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;
}
