public void SetUp()
 {
   AppraiserSignUpService = Substitute.For<IAppraiserSignUpService>();
   AuthProvider = Substitute.For<IAuthProvider>();
   Target = new AppraiserSignUpController(AppraiserSignUpService, AuthProvider);
   Target.CommitProviderInstance = Substitute.For<ICommitProvider>();
 }

 public VerifyUserAccountController(IUserRepo urep, IAuthProvider auth, IAccountRepo account, ICCFolderRepo folderRep)
 {
     userRepository = urep;
     authProvider = auth;
     accRepository = account;
     CCFolderRepository = folderRep;
 }

 /// <summary>
 /// Creates a new instance. This class is also used to shareable a context across all instance that are created below one Cluster instance.
 /// One configuration instance per Cluster instance.
 /// </summary>
 internal Configuration(Policies policies,
     ProtocolOptions protocolOptions,
     PoolingOptions poolingOptions,
     SocketOptions socketOptions,
     ClientOptions clientOptions,
     IAuthProvider authProvider,
     IAuthInfoProvider authInfoProvider,
     QueryOptions queryOptions,
     IAddressTranslator addressTranslator)
 {
     if (addressTranslator == null)
     {
         throw new ArgumentNullException("addressTranslator");
     }
     if (queryOptions == null)
     {
         throw new ArgumentNullException("queryOptions");
     }
     _policies = policies;
     _protocolOptions = protocolOptions;
     _poolingOptions = poolingOptions;
     _socketOptions = socketOptions;
     _clientOptions = clientOptions;
     _authProvider = authProvider;
     _authInfoProvider = authInfoProvider;
     _queryOptions = queryOptions;
     _addressTranslator = addressTranslator;
 }

        internal ControlConnection(Cluster cluster,
                                   IEnumerable<IPAddress> clusterEndpoints,
                                   Policies policies,
                                   ProtocolOptions protocolOptions,
                                   PoolingOptions poolingOptions,
                                   SocketOptions socketOptions,
                                   ClientOptions clientOptions,
                                   IAuthProvider authProvider,
                                   IAuthInfoProvider authInfoProvider)
        {
            _cluster = cluster;
            _reconnectionSchedule = _reconnectionPolicy.NewSchedule();
            _reconnectionTimer = new Timer(ReconnectionClb, null, Timeout.Infinite, Timeout.Infinite);

            var config = new Configuration
            (
                policies,
                protocolOptions,
                poolingOptions,
                socketOptions,
                clientOptions,
                authProvider,
                authInfoProvider,
                new QueryOptions()
            );

            _session = new Session(cluster, config, "", ControlConnectionProtocolVersion);
        }

 public StartupParams(IAuthProvider provider, IPathManager pathManager,
     ICustomNodeManager customNodeManager)
 {
     this.authProvider = provider;
     this.pathManager = pathManager;
     this.customNodeManager = customNodeManager;
 }

        public AuthFeature(Func<IAuthSession> sessionFactory, IAuthProvider[] authProviders, string htmlRedirect = null)
        {
            this.sessionFactory = sessionFactory;
            this.authProviders = authProviders;

            Func<string,string> localize = HostContext.ResolveLocalizedString;

            ServiceRoutes = new Dictionary<Type, string[]> {
                { typeof(AuthenticateService), new[]
                    {
                        "/" + localize(LocalizedStrings.Auth), 
                        "/" + localize(LocalizedStrings.Auth) + "/{provider}", 
                        "/" + localize(LocalizedStrings.Authenticate), 
                        "/" + localize(LocalizedStrings.Authenticate) + "/{provider}",
                    } },
                { typeof(AssignRolesService), new[]{ "/" + localize(LocalizedStrings.AssignRoles) } },
                { typeof(UnAssignRolesService), new[]{ "/" + localize(LocalizedStrings.UnassignRoles) } },
            };

            RegisterPlugins = new List<IPlugin> {
                new SessionFeature()                          
            };

            this.HtmlRedirect = htmlRedirect ?? "~/" + localize(LocalizedStrings.Login);
        }

        public AuthFeature(Func<IAuthSession> sessionFactory, IAuthProvider[] authProviders, string htmlRedirect = null)
        {
            this.sessionFactory = sessionFactory;
            this.authProviders = authProviders;

            Func<string,string> localize = s => HostContext.AppHost.ResolveLocalizedString(s, null);

            ServiceRoutes = new Dictionary<Type, string[]> {
                { typeof(AuthenticateService), new[]
                    {
                        "/" + localize(LocalizedStrings.Auth), 
                        "/" + localize(LocalizedStrings.Auth) + "/{provider}", 
                        "/" + localize(LocalizedStrings.Authenticate), 
                        "/" + localize(LocalizedStrings.Authenticate) + "/{provider}",
                    } },
                { typeof(AssignRolesService), new[]{ "/" + localize(LocalizedStrings.AssignRoles) } },
                { typeof(UnAssignRolesService), new[]{ "/" + localize(LocalizedStrings.UnassignRoles) } },
            };

            RegisterPlugins = new List<IPlugin> {
                new SessionFeature()        
            };

            AuthEvents = new List<IAuthEvents>();

            this.HtmlRedirect = htmlRedirect ?? "~/" + localize(LocalizedStrings.Login);
            this.IncludeAuthMetadataProvider = true;
            this.ValidateUniqueEmails = true;
            this.DeleteSessionCookiesOnLogout = true;
        }

 public UserController(IAuthProvider authProvider)
 {
     _postService = new PostServiceClient();
     _friendService = new FriendServiceClient();
     _userService = new UserServiceClient();
     _authProvider = authProvider;
     _commentService = new CommentServiceClient();
 }

 public Gist(
     ILogProvider logProvider,
     ICacheProvider cacheProvider,
     IAuthProvider authProvider)
     : base(
         logProvider,
         cacheProvider,
         authProvider) { }

 public SettingsController(IUserService userService, IAuthProvider authProvider, 
     ILocationService locationService, IHash hash)
 {
     _userService = new UserServiceClient();
     _authProvider = authProvider;
     _locationService = new LocationServiceClient();
     _hash = hash;
 }

    public void SetUp()
    {
      _authProvider = MockRepository.GenerateMock<IAuthProvider>();
      _adminController = new AdminController(_authProvider);

      var httpContextMock = MockRepository.GenerateMock<HttpContextBase>();
      _adminController.Url = new UrlHelper(new RequestContext(httpContextMock, new RouteData()));
    }

 public override void Configure(Container container)
 {
     var authProviders = new IAuthProvider[] { new AadAuthProvider(AppSettings) };
     Plugins.Add(new AuthFeature(
         () => new AuthUserSession(), 
         authProviders,
         htmlRedirect: "/auth/aad"));
 }

		protected AbstractMasterDetailPage (IAuthProvider ap) : base()
		{
			Icon = GetIcon();

			this.ap = ap;
			ShowPersonalPages (ap.AuthState.IsAuthorised);
			ap.AuthState.OnAuthChange += OnAuthChange;
		}

		public HomeController(IUsersManagement userManagement,
			IAuthProvider authenticationProvider, IUserAccessHelper userAccessHelper, IAppraiserManagement appraiserManagement, ITaskManager taskManager)
		{
			_userManagement = userManagement;
			_authenticationProvider = authenticationProvider;
			_userAccessHelper = userAccessHelper;
			_appraiserManagement = appraiserManagement;
			_taskManager = taskManager;
		}

 private async Task InstallNew(GroupContent mod, IAuthProvider provider, Action<SyncOptions> config,
     IAbsoluteDirectoryPath folder) {
     SetupHosts(mod, provider);
     var opts = new SyncOptions();
     config(opts);
     await
         Repository.Factory.Clone(opts.Hosts, folder.ToString(), config)
             .ConfigureAwait(false);
 }

        public BasicAuthenticationModule()
        {
            var provider = ConfigReader.GetConfigValue("ODataTFS.AuthProvider");
            var tfsServer = ConfigReader.GetConfigValue("ODataTFS.TfsServer");

            var providerType = Type.GetType(provider, true);
            var tfsServerUri = new Uri(tfsServer, UriKind.Absolute);

            this.authProvider = Activator.CreateInstance(providerType, new[] { tfsServerUri }) as IAuthProvider;
        }

 public StartupParams(IAuthProvider provider, IPathManager pathManager,
     ILibraryLoader libraryLoader, ICustomNodeManager customNodeManager,
     Version dynamoVersion)
 {
     this.authProvider = provider;
     this.pathManager = pathManager;
     this.libraryLoader = libraryLoader;
     this.customNodeManager = customNodeManager;
     this.dynamoVersion = dynamoVersion;
 }

        public AccountController(IAuthProvider authProvider, IAccountRepository accountRepository)
        {
            Guard.ArgNotNull(authProvider, "authProvider");
            Guard.ArgNotNull(accountRepository, "accountRepository");

            _authProvider = authProvider;
            _accountRepository = accountRepository;
            if (_managerService == null)
                _managerService = new SnippetCacheManagerServiceClient();
        }

 public LoginController(IAuthProvider auth, IUserRepo userRepo, ICCFolderRepo folder, IAccountRepo account, ICCTokenRepo token, INotificationManager notifMgr, ICCItemRepo item, ICCErrorLogRepo errorlogs)
 {
     authProvider = auth;
     userRepository = userRepo;
     CCFolderRepository = folder;
     accRepository = account;
     CCTokenRepository = token;
     notifManager = notifMgr;
     items = item;
     CCErrorLogRepository = errorlogs;
 }

        public AuthenticationManager(IAuthProvider authProvider)
        {
            this.authProvider = authProvider;

            // The lack of AuthProvider indicates that the user cannot login for this
            // session.  Hence, we do not subscribe to this event.
            if (this.authProvider != null)
            {
                this.authProvider.LoginStateChanged += OnLoginStateChanged;
            }
        }