VisualStudio/test/GitHub.App.UnitTests/Substitutes.cs

using GitHub.Authentication;
using GitHub.Models;
using GitHub.Services;
using GitHub.VisualStudio;
using Microsoft.VisualStudio.ComponentModelHost;
using NSubstitute;
using Rothko;
using System;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using GitHub.Factories;
using GitHub.Api;
using Microsoft.VisualStudio.Threading;

namespace UnitTests
{
    internal static class Substitutes
    {
        public static T1 For<T1, T2, T3, T4>(params object[] constructorArguments)
            where T1 : class
            where T2 : class
            where T3 : class
            where T4 : class
        {
            return (T1)Substitute.For(new Type[4]
            {
                typeof (T1),
                typeof (T2),
                typeof (T3),
                typeof (T4)
            }, constructorArguments);
        }

        public static IGitService IGitService { get { return Substitute.For<IGitService>(); } }

        public static IViewViewModelFactory ViewViewModelFactory { get { return Substitute.For<IViewViewModelFactory>(); } }

        public static IRepositoryCreationService RepositoryCreationService { get { return Substitute.For<IRepositoryCreationService>(); } }
        public static IRepositoryCloneService RepositoryCloneService { get { return Substitute.For<IRepositoryCloneService>(); } }

        public static IConnection Connection { get { return Substitute.For<IConnection>(); } }
        public static IConnectionManager ConnectionManager { get { return Substitute.For<IConnectionManager>(); } }
        public static IDelegatingTwoFactorChallengeHandler TwoFactorChallengeHandler { get { return Substitute.For<IDelegatingTwoFactorChallengeHandler>(); } }
        public static IGistPublishService GistPublishService { get { return Substitute.For<IGistPublishService>(); } }
        public static IPullRequestService PullRequestService { get { return Substitute.For<IPullRequestService>(); } }

        /// <summary>
        /// This returns a service provider with everything mocked except for 
        /// RepositoryCloneService and RepositoryCreationService, which are real
        /// instances.
        /// </summary>
        public static IGitHubServiceProvider ServiceProvider { get { return GetServiceProvider(); } }

        /// <summary>
        /// This returns a service provider with mocked IRepositoryCreationService and
        /// IRepositoryCloneService as well as all other services mocked. The regular
        /// GetServiceProvider method (and ServiceProvider property return a IServiceProvider
        /// with real RepositoryCloneService and RepositoryCreationService instances.
        /// </summary>
        /// <returns></returns>
        public static IServiceProvider GetFullyMockedServiceProvider()
        {
            return GetServiceProvider(RepositoryCloneService, RepositoryCreationService);
        }

        /// <summary>
        /// This returns a service provider with everything mocked except for 
        /// RepositoryCloneService and RepositoryCreationService, which are real
        /// instances.
        /// </summary>
        /// <param name="cloneService"></param>
        /// <param name="creationService"></param>
        /// <returns></returns>
        public static IGitHubServiceProvider GetServiceProvider(
            IRepositoryCloneService cloneService = null,
            IRepositoryCreationService creationService = null,
            IAvatarProvider avatarProvider = null)
        {
            var ret = Substitute.For<IGitHubServiceProvider, IServiceProvider>();

            var gitservice = IGitService;
            var cm = Substitute.For<SComponentModel, IComponentModel>();
            var cc = new CompositionContainer(CompositionOptions.IsThreadSafe | CompositionOptions.DisableSilentRejection);
            cc.ComposeExportedValue(gitservice);
            ((IComponentModel)cm).DefaultExportProvider.Returns(cc);
            ret.GetService(typeof(SComponentModel)).Returns(cm);
            Services.UnitTestServiceProvider = ret;

            var clone = cloneService ?? new RepositoryCloneService(Substitute.For<IOperatingSystem>(),
                Substitute.For<IVSGitServices>(), Substitute.For<ITeamExplorerServices>(),
                Substitute.For<IGraphQLClientFactory>(), Substitute.For<IGitHubContextService>(),
                Substitute.For<IUsageTracker>(), ret, new JoinableTaskContext());
            var create = creationService ?? new RepositoryCreationService(clone);
            avatarProvider = avatarProvider ?? Substitute.For<IAvatarProvider>();
            ret.GetService(typeof(IGitService)).Returns(gitservice);
            ret.GetService(typeof(IVSServices)).Returns(Substitute.For<IVSServices>());
            ret.GetService(typeof(ITeamExplorerServices)).Returns(Substitute.For<ITeamExplorerServices>());
            ret.GetService(typeof(IGraphQLClientFactory)).Returns(Substitute.For<IGraphQLClientFactory>());
            ret.GetService(typeof(IGitHubContextService)).Returns(Substitute.For<IGitHubContextService>());
            ret.GetService(typeof(IVSGitExt)).Returns(Substitute.For<IVSGitExt>());
            ret.GetService(typeof(IUsageTracker)).Returns(Substitute.For<IUsageTracker>());
            ret.GetService(typeof(IVSGitServices)).Returns(Substitute.For<IVSGitServices>());
            ret.GetService(typeof(IOperatingSystem)).Returns(Substitute.For<IOperatingSystem>());
            ret.GetService(typeof(IRepositoryCloneService)).Returns(clone);
            ret.GetService(typeof(IRepositoryCreationService)).Returns(create);
            ret.GetService(typeof(IViewViewModelFactory)).Returns(ViewViewModelFactory);
            ret.GetService(typeof(IConnection)).Returns(Connection);
            ret.GetService(typeof(IConnectionManager)).Returns(ConnectionManager);
            ret.GetService(typeof(IAvatarProvider)).Returns(avatarProvider);
            ret.GetService(typeof(IDelegatingTwoFactorChallengeHandler)).Returns(TwoFactorChallengeHandler);
            ret.GetService(typeof(IGistPublishService)).Returns(GistPublishService);
            ret.GetService(typeof(IPullRequestService)).Returns(PullRequestService);
            return ret;
        }

        public static IVSServices GetVSServices(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IVSServices)) as IVSServices;
        }

        public static ITeamExplorerServices GetTeamExplorerServices(this IServiceProvider provider)
        {
            return provider.GetService(typeof(ITeamExplorerServices)) as ITeamExplorerServices;
        }

        public static IGraphQLClientFactory GetGraphQLClientFactory(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IGraphQLClientFactory)) as IGraphQLClientFactory;
        }

        public static IGitHubContextService GetGitHubContextService(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IGitHubContextService)) as IGitHubContextService;
        }

        public static IVSGitExt GetVSGitExt(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IVSGitExt)) as IVSGitExt;
        }

        public static IUsageTracker GetUsageTracker(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IUsageTracker)) as IUsageTracker;
        }

        public static IVSGitServices GetVSGitServices(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IVSGitServices)) as IVSGitServices;
        }

        public static IGitService GetGitService(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IGitService)) as IGitService;
        }

        public static IOperatingSystem GetOperatingSystem(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IOperatingSystem)) as IOperatingSystem;
        }

        public static IRepositoryCloneService GetRepositoryCloneService(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IRepositoryCloneService)) as IRepositoryCloneService;
        }

        public static IRepositoryCreationService GetRepositoryCreationService(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IRepositoryCreationService)) as IRepositoryCreationService;
        }

        public static IViewViewModelFactory GetExportFactoryProvider(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IViewViewModelFactory)) as IViewViewModelFactory;
        }

        public static IConnection GetConnection(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IConnection)) as IConnection;
        }

        public static IConnectionManager GetConnectionManager(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IConnectionManager)) as IConnectionManager;
        }

        public static IAvatarProvider GetAvatarProvider(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IAvatarProvider)) as IAvatarProvider;
        }

        public static IDelegatingTwoFactorChallengeHandler GetTwoFactorChallengeHandler(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IDelegatingTwoFactorChallengeHandler)) as IDelegatingTwoFactorChallengeHandler;
        }

        public static IGistPublishService GetGistPublishService(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IGistPublishService)) as IGistPublishService;
        }

        public static IPullRequestService GetPullRequestsService(this IServiceProvider provider)
        {
            return provider.GetService(typeof(IPullRequestService)) as IPullRequestService;
        }
    }
}