public Task CanGenerateUrl_FromStringInterpolatedResourceUrl() { var mockResource = new LinkedResource { Id = 10, Value1 = 100, Value2 = "value-2", Value3 = 300, Value4 = 400 }; return(WebHostFixture.TestAsync <LinkGenerationTests>(async host => { var response = await host .ArrangeWithDefaults(mockResource) .Act.OnRestClient(async client => { var request = ApiRequest.Create("api/linked/resource", HttpMethod.Get); return await client.SendAsync <LinkedResourceModel>(request); }); response.Assert.ApiResponse(apiResponse => { var resource = (LinkedResourceModel)apiResponse.Content; resource.AssertLink("scenario-25", HttpMethod.Options, "http://external/api/call/10/info/value-2"); }); })); }
public Task ResourceMap_CanSpecify_AdditionalOptionalLinkProperties() { var mockResource = new LinkedResource { Id = 10, Value2 = "value-2" }; return(WebHostFixture.TestAsync <LinkGenerationTests>(async host => { var response = await host .ArrangeWithDefaults(mockResource) .Act.OnRestClient(async client => { var request = ApiRequest.Create("api/linked/resource", HttpMethod.Get); return await client.SendAsync <LinkedResourceModel>(request); }); response.Assert.ApiResponse(apiResponse => { var resource = (LinkedResourceModel)apiResponse.Content; resource.AssertLink("scenario-30", HttpMethod.Options, "http://external/api/call/10/info/value-2"); var link = resource.Links["scenario-30"]; Assert.Equal("test-name", link.Name); Assert.Equal("test-title", link.Title); Assert.Equal("test-type", link.Type); Assert.Equal("test-href-lang", link.HrefLang); }); })); }
public async Task TestCreateUserAndDuplicatesClaims() { using (var fixture = new WebHostFixture()) { var userManager = fixture.GetUserManager(); var roleManager = fixture.GetRoleManager(); await InitializeIdentity.SeedPermissions <PermissionsTest>(roleManager).SeedAsync(); await InitializeIdentity.SeedPermissions <PermissionsTest>(roleManager).SeedAsync(); var defaultRole = roleManager.Roles.ToList()[0]; var claims = await roleManager.GetClaimsAsync(defaultRole); var user = new ApplicationUser { Email = "*****@*****.**", UserName = "******" }; // IN SEQUENCE var created = await userManager.CreateAsync(user, "Aa@123456"); // var result = await userManager.AddClaimsAsync(user, claims); // var userClaims = await userManager.GetClaimsAsync(user); Assert.True(result.Succeeded); Assert.Equal(2, claims.Count()); Assert.Equal(2, userClaims.Count()); } }
public Task CanGenerateUrl_ActionExpression_WithOptionalSuppliedRouteParam() { var mockResource = new LinkedResource { Id = 10, Value1 = 100, Value2 = "value-2", Value3 = 300, Value4 = 400 }; return(WebHostFixture.TestAsync <LinkGenerationTests>(async host => { var response = await host .ArrangeWithDefaults(mockResource) .Act.OnRestClient(async client => { var request = ApiRequest.Create("api/linked/resource", HttpMethod.Get); return await client.SendAsync <LinkedResourceModel>(request); }); response.Assert.ApiResponse(apiResponse => { var resource = (LinkedResourceModel)apiResponse.Content; // Optional Route Parameter with supplied value: resource.AssertLink("scenario-3", HttpMethod.Get, "/api/linked/resource/scenario-3/10/param-one/300"); }); })); }
public Task QueryStringParams_CanBeSpecified() { return(WebHostFixture.TestAsync <LinkGenerationTests>(async host => { IMockedService mockedSrv = new MockUnitTestService { Customers = new[] { new CustomerResource { CustomerId = "ID_1", Age = 47 } } }; var response = await host .ArrangeWithDefaults(mockedSrv) .Act.OnRestClient(async client => { var request = ApiRequest.Create("api/customers/24234234234", HttpMethod.Get, config => { config.Settings.UseHalDefaults(); config.Settings.QueryString .AddParam("a", "v1") .AddParam("b", "v2"); }); return await client.SendAsync <CustomerModel>(request); }); response.Assert.ApiResponse(apiResponse => { apiResponse.Request.RequestUri.PathAndQuery .Should().Be("/api/customers/24234234234?a=v1&b=v2"); }); })); }
public Task ClientCan_ReceiveEmbeddedResourceCollection() { // Arrange the test resources that will be returned from the server // to test the client consumer code. var serverResource = new CustomerResource { CustomerId = Guid.NewGuid().ToString() }; // Embed to child resources. serverResource.Embed(new[] { new AddressResource { AddressId = Guid.NewGuid().ToString(), CustomerId = serverResource.CustomerId }, new AddressResource { AddressId = Guid.NewGuid().ToString(), CustomerId = serverResource.CustomerId } }, "addresses"); // Configure the mock service to return the resource. var mockSrv = new MockUnitTestService { Customers = new[] { serverResource } }; // Run the unit test and request the resource and assert the expected results. return(WebHostFixture.TestAsync <LinkGenerationTests>(async host => { var response = await host .ArrangeWithDefaults(mockSrv) .Act.OnRestClient(async client => { var request = ApiRequest.Get("api/customers/embedded/resource"); return await client.SendAsync <CustomerModel>(request); }); response.Assert.ApiResponse(apiResponse => { var resource = (CustomerModel)apiResponse.Content; // Validate that an embedded resource collection was returned. resource.Should().NotBeNull(); resource.Embedded.Should().NotBeNull(); resource.Embedded.Keys.Should().HaveCount(1); resource.Embedded.ContainsKey("addresses").Should().BeTrue(); // At this point, the embedded resource is the generic JSON.NET representation. // The next line of code will deserialize this generic representation in the C# client side class // matching the server-sided resource collection. var embeddedClientResource = resource.GetEmbeddedCollection <AddressModel>("addresses").ToArray(); embeddedClientResource.Should().NotBeNull(); embeddedClientResource.Should().HaveCount(2); }); })); }
public async Task TestInitializeIdentitySeedRoles() { using (var fixture = new WebHostFixture()) { var roleManager = fixture.GetRoleManager(); await InitializeIdentity.SeedPermissions <PermissionsTest>(roleManager).SeedAsync(); var roles = roleManager.Roles.ToList(); var claims = await roleManager.GetClaimsAsync(roles[0]); Assert.True(roles.Count == 1); Assert.True(claims.Count == 2); Assert.Equal("1", claims[0].Value); Assert.Equal("2", claims[1].Value); } }
public Task EmbeddedResources_NotSerializedWithRequest() { // Create a test resource as it would have been returned from the server. var resource = new CustomerModel { CustomerId = Guid.NewGuid().ToString(), FirstName = "Doug", LastName = "Bowan", Age = 77 }; // Create an embedded resource. This would be the same state as if // the embedded resource, returned from the server, was deserialized into // the client-side resource representation. var embeddedResource = new AddressModel { AddressId = Guid.NewGuid().ToString(), CustomerId = resource.CustomerId, City = "Buckhannon", Street = "59 College Avenue", ZipCode = "26201" }; resource.Embedded = new Dictionary <string, object>(); resource.Embedded.Add("address", embeddedResource); return(WebHostFixture.TestAsync <LinkGenerationTests>(async host => { var response = await host .ArrangeWithDefaults() .Act.OnRestClient(async client => { var request = ApiRequest.Post("api/customers/pass-through", config => config.WithContent(resource)); return await client.SendAsync <CustomerModel>(request); }); response.Assert.Service <IMockedService>(mockedSrv => { var serverReceivedResource = mockedSrv.ServerReceivedResource as CustomerResource; serverReceivedResource.Should().NotBeNull("Client Resource Deserialized in Server Resource Representation."); serverReceivedResource.CustomerId.Should().Be(resource.CustomerId, "Server Side Serialized Resource Matches Client Resource."); serverReceivedResource.Embedded.Should().BeNull("Embedded Resources Should only be returned from Server."); }); })); }
public async Task TestCreateUser() { using (var fixture = new WebHostFixture()) { var userManager = fixture.GetUserManager(); var user = new ApplicationUser { Email = "*****@*****.**", UserName = "******" }; var created = await userManager.CreateAsync(user, "Aa@123456"); var find = await userManager.FindByEmailAsync(user.Email); var users = userManager.Users.ToList(); Assert.True(created.Succeeded); Assert.Equal(find.Email, user.Email); Assert.Single(users); } }
public Task ResourceLinks_NotSerializedWithRequest() { // Create a test resource as it would have been returned from the server. var resource = new CustomerModel { CustomerId = Guid.NewGuid().ToString(), FirstName = "Doug", LastName = "Bowan", Age = 77, Links = new Dictionary <string, Link> { { "test:lj4000", new Link { Href = "pull/rip/cord" } } } }; return(WebHostFixture.TestAsync <LinkGenerationTests>(async host => { var response = await host .ArrangeWithDefaults() .Act.OnRestClient(async client => { var request = ApiRequest.Post("api/customers/pass-through").WithContent(resource); return await client.SendAsync <CustomerModel>(request); }); response.Assert.Service <IMockedService>(mockedSrv => { var serverReceivedResource = mockedSrv.ServerReceivedResource as CustomerResource; serverReceivedResource.Should().NotBeNull("Client Resource Deserialized in Server Resource Representation."); if (serverReceivedResource == null) { return; } serverReceivedResource.CustomerId.Should().Be(resource.CustomerId, "Server Side Serialized Resource Matches Client Resource."); serverReceivedResource.Links.Should().BeNull("Links Should only be returned from Server."); }); })); }
public static WebServerConfig ArrangeWithDefaults(this WebHostFixture fixture, LinkedResource mockResource) { return(fixture.WithServices(services => { var serviceMock = new MockUnitTestService { ServerResources = new[] { mockResource } }; services.AddSingleton <IMockedService>(serviceMock); }) .ComposedFrom(compose => { compose.AddRest(); var hostPlugin = new MockHostPlugin(); hostPlugin.AddPluginType <LinkedResourceMap>(); compose.AddPlugin(hostPlugin); })); }
public ManagersClientTests(WebHostFixture fixture) { this.Fixture = fixture; }
public LimpingTestsControllerTest(WebHostFixture fixture) { _fixture = fixture; }
public WebTests(WebHostFixture fixture) { this.Fixture = fixture; }
public AccountsControllerIntegrationTests(CustomWebApplicationFactory <Startup, TestStartup, AppIdentityDbContext> factory, WebHostFixture webHostFixture) { _client = factory.CreateClient(); _webHostFixture = webHostFixture; }
public AnalysisControllerTest(WebHostFixture fixture) { // The fixture is a virtual server that lives for a single test method _fixture = fixture; }
public AppUsersServiceTest(WebHostFixture fixture) { _fixture = fixture; }
public ProjectsApiFixture(WebHostFixture <Startup> context) { this.context = context.ArgumentNotNull(nameof(context)); }
public PermissionsSeederTests() { var webHost = new WebHostFixture(); _roleManager = webHost.GetRoleManager(); }
public AppUsersControllerTest(WebHostFixture fixture) { _fixture = fixture; }
public TestAnalysesServiceTest(WebHostFixture fixture) { _fixture = fixture; }
public CallToGetProductsTests(WebHostFixture fixture, ITestOutputHelper output) : base(fixture, output) { }
public LimpingTestsServiceTest(WebHostFixture fixture) { _fixture = fixture; }
public ManagersApiTests(WebHostFixture fixture) { this.Fixture = fixture; }