Service manager for unity (for accessing single instances of objects globally) and tests

Services.cs

using System;
using System.Collections.Generic;

/// <summary>
/// Simple service manager. Allows global access to a single instance of any class.
/// Copyright (c) 2014-2017 Eliot Lash
/// </summary>
public class Services
{
    //Statics
    private static Services _instance;

    //Instance
    private Dictionary<Type, object> services = new Dictionary<Type, object>();

    private Services() {
        if (_instance != null) {
            UnityEngine.Debug.LogError("Cannot have two instances of singleton.");
        }
    }

    /// <summary>
    /// Getter for singelton instance.
    /// </summary>
    public static Services instance {
        get {
            if (_instance == null) {
                _instance = new Services();
            }

            return _instance;
        }
    }

    /// <summary>
    /// Set the specified service instance. Usually called like Set<ExampleService>(this).
    /// </summary>
    /// <param name="service">Service instance object.</param>
    /// <typeparam name="T">Type of the instance object.</typeparam>
    public void Set<T>(T service) where T : class {
        services.Add(typeof(T), service);
    }

    /// <summary>
    /// Removes the specified service.
    /// </summary>
    /// <typeparam name="T">Type of the instance object.</typeparam>
    public void Remove<T>() where T : class {
        services.Remove(typeof(T));
    }

    /// <summary>
    /// Removes the specified service instance.
    /// In cases such as where a MonoBehaviour is cleaning itself up in OnDestroy but this call is delayed
    /// for several frames, using this method will ensure that a newer instance of the service is not removed
    /// by the older instance being destroyed.
    /// </summary>
    /// <param name="service">Service instance object.</param>
    /// <typeparam name="T">Type of the instance object.</typeparam>
    public void Remove<T>(T service) where T : class {
        if (services.ContainsValue(service)) {
            services.Remove(typeof(T));
        }
    }

    /// <summary>
    /// Gets the specified service instance. Called like Get<ExampleService>().
    /// </summary>
    /// <typeparam name="T">Type of the service.</typeparam>
    /// <returns>Service instance, or null if not initialized</returns>
    public T Get<T>() where T : class {
        T ret = null;
        try {
            ret = services[typeof(T)] as T;
        } catch (KeyNotFoundException) {
        }
        return ret;
    }

    /// <summary>
    /// Clears internal dictionary of service instances.
    /// This will not clear out any global state that they contain,
    /// unless there are no other references to the object.
    /// </summary>
    public void Clear() {
        services.Clear();
    }
}

ServicesSpec.cs

using NUnit.Framework;

public class ServicesSpec
{
    class MockService1 {}
    class MockService2 {}

    [SetUp]
    public void SetUp() {
        Services.instance.Clear();
    }

    public class Singleton : ServicesSpec
    {
        [Test]
        public void ShouldReturnServiceInstance() {
            Assert.That(Services.instance, Is.InstanceOf(typeof(Services)));
        }

        [Test]
        public void ShouldReturnSameServiceInstanceOnMultipleCalls() {
            var services = Services.instance;
            var services2 = Services.instance;
            Assert.That(services, Is.SameAs(services2));
        }

        [Test]
        public void ShouldReturnSameServiceInstanceAfterClear() {
            var services = Services.instance;
            services.Clear();
            var services2 = Services.instance;
            Assert.That(services, Is.SameAs(services2));
        }
    }

    public class SetAndGet : ServicesSpec
    {
        [Test]
        public void ShouldSetAndGetService() {
            var services = Services.instance;
            var mockService = new MockService1();
            services.Set<MockService1>(mockService);
            Assert.That(services.Get<MockService1>(), Is.SameAs(mockService));
        }

        [Test]
        public void ShouldThrowWhenSettingSameServiceTwice() {
            var services = Services.instance;
            services.Set<MockService1>(new MockService1());
            Assert.That(
                () => services.Set<MockService1>(new MockService1()),
                Throws.ArgumentException
            );
        }
    }

    public class Clear : ServicesSpec
    {
        [Test]
        public void ShouldRemoveAllServices() {
            var services = Services.instance;
            services.Set<MockService1>(new MockService1());
            services.Set<MockService2>(new MockService2());
            services.Clear();
            Assert.That(services.Get<MockService1>(), Is.Null);
            Assert.That(services.Get<MockService2>(), Is.Null);
        }
    }

    public class Remove : ServicesSpec
    {
        [Test]
        public void ShouldRemoveType() {
            var services = Services.instance;
            services.Set<MockService1>(new MockService1());
            services.Set<MockService2>(new MockService2());
            services.Remove<MockService1>();
            Assert.That(services.Get<MockService1>(), Is.Null);
            Assert.That(services.Get<MockService2>(), Is.InstanceOf(typeof(MockService2)));
        }
    }

    public class RemoveInstance : ServicesSpec
    {
        [Test]
        public void ShouldRemoveInstanceType() {
            var services = Services.instance;
            var firstInstance = new MockService1();
            services.Set<MockService1>(firstInstance);
            services.Remove<MockService1>();
            services.Set<MockService1>(new MockService1());
            services.Remove<MockService1>(firstInstance);
            Assert.That(services.Get<MockService1>(), Is.InstanceOf(typeof(MockService1)));
            Assert.That(services.Get<MockService1>(), Is.Not.SameAs(firstInstance));
        }
    }
}