sonarr-repo-only/NzbDrone.Core.Test/Ninject.Moq/MockProvider.cs

using System;
using System.Collections.Generic;
using Moq;
using Ninject.Activation;
using Ninject.Injection;

namespace Ninject.Moq
{
    /// <summary>
    ///   Creates mocked instances via Moq.
    /// </summary>
    public class MockProvider : IProvider
    {
        private static readonly Dictionary<Type, ConstructorInjector> _injectors =
            new Dictionary<Type, ConstructorInjector>();

        /// <summary>
        ///   Initializes a new instance of the <see cref = "MockProvider" /> class.
        /// </summary>
        /// <param name = "injectorFactory">The injector factory component.</param>
        public MockProvider(IInjectorFactory injectorFactory)
        {
            InjectorFactory = injectorFactory;
        }

        /// <summary>
        ///   Gets the injector factory component.
        /// </summary>
        public IInjectorFactory InjectorFactory { get; private set; }

        #region IProvider Members

        /// <summary>
        ///   Gets the type (or prototype) of instances the provider creates.
        /// </summary>
        public Type Type
        {
            get { return typeof (Mock<>); }
        }

        /// <summary>
        ///   Creates an instance within the specified context.
        /// </summary>
        /// <param name = "context">The context.</param>
        /// <returns>The created instance.</returns>
        public object Create(IContext context)
        {
            ConstructorInjector injector = GetInjector(context.Request.Service);
            var mock = injector.Invoke() as Mock;
            return mock.Object;
        }

        #endregion

        private ConstructorInjector GetInjector(Type service)
        {
            lock (_injectors)
            {
                Type mockType = typeof (Mock<>).MakeGenericType(service);

                if (_injectors.ContainsKey(mockType))
                    return _injectors[mockType];

                ConstructorInjector injector = InjectorFactory.Create(mockType.GetConstructor(Type.EmptyTypes));
                _injectors[mockType] = injector;

                return injector;
            }
        }

        /// <summary>
        ///   Gets a callback that creates an instance of the <see cref = "MockProvider" />.
        /// </summary>
        /// <returns>The created callback.</returns>
        public static Func<IContext, IProvider> GetCreationCallback()
        {
            return ctx => new MockProvider(ctx.Kernel.Components.Get<IInjectorFactory>());
        }
    }
}