public AddGuidColumn(BonoboGitServerContext context)
        {
            AuthProvider = DependencyResolver.Current.GetService<IAuthenticationProvider>();

            _db = context.Database;

            if (UpgradeHasAlreadyBeenRun())
            {
                return;
            }

            using (var trans = context.Database.BeginTransaction())
            {
                try
                {
                    RenameTables();
                    CreateTables();
                    CopyData();
                    AddRelations();
                    DropRenamedTables();
                    trans.Commit();
                }
                catch (Exception)
                {
                    trans.Rollback();
                    throw;
                }
            }
        }

        public EventStoreEmbeddedNodeConnection(ConnectionSettings settings, string connectionName, IPublisher publisher, ISubscriber bus, IAuthenticationProvider authenticationProvider)
        {
            Ensure.NotNull(publisher, "publisher");
            Ensure.NotNull(settings, "settings");

            Guid connectionId = Guid.NewGuid();

            _settings = settings;
            _connectionName = connectionName;
            _publisher = publisher;
            _authenticationProvider = authenticationProvider;
            _subscriptionBus = new InMemoryBus("Embedded Client Subscriptions");
            _subscriptions = new EmbeddedSubscriber(_subscriptionBus, _authenticationProvider, _settings.Log, connectionId);
            
            _subscriptionBus.Subscribe<ClientMessage.SubscriptionConfirmation>(_subscriptions);
            _subscriptionBus.Subscribe<ClientMessage.SubscriptionDropped>(_subscriptions);
            _subscriptionBus.Subscribe<ClientMessage.StreamEventAppeared>(_subscriptions);
            _subscriptionBus.Subscribe<ClientMessage.PersistentSubscriptionConfirmation>(_subscriptions);
            _subscriptionBus.Subscribe<ClientMessage.PersistentSubscriptionStreamEventAppeared>(_subscriptions);
            _subscriptionBus.Subscribe(new AdHocHandler<ClientMessage.SubscribeToStream>(_publisher.Publish));
            _subscriptionBus.Subscribe(new AdHocHandler<ClientMessage.UnsubscribeFromStream>(_publisher.Publish));
            _subscriptionBus.Subscribe(new AdHocHandler<ClientMessage.ConnectToPersistentSubscription>(_publisher.Publish));

            bus.Subscribe(new AdHocHandler<SystemMessage.BecomeShutdown>(_ => Disconnected(this, new ClientConnectionEventArgs(this, new IPEndPoint(IPAddress.None, 0)))));
        }

 /// <summary>
 /// Instantiates a new OneDriveClient.
 /// </summary>
 /// <param name="baseUrl">The base service URL. For example, "https://api.onedrive.com/v1.0."</param>
 /// <param name="authenticationProvider">The <see cref="IAuthenticationProvider"/> for authenticating request messages.</param>
 /// <param name="httpProvider">The <see cref="IHttpProvider"/> for sending requests.</param>
 public OneDriveClient(
     string baseUrl,
     IAuthenticationProvider authenticationProvider,
     IHttpProvider httpProvider = null)
     : base(baseUrl, authenticationProvider, httpProvider)
 {
 }

 /// <summary>
 /// Erstellt eine neue Instanz von TcpCustomServerProtocolSetup.
 /// </summary>
 /// <param name="tcpPort">TCP-Anschlußnummer</param>
 /// <param name="authProvider">Authentifizierungsanbieter</param>
 public TcpCustomServerProtocolSetup(int tcpPort,IAuthenticationProvider authProvider)
     : this()
 {
     // Werte übernehmen
     TcpPort = tcpPort;
     AuthenticationProvider=authProvider;
 }

 public VartotojaiController(IAuthenticationProvider authenticationProvider, ISessionFactory sessionFactory, [LoggedIn] UserInformation loggedInUser, HashAlgorithm hashAlgorithm)
 {
     _authenticationProvider = authenticationProvider;
     _sessionFactory = sessionFactory;
     _loggedInUser = loggedInUser;
     _hashAlgorithm = hashAlgorithm;
 }

 public SettingsController(IUserReaderService userReaderService, IUserWriterService userWriterService, IAuthenticationProvider authenticationProvider, ILoggerFactory loggerFactory)
 {
     _userReaderService = userReaderService;
     _userWriterService = userWriterService;
     _authenticationProvider = authenticationProvider;
     _logger = loggerFactory.GetLogger("Settings");
 }

        public AuthenticationRegistry(IAuthenticationProvider facebookProvider,
                                      IAuthenticationProvider googleProvider,
                                      IAuthenticationProvider twitterProvider)
        {
            var authenticationService = new AuthenticationService();

            if (facebookProvider != null)
            {
                authenticationService.AddProvider(facebookProvider);
            }

            if (googleProvider != null)
            {
                authenticationService.AddProvider(googleProvider);
            }

            if (twitterProvider != null)
            {
                authenticationService.AddProvider(twitterProvider);
            }

            For<IAuthenticationService>()
                .Use(authenticationService)
                .Named("Authentication Service.");
        }

        public MqttIotHubAdapter(Settings settings, DeviceClientFactoryFunc deviceClientFactory, ISessionStatePersistenceProvider sessionStateManager, IAuthenticationProvider authProvider,
            ITopicNameRouter topicNameRouter, IQos2StatePersistenceProvider qos2StateProvider)
        {
            Contract.Requires(settings != null);
            Contract.Requires(sessionStateManager != null);
            Contract.Requires(authProvider != null);
            Contract.Requires(topicNameRouter != null);

            if (qos2StateProvider != null)
            {
                this.maxSupportedQosToClient = QualityOfService.ExactlyOnce;
                this.qos2StateProvider = qos2StateProvider;
            }
            else
            {
                this.maxSupportedQosToClient = QualityOfService.AtLeastOnce;
            }

            this.settings = settings;
            this.deviceClientFactory = deviceClientFactory;
            this.sessionStateManager = sessionStateManager;
            this.authProvider = authProvider;
            this.topicNameRouter = topicNameRouter;

            this.publishProcessor = new PacketAsyncProcessor<PublishPacket>(this.PublishToServerAsync);
            this.publishProcessor.Completion.OnFault(ShutdownOnPublishToServerFaultAction);

            TimeSpan? ackTimeout = this.settings.DeviceReceiveAckCanTimeout ? this.settings.DeviceReceiveAckTimeout : (TimeSpan?)null;
            this.publishPubAckProcessor = new RequestAckPairProcessor<AckPendingMessageState, PublishPacket>(this.AcknowledgePublishAsync, this.RetransmitNextPublish, ackTimeout);
            this.publishPubAckProcessor.Completion.OnFault(ShutdownOnPubAckFaultAction);
            this.publishPubRecProcessor = new RequestAckPairProcessor<AckPendingMessageState, PublishPacket>(this.AcknowledgePublishReceiveAsync, this.RetransmitNextPublish, ackTimeout);
            this.publishPubRecProcessor.Completion.OnFault(ShutdownOnPubRecFaultAction);
            this.pubRelPubCompProcessor = new RequestAckPairProcessor<CompletionPendingMessageState, PubRelPacket>(this.AcknowledgePublishCompleteAsync, this.RetransmitNextPublishRelease, ackTimeout);
            this.pubRelPubCompProcessor.Completion.OnFault(ShutdownOnPubCompFaultAction);
        }

 public AccountController(IOpenIdMembershipService openIdMembershipService, IAuthenticationProvider authenticationProvider, IUserService userService, IUserProvider userProvider)
 {
     this.openIdMembershipService = openIdMembershipService;
     this.authenticationProvider = authenticationProvider;
     this.userService = userService;
     this.userProvider = userProvider;
 }

 public ServiceUrlBuilder(ServiceType serviceType, IAuthenticationProvider authenticationProvider, string region, bool useInternalUrl)
 {
     _serviceType = serviceType;
     _authenticationProvider = authenticationProvider;
     _region = region;
     _useInternalUrl = useInternalUrl;
 }

        public LifeCycleManager(IAuthenticationProvider authenticationProvider, String entityType)
        {
            Debug.WriteLine("Create new instance of LifeCycleManager for entityType '{0}'", entityType);
            _entityType = entityType;

            lock (_lock)
            {
                if (null == _staticStateMachineConfigLoader)
                {
                    LoadAndComposeParts();
                    _staticStateMachineConfigLoader = _stateMachineConfigLoader;
                    _staticCalloutExecutor = _calloutExecutor;
                }
                else
                {
                    _stateMachineConfigLoader = _staticStateMachineConfigLoader;
                    _calloutExecutor = _staticCalloutExecutor;
                }
            }
            _coreService = new CumulusCoreService.Core(new Uri(ConfigurationManager.AppSettings[CORE_ENDPOINT_URL_KEY]));
            _coreService.BuildingRequest += CoreServiceOnBuildingRequest;

            _entityController = new EntityController(authenticationProvider);
            _stateMachine = new StateMachine.StateMachine();
            ConfigureStateMachine(entityType);
        }

 protected override void EstablishContext()
 {
     wimpProvider = mocks.StrictMock<IWimpProvider>();
     staffInformationProvider = mocks.Stub<IStaffInformationProvider>();
     authenticationProvider = mocks.Stub<IAuthenticationProvider>();
     userClaimsProvider = mocks.Stub<IUserClaimsProvider>();
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="CmisSync.Lib.Queueing.ConnectionScheduler"/> class.
        /// </summary>
        /// <param name="repoInfo">Repo info.</param>
        /// <param name="queue">Event queue.</param>
        /// <param name="sessionFactory">Session factory.</param>
        /// <param name="authProvider">Auth provider.</param>
        /// <param name="interval">Retry interval in msec.</param>
        public ConnectionScheduler(
            RepoInfo repoInfo,
            ISyncEventQueue queue,
            ISessionFactory sessionFactory,
            IAuthenticationProvider authProvider,
            int interval = 5000)
        {
            if (interval <= 0) {
                throw new ArgumentException(string.Format("Given Interval \"{0}\" is smaller or equal to null", interval));
            }

            if (repoInfo == null) {
                throw new ArgumentNullException("repoInfo");
            }

            if (queue == null) {
                throw new ArgumentNullException("queue");
            }

            if (sessionFactory == null) {
                throw new ArgumentNullException("sessionFactory");
            }

            if (authProvider == null) {
                throw new ArgumentNullException("authProvider");
            }

            this.Queue = queue;
            this.SessionFactory = sessionFactory;
            this.RepoInfo = repoInfo;
            this.AuthProvider = authProvider;
            this.Interval = interval;
        }

 /// <summary>
 /// Erstellt eine neue Instanz von HttpCustomServerProtocolSetup.
 /// </summary>
 /// <param name="httpPort">HTTP-Anschlußnummer</param>
 /// <param name="authProvider">Authentifizierungsanbieter</param>
 public HttpCustomServerProtocolSetup(int httpPort, IAuthenticationProvider authProvider)
     : this()
 {
     // Werte übernehmen
     HttpPort = httpPort;
     AuthenticationProvider = authProvider;
 }

 public IdentityClaimsGetOutputClaimsIdentityProvider(IStaffInformationProvider staffInformationProvider, IAuthenticationProvider authenticationProvider,
     IDashboardUserClaimsInformationProvider<EdFiUserSecurityDetails> dashboardUserClaimsInformationProvider, IHttpRequestProvider httpRequestProvider)
 {
     this.staffInformationProvider = staffInformationProvider;
     this.authenticationProvider = authenticationProvider;
     this.dashboardUserClaimsInformationProvider = dashboardUserClaimsInformationProvider;
     this.httpRequestProvider = httpRequestProvider;
 }

 public GetImpersonatedClaimsDataProvider(IWimpProvider wimpProvider, IStaffInformationProvider staffInformationProvider,
     IAuthenticationProvider authenticationProvider, IUserClaimsProvider userClaimsProvider)
 {
     this.wimpProvider = wimpProvider;
     this.staffInformationProvider = staffInformationProvider;
     this.authenticationProvider = authenticationProvider;
     this.userClaimsProvider = userClaimsProvider;
 }

 public AccountProvider(IAuthenticationProvider authenticationProvider, ICaptchaProvider captchaProvider,
                        IEmailProvider emailProvider, IMobileProvider mobileProvider)
 {
     _authenticationProvider = authenticationProvider;
     _captchaProvider = captchaProvider;
     _emailProvider = emailProvider;
     _mobileProvider = mobileProvider;
 }

 public void Initialize(IPipeline pipelineRunner)
 {
     _authentication = _resolver.Resolve<IAuthenticationProvider>();
     pipelineRunner.Notify(ReadCredentials)
         .After<KnownStages.IBegin>()
         .And
         .Before<KnownStages.IHandlerSelection>();
 }

 public static FlurlClient Authenticate(this FlurlClient client, IAuthenticationProvider authenticationProvider)
 {
     var authenticatedMessageHandler = client.HttpMessageHandler as AuthenticatedMessageHandler;
     if (authenticatedMessageHandler != null)
     {
         authenticatedMessageHandler.AuthenticationProvider = authenticationProvider;
     }
     return client;
 }

        public void SetUp()
        {
            ServiceLocatorInitializer.Init();
            controller = new MembershipController();

            mockedMembershipProvider = MockRepository.GenerateMock<IMembershipProvider>();
            mockedAuthenticationProvider = MockRepository.GenerateMock<IAuthenticationProvider>();
            mockedAuthorizationProvider = MockRepository.GenerateMock<IAuthorizationProvider>();
        }