public ServiceController(ServiceStackHost appHost, params Assembly[] assembliesWithServices)
            : this(appHost)
        {
            if (assembliesWithServices == null || assembliesWithServices.Length == 0)
                throw new ArgumentException(
                    "No Assemblies provided in your AppHost's base constructor.\n"
                    + "To register your services, please provide the assemblies where your web services are defined.");

            this.ResolveServicesFn = () => GetAssemblyTypes(assembliesWithServices);
        }

        public void OnTestFixtureStartUp()
        {
            appHost = new ExampleAppHostHttpListener()
                .Init()
                .Start(ListeningOn);

            "ExampleAppHost Created at {0}, listening on {1}".Print(DateTime.Now, ListeningOn);
        }

        public void OnTestFixtureStartUp()
        {
            appHost = new ExampleAppHostHttpListenerPool()
                .Init()
                .Start(ListeningOn);

            Console.WriteLine("ExampleAppHost Created at {0}, listening on {1}", DateTime.Now, ListeningOn);
        }

        public void TestFixtureSetUp()
        {
            DynamoMetadata.Reset();
            var db = CreatePocoDynamo();
            db.DeleteAllTables(TimeSpan.FromMinutes(1));

            appHost = new BasicAppHost()
                .Init();
        }

        public void TestFixtureSetUp()
        {
            appHost = new RedisMqAppHost()
                .Init()
                .Start(ListeningOn);

            using (var redis = appHost.TryResolve<IRedisClientsManager>().GetClient())
                redis.FlushAll();
        }

 public UnitTests()
 {
     appHost = new BasicAppHost(typeof(MyServices).Assembly)
     {
         ConfigureContainer = container =>
         {
             //Add your IoC dependencies here
         }
     }
     .Init();
 }

 public void TestFixtureSetUp()
 {
     appHost = new BasicAppHost().Init();
     this.products = new List<Product> {
         new Product("Pen", 1.99m),
         new Product("Glass", 9.99m),
         new Product("Book", 14.99m),
         new Product("DVD", 11.99m),
     };
     productArgs = new { products = products };
 }

 public void TestFixtureSetUp()
 {
     appHost = new BasicAppHost
     {
         ConfigureContainer = c =>
         {
             var authService = new AuthenticateService();
             c.Register(authService);
             c.Register<IAuthSession>(authUserSession);
             AuthenticateService.Init(() => authUserSession, new CredentialsAuthProvider());
         }
     }.Init();
 }

        public void TestFixtureSetUp()
        {
            var json = "~/AppData/ALFKI.json".MapProjectPath().ReadAllText();
            response = JsonSerializer.DeserializeFromString<CustomerDetailsResponse>(json);

            appHost = new BasicAppHost
            {
                ConfigFilter = config => {
                    //Files aren't copied, set RootDirectory to ProjectPath instead.
                    config.WebHostPhysicalPath = "~".MapProjectPath(); 
                }
            }.Init();
            markdownFormat = appHost.GetPlugin<MarkdownFormat>();
        }

        public void SetUp()
        {
			try
			{
                tests = new OAuthUserSessionTests();

                appHost = new BasicAppHost().Init();
                
                var inMemoryRepo = new InMemoryAuthRepository();
				inMemoryRepo.Clear();
				userAuthRepositorys.Add(inMemoryRepo);

                var appSettings = new AppSettings();
				var redisRepo = new RedisAuthRepository(new BasicRedisClientManager(new[] { appSettings.GetString("Redis.Host") ?? "localhost" }));
				redisRepo.Clear();
				userAuthRepositorys.Add(redisRepo);

				if (OAuthUserSessionTestsBase.UseSqlServer)
				{
					var connStr = @"Data Source=.\SQLEXPRESS;AttachDbFilename=|DataDirectory|\App_Data\auth.mdf;Integrated Security=True;Connect Timeout=30;User Instance=True";
					var sqlServerFactory = new OrmLiteConnectionFactory(connStr, SqlServerOrmLiteDialectProvider.Instance);
					var sqlServerRepo = new OrmLiteAuthRepository(sqlServerFactory);
					sqlServerRepo.DropAndReCreateTables();
				}
				else
				{
					var sqliteInMemoryRepo = new OrmLiteAuthRepository(dbFactory);

                    sqliteInMemoryRepo.InitSchema();
                    sqliteInMemoryRepo.Clear();
					userAuthRepositorys.Add(sqliteInMemoryRepo);

					var sqliteDbFactory = new OrmLiteConnectionFactory( 
						"~/App_Data/auth.sqlite".MapProjectPath()); 
                    var sqliteDbRepo = new OrmLiteAuthRepository(sqliteDbFactory);
                    sqliteDbRepo.InitSchema();
					userAuthRepositorys.Add(sqliteDbRepo);
				}
			}
			catch (Exception ex)
			{
				Console.WriteLine(ex.Message);
				throw;
			}
		}

        public void TestFixtureSetUp()
        {
            appHost = new RabbitMqAppHost()
                .Init()
                .Start(ListeningOn);

            using (var conn = appHost.TryResolve<ConnectionFactory>().CreateConnection())
            using (var channel = conn.CreateModel())
            {
                channel.PurgeQueue<AnyTestMq>();
                channel.PurgeQueue<AnyTestMqResponse>();
                channel.PurgeQueue<PostTestMq>();
                channel.PurgeQueue<PostTestMqResponse>();
                channel.PurgeQueue<ValidateTestMq>();
                channel.PurgeQueue<ValidateTestMqResponse>();
                channel.PurgeQueue<ThrowGenericError>();
            }
        }

        protected StatelessAuthRazorTests()
        {
            appHost = CreateAppHost()
               .Init()
               .Start("http://*:2337/");

            var client = GetClient();
            var response = client.Post(new Register
            {
                UserName = "user",
                Password = "[email protected]",
                Email = "[email protected]{0}.com",
                DisplayName = "DisplayName",
                FirstName = "FirstName",
                LastName = "LastName",
            });

            var userId = response.UserId;
            var apiRepo = (IManageApiKeys)appHost.Resolve<IAuthRepository>();
            var user1Client = GetClientWithUserPassword(alwaysSend: true);
            ApiKey = user1Client.Get(new GetApiKeys { Environment = "live" }).Results[0].Key;
        }

 public void LocalFixtureSetUp()
 {
     // Configure the basic app host and start it
     this.AppHost = new BasicAppHost
     {
         ConfigureAppHost = host =>
         {
             host.Plugins.Add(
                 new AuthFeature(() =>
                     new AuthUserSession(),
                     new IAuthProvider[] {  
                         new CredentialsAuthProvider() 
             }));
         },
         ConfigureContainer = container =>
         {
             container.Register<IUnitOfWork>(c => this.UnitOfWork);
             container.Register<IAuthRepository>(c =>
                 new LightSpeedUserAuthRepository(c.Resolve<IUnitOfWork>()));
         }
     }.Init();
 }

        public void TestFixtureSetUp()
        {
            appHost = new BasicAppHost 
            {
                ConfigureAppHost = host =>
                {
                    host.Plugins.Add(new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] {
                        new CredentialsAuthProvider(), 
                    }));
                },
                ConfigureContainer = container => 
                {
                    container.Register<IDbConnectionFactory>(c =>
                        new OrmLiteConnectionFactory(":memory:", SqliteDialect.Provider) {
                            AutoDisposeConnection = false,
                        });

                    container.Register<IUserAuthRepository>(c => new OrmLiteAuthRepository(c.Resolve<IDbConnectionFactory>()));
                    container.Resolve<IUserAuthRepository>().InitSchema(); 
                }
            }.Init();
        }

 public SoapHandler(RequestAttributes soapType)
 {
     this.HandlerAttributes = soapType;
     this.appHost = HostContext.AppHost;
 }

 public XmlContentTypeIssue()
 {
     appHost = new AppHost()
         .Init()
         .Start(Config.AbsoluteBaseUri);
 }

 public void TestFixtureSetUp()
 {
     appHost = new AppHost()
         .Init()
         .Start(Config.AbsoluteBaseUri);
 }

 protected EncryptedMessagesTests()
 {
     appHost = new EncryptedMessagesAppHost()
         .Init()
         .Start(Config.AbsoluteBaseUri);
 }

 public void TestFixtureSetUp()
 {
     appHost = new BasicAppHost().Init();
     AuthenticateService.Init(() => new AuthUserSession(), new CredentialsAuthProvider());
 }

        public void SetUp()
		{
            appHost = new BasicAppHost().Init();
            serviceController = appHost.ServiceController;
		}