public void Initialize()
{
_server = TestServer.Create<StartUp>();
_repository = new TasksRepository(new RedisClient());
_taskOne = _repository.Save(new Task { Title = "TaskOne" });
_taskTwo = _repository.Save(new Task { Title = "TaskTwo" });
}
protected void CreateServer(SequinOptions options)
{
Server = TestServer.Create(app =>
{
app.UseSequin(options);
});
}
public static void BeforeFeature()
{
//_testServer = TestServer.Create(app =>
//{
// var startup = new Startup();
// startup.Configuration(app);
// //var config = new HttpConfiguration();
// //WebApiConfig.Configure(config);
// //app.UseWebApi(config);
//});
TestUserManager.AddUserIfNotExists(TestUserName, TestPwd);
_authApiTestServer = TestServer.Create<AuthServer.Startup>();
_authApiHttpHelper = new HttpHelper(_authApiTestServer.HttpClient);
var request = String.Format("grant_type=password&username={0}&password={1}", TestUserName, TestPwd);
_bearerToken = _authApiHttpHelper.Post<AccessTokenResponse>("token", request).Token;
_todoApiTestServer = TestServer.Create<Api.Startup>();
_todoApiHttpHelper = new HttpHelper(_todoApiTestServer.HttpClient);
SetToDoContextConnectionString();
}
public void Setup()
{
Effort.Provider.EffortProviderConfiguration.RegisterProvider();
var connection = DbConnectionFactory.CreateTransient();
_context = new ApplicationDbContext(connection);
_context.GenerateRandomData();
_resolver = new HostNameTenantResolver(new List<ITenant>
{
new Tenant(1, "local", "localhost"),
new Tenant(2, "sample", "sample.local")
}, "TenantId");
_server = TestServer.Create(app =>
{
app.UseTenantCore(_resolver);
app.Run(context =>
{
var tenant = context.GetCurrentTenant();
return context.Response.WriteAsync(tenant.Name);
});
});
}
public void Dispose()
{
When.MessageHandlerFn = null;
_server?.Dispose();
_server = null;
}
public void Initialize()
{
Server = TestServer.Create<Startup>();
Container = TestsBootstrapper.InitializeContainer();
DbContext = (WebApiSeedDbContext)Container.Resolve<IDbContext>();
DbContext.Database.Initialize(true);
}
protected void CreateServer()
{
Server = TestServer.Create(app =>
{
app.UseSequin();
});
}
protected string RetrieveBearerToken(TestServer server)
{
if (!string.IsNullOrWhiteSpace(_token))
return _token;
// account service mock
var securityServiceMock = new Mock<ISecurityService>();
ServiceFacadeMock.Setup(m => m.Security).Returns(securityServiceMock.Object);
var user = new User(Configuration.DefaultAdminUsername) {IsAdmin = true};
user.SetPassword(Configuration.DefaultPassword);
securityServiceMock.Setup(m => m.AuthorizeAsync(Configuration.DefaultAdminUsername, Configuration.DefaultPassword)).ReturnsAsync(user);
// retrieve token
var tokenDetails = new List<KeyValuePair<string, string>>
{
new KeyValuePair<string, string>("grant_type", "password"),
new KeyValuePair<string, string>("username", Configuration.DefaultAdminUsername),
new KeyValuePair<string, string>("password", Configuration.DefaultPassword)
};
var tokenPostData = new FormUrlEncodedContent(tokenDetails);
var tokenResult = server.HttpClient.PostAsync(string.Format("/{0}/accesstoken", Constants.Api.V1.RoutePrefix), tokenPostData).Result;
tokenResult.StatusCode.ShouldBe(HttpStatusCode.OK);
var body = JObject.Parse(tokenResult.Content.ReadAsStringAsync().Result);
_token = (string) body["access_token"];
return _token;
}
public ApiAcceptanceTests()
{
var currentUser = new Operator
{
Key = "andy-dote",
Name = "Andy Dote",
CanCreatePermissions = true,
CanCreateRoles = true,
CanCreateUsers = true
};
var config = new MagistrateConfiguration
{
EventStore = new InMemoryEventStore(),
User = () => currentUser
};
var container = new Container(new MagistrateRegistry(config.EventStore));
container.GetInstance<Boot>().Load();
var ps = container.GetInstance<PermissionService>();
var rs = container.GetInstance<RoleService>();
var us = container.GetInstance<UserService>();
var p1 = Permission.Create(ps, currentUser, new PermissionKey("perm-one"), "first", "first permission");
var p2 = Permission.Create(ps, currentUser, new PermissionKey("perm-two"), "second", "second permission");
var p3 = Permission.Create(ps, currentUser, new PermissionKey("perm-three"), "third", "third permission");
var r1 = Role.Create(rs, currentUser, new RoleKey("role-one"), "first", "first role");
r1.AddPermission(currentUser, p1.ID);
var r2 = Role.Create(rs, currentUser, new RoleKey("role-two"), "second", "second role");
r2.AddPermission(currentUser, p2.ID);
var u1 = User.Create(us, currentUser, new UserKey("user-one"), "first");
u1.AddRole(currentUser, r1.ID);
u1.AddInclude(currentUser, p2.ID);
u1.AddRevoke(currentUser, p3.ID);
var store = container.GetInstance<AggregateStore<Guid>>();
store.Save(MagistrateSystem.MagistrateStream, p1);
store.Save(MagistrateSystem.MagistrateStream, p2);
store.Save(MagistrateSystem.MagistrateStream, p3);
store.Save(MagistrateSystem.MagistrateStream, r1);
store.Save(MagistrateSystem.MagistrateStream, r2);
store.Save(MagistrateSystem.MagistrateStream, u1);
_server = TestServer.Create(app =>
{
app.Use<MagistrateOperatorMiddleware>(config);
container
.GetAllInstances<IController>()
.ForEach(controller => controller.Configure(app));
});
}
public virtual void BeforeEachTest()
{
var startup = new TestStartup();
Server = TestServer.Create(builder => startup.Configuration(builder));
MockedApiInstaller = startup.MockedApiInstaller;
var documentDbBase = new DocumentDbBase(startup.Container.Resolve<IDocumentStore>(), startup.Container.Resolve<SeedService>());
documentDbBase.Init();
}
public void TestInitialize()
{
server = TestServer.Create(app =>
{
httpConfiguration = new HttpConfiguration();
biz.dfch.CS.Examples.Odata.WebApiConfig.Register(httpConfiguration);
appBuilder = app.UseWebApi(httpConfiguration);
});
}
public void Setup()
{
IntentBase.UseResponseNumber = 1;
server = TestServer.Create(app =>
{
HttpConfiguration config = new HttpConfiguration();
AlexaService.WebApiConfig.Register(config);
app.UseWebApi(config);
});
}
public SystemTests()
{
var sys = new MagistrateSystem(new MagistrateConfiguration
{
EventStore = new InMemoryEventStore(),
User = () => new Operator { Key = "user/1", Name = "Andy", CanCreatePermissions = true }
});
_host = TestServer.Create(sys.Configure);
}
public RequestBuilder(TestServer server, string path)
{
if (server == null)
{
throw new ArgumentNullException("server");
}
_server = server;
_req = new HttpRequestMessage(HttpMethod.Get, path);
}
public void SetUpTestServer()
{
var httpConfig = new HttpConfiguration();
RootContainer = new CompositionRoot().Compose(httpConfig);
httpConfig.DependencyResolver = new AutofacWebApiDependencyResolver(RootContainer);
Server =
TestServer.Create(app => new Startup(RootContainer, httpConfig).Configuration(app));
SetUpTestSpecificDatabase();
}
public void Init()
{
DateTimeOffsetHelper.UtcNowFunc = () => UtcNow;
Server = TestServer.Create(app =>
{
app.UseIdentityServer(Options);
});
NewRequest();
}
public static void AssemblyInit(TestContext context)
{
httpTestServer = TestServer.Create(appBuilder =>
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
appBuilder.UseWebApi(config);
});
httpClient = httpTestServer.HttpClient;
}
public NancyOwinHostFixture()
{
this.testServer = TestServer.Create(
builder =>
builder.UseNancy(options =>
{
options.Bootstrapper = new DefaultNancyBootstrapper();
options.PassThroughWhenStatusCodesAre(NancyHttpStatusCode.NotFound);
})
.UseHandler((request, response) => response.StatusCode = 200));
}
public void TestInit()
{
this.httpTestServer = TestServer.Create(appBuilder =>
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
appBuilder.UseWebApi(config);
});
this.httpClient = httpTestServer.HttpClient;
}
public void TestInit()
{
// Start OWIN testing HTTP server with Web API support
this.httpTestServer = TestServer.Create(appBuilder =>
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
appBuilder.Use(config);
});
this.httpClient = httpTestServer.HttpClient;
}
public ActionTests()
{
_server = TestServer.Create<ActionStartup>();
_client = new ODataClient(new ODataClientSettings()
{
BaseUri = new Uri("http://localhost/actions"),
PayloadFormat = ODataPayloadFormat.Json,
OnCreateMessageHandler = () => _server.Handler,
OnTrace = (x,y) => Console.WriteLine(string.Format(x,y)),
});
}
public static void Setup(TestContext testContext)
{
server = TestServer.Create(app =>
{
var config = new HttpConfiguration();
NS_ECI_WebAPI_RestService.WebApiConfig.Register(config);
app.UseWebApi(config);
});
AppDomain.CurrentDomain.SetData("DataDirectory", AppDomain.CurrentDomain.BaseDirectory);
}
internal ObsoleteSetupJsonApiServer(JsonApiMediaTypeFormatter formatter)
{
var config = new HttpConfiguration();
config.Formatters.Clear();
config.Formatters.Add(formatter);
config.MapHttpAttributeRoutes(new DefaultDirectRouteProvider());
_server = TestServer.Create(builder =>
{
builder.UseWebApi(config);
});
}
public OwinBasedFileServer(IFileSystem fileSystem)
{
if (fileSystem == null)
throw new ArgumentNullException("fileSystem");
m_OwinTestServer = TestServer.Create(app => app.UseFileServer(new FileServerOptions
{
EnableDefaultFiles = false,
EnableDirectoryBrowsing = true,
FileSystem = fileSystem
}));
}
public void TestInit()
{
this.httpTestServer = TestServer.Create(appBuilder =>
{
var config = new HttpConfiguration();
config.MessageHandlers.Add(new PresharedKeyAuthorizer());
WebApiConfig.Register(config);
appBuilder.UseWebApi(config);
});
this.httpClient = this.httpTestServer.HttpClient;
}
public static void AssemblyInit(TestContext context)
{
// Start OWIN testing HTTP server with Web API support
TestWebServer = TestServer.Create(appBuilder =>
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
var webAppStartup = new Startup();
webAppStartup.Configuration(appBuilder);
appBuilder.UseWebApi(config);
});
HttpClient = TestWebServer.HttpClient;
}
public static void InitializeTests(TestContext context)
{
server = TestServer.Create(AppBuilder =>
{
var httpConfig = new HttpConfiguration();
WebApiConfig.Register(httpConfig);
var webApiStartup = new Startup();
webApiStartup.Configuration(AppBuilder);
AppBuilder.UseWebApi(httpConfig);
});
client = server.HttpClient;
Seed();
}
public void SetUp()
{
this.server = TestServer.Create<OwinStartup>();
var client = new HttpClient(new TraceMessageHandler(new ClientCompressionHandler(this.server.Handler, new GZipCompressor(), new DeflateCompressor())))
{
BaseAddress = new Uri("http://localhost:55399")
};
client.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
client.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("deflate"));
this.testFixture = new TestFixture(client);
}
public static void AssemblyInit(TestContext context)
{
httpTestServer = TestServer.Create(appBuilder =>
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
var startup = new Startup();
startup.Configuration(appBuilder);
appBuilder.UseWebApi(config);
});
httpClient = httpTestServer.HttpClient;
SeedDatabase();
}
public void Background()
{
TrackedCommandHandler.Reset();
Server = TestServer.Create(app =>
{
if (Options != null)
{
app.UseSequin((HttpOptions)Options);
}
else
{
app.UseSequin();
}
});
}
