public async Task StartAppWithGuid_ReturnsFalse_WhenStatusCodeIsNotASuccess()
{
string fakeAppGuid = "1234";
string expectedPath = _fakeCfApiAddress + CfApiClient.listAppsPath + $"/{fakeAppGuid}/actions/start";
Exception resultException = null;
MockedRequest appsRequest = _mockHttp.Expect(expectedPath)
.WithHeaders("Authorization", $"Bearer {_fakeAccessToken}")
.Respond(HttpStatusCode.Unauthorized);
_sut = new CfApiClient(_mockUaaClient.Object, _mockHttp.ToHttpClient());
bool startResult = true;
try
{
startResult = await _sut.StartAppWithGuid(_fakeCfApiAddress, _fakeAccessToken, fakeAppGuid);
}
catch (Exception e)
{
resultException = e;
}
Assert.AreEqual(1, _mockHttp.GetMatchCount(appsRequest));
Assert.IsNull(resultException);
Assert.IsFalse(startResult);
}
public async Task ValidateRequest_Default_Success()
{
string location = Guid.NewGuid().ToString();
string name = Guid.NewGuid().ToString();
string libraryId = Guid.NewGuid().ToString();
string tenantId = Guid.NewGuid().ToString();
var mockHttp = new MockHttpMessageHandler();
MockedRequest request = mockHttp
.When(HttpMethod.Get, "*/libraries")
.Respond("application/json", $"[{{'libraryId': '{libraryId}', 'tenantId': '{tenantId}', 'name': '{name}', 'location': '{location}'}}]");
IServiceProvider services = ConfigureServices(mockHttp);
IDocumentLibraryClient docLibClient = services.GetRequiredService <IDocumentLibraryClient>();
ICollection <Library> libraries = await docLibClient.ListLibrariesAsync().ConfigureAwait(false);
mockHttp.GetMatchCount(request).Should().Be(1);
libraries.Should().NotBeNullOrEmpty();
libraries.Should().HaveCount(1);
Library library = libraries.Single();
library.Should().NotBeNull();
library.TenantId.Should().Be(tenantId);
library.Name.Should().Be(name);
}
public async Task StartAppWithGuid_ReturnsFalse_WhenAppStateIsNotSTARTED()
{
string fakeAppGuid = "1234";
string expectedPath = _fakeCfApiAddress + CfApiClient.ListAppsPath + $"/{fakeAppGuid}/actions/start";
Exception resultException = null;
MockedRequest cfStartAppRequest = _mockHttp.Expect(expectedPath)
.Respond("application/json", JsonConvert.SerializeObject(new App {
State = "fake state != STARTED"
}));
_sut = new CfApiClient(_mockUaaClient.Object, _mockHttp.ToHttpClient());
bool startResult = true;
try
{
startResult = await _sut.StartAppWithGuid(_fakeCfApiAddress, _fakeAccessToken, fakeAppGuid);
}
catch (Exception e)
{
resultException = e;
}
Assert.AreEqual(1, _mockHttp.GetMatchCount(cfStartAppRequest));
Assert.IsNull(resultException);
Assert.IsFalse(startResult);
}
public static MockedRequest WithJsonContent(this MockedRequest mockedRequest, Func <JsonElement, bool> matcher)
{
mockedRequest.With(r =>
{
if (r.Content == null)
{
return(false);
}
if (r.Content.Headers.ContentType.MediaType != "application/json")
{
return(false);
}
var content = r.Content.ReadAsStringAsync().GetAwaiter().GetResult();
try
{
using var document = JsonDocument.Parse(content);
return(matcher(document.RootElement));
}
catch (JsonException)
{
return(false);
}
});
return(mockedRequest);
}
public async Task LoginAsync_ThrowsException_WhenBasicInfoRequestErrors()
{
Exception resultException = null;
var fakeHttpExceptionMessage = "(fake) http request failed";
MockedRequest cfBasicInfoRequest = _mockHttp.Expect(_fakeCfApiAddress + "/")
.Throw(new Exception(fakeHttpExceptionMessage));
_sut = new CfApiClient(_mockUaaClient.Object, _mockHttp.ToHttpClient());
try
{
await _sut.LoginAsync(_fakeCfApiAddress, _fakeCfUsername, _fakeCfPassword);
}
catch (Exception e)
{
resultException = e;
}
Assert.AreEqual(1, _mockHttp.GetMatchCount(cfBasicInfoRequest));
Assert.IsNotNull(resultException);
Assert.IsTrue(resultException.Message.Contains(fakeHttpExceptionMessage));
Assert.IsTrue(
resultException.Message.Contains(CfApiClient.AuthServerLookupFailureMessage) ||
(resultException.Data.Contains("MessageToDisplay") &&
resultException.Data["MessageToDisplay"].ToString().Contains(CfApiClient.AuthServerLookupFailureMessage)));
_mockUaaClient.Verify(mock =>
mock.RequestAccessTokenAsync(
It.IsAny <Uri>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>()), Times.Never);
}
public async Task LoginAsync_UpdatesAndReturnsAccessToken_WhenLoginSucceeds()
{
var expectedUri = new Uri(_fakeLoginAddress);
var fakeAccessTokenContent = "fake access token";
MockedRequest cfBasicInfoRequest = _mockHttp.Expect("https://api." + _fakeTargetDomain + "/")
.Respond("application/json", _fakeBasicInfoJsonResponse);
_mockUaaClient.Setup(mock => mock.RequestAccessTokenAsync(
expectedUri,
CfApiClient.DefaultAuthClientId,
CfApiClient.DefaultAuthClientSecret,
_fakeCfUsername,
_fakeCfPassword))
.ReturnsAsync(HttpStatusCode.OK);
_mockUaaClient.SetupGet(mock => mock.Token)
.Returns(new Token()
{
Access_token = fakeAccessTokenContent
});
_sut = new CfApiClient(_mockUaaClient.Object, _mockHttp.ToHttpClient());
Assert.AreNotEqual(fakeAccessTokenContent, _sut.AccessToken);
var result = await _sut.LoginAsync(_fakeCfApiAddress, _fakeCfUsername, _fakeCfPassword);
Assert.AreEqual(fakeAccessTokenContent, _sut.AccessToken);
Assert.AreEqual(fakeAccessTokenContent, result);
_mockUaaClient.VerifyAll();
Assert.AreEqual(1, _mockHttp.GetMatchCount(cfBasicInfoRequest));
}
public async Task ValidateRequest_Default_Success()
{
string tenantName = Guid.NewGuid().ToString();
string tenantId = Guid.NewGuid().ToString();
var mockHttp = new MockHttpMessageHandler();
MockedRequest request = mockHttp
.When(HttpMethod.Get, "*/tenants")
.Respond("application/json", $"[{{'tenantId': '{tenantId}', 'name': '{tenantName}'}}]");
IServiceProvider services = ConfigureServices(mockHttp);
IIamClient iamClient = services.GetRequiredService <IIamClient>();
ICollection <Tenant> tenants = await iamClient.ListTenantsAsync().ConfigureAwait(false);
mockHttp.GetMatchCount(request).Should().Be(1);
tenants.Should().NotBeNullOrEmpty();
tenants.Should().HaveCount(1);
Tenant tenant = tenants.Single();
tenant.Should().NotBeNull();
tenant.TenantId.Should().Be(tenantId);
tenant.Name.Should().Be(tenantName);
}
public async Task ListBuildpacks_ReturnsListOfBuildpacks_WhenResponseContainsMultiplePages()
{
string expectedPath = CfApiClient.ListBuildpacksPath;
string page2Identifier = "?page=2&per_page=50";
string page3Identifier = "?page=3&per_page=50";
MockedRequest buildpacksRequest = _mockHttp.Expect(_fakeCfApiAddress + expectedPath)
.WithHeaders("Authorization", $"Bearer {_fakeAccessToken}")
.Respond("application/json", _fakeBuildpacksJsonResponsePage1);
MockedRequest buildpacksPage2Request = _mockHttp.Expect(_fakeCfApiAddress + expectedPath + page2Identifier)
.WithHeaders("Authorization", $"Bearer {_fakeAccessToken}")
.Respond("application/json", _fakeBuildpacksJsonResponsePage2);
MockedRequest buildpacksPage3Request = _mockHttp.Expect(_fakeCfApiAddress + expectedPath + page3Identifier)
.WithHeaders("Authorization", $"Bearer {_fakeAccessToken}")
.Respond("application/json", _fakeBuildpacksJsonResponsePage3);
_sut = new CfApiClient(_mockUaaClient.Object, _mockHttp.ToHttpClient());
var result = await _sut.ListBuildpacks(_fakeCfApiAddress, _fakeAccessToken);
Assert.IsNotNull(result);
Assert.AreEqual(125, result.Count);
Assert.AreEqual(1, _mockHttp.GetMatchCount(buildpacksRequest));
Assert.AreEqual(1, _mockHttp.GetMatchCount(buildpacksPage2Request));
Assert.AreEqual(1, _mockHttp.GetMatchCount(buildpacksPage3Request));
}
public async Task ListBuildpacks_ThrowsException_WhenStatusCodeIsNotASuccess()
{
string expectedPath = CfApiClient.ListBuildpacksPath;
MockedRequest buildpacksRequest = _mockHttp.Expect(_fakeCfApiAddress + expectedPath)
.WithHeaders("Authorization", $"Bearer {_fakeAccessToken}")
.Respond(HttpStatusCode.Unauthorized);
_sut = new CfApiClient(_mockUaaClient.Object, _mockHttp.ToHttpClient());
Exception thrownException = null;
try
{
var result = await _sut.ListBuildpacks(_fakeCfApiAddress, _fakeAccessToken);
}
catch (Exception ex)
{
thrownException = ex;
}
Assert.IsNotNull(thrownException);
Assert.IsTrue(thrownException.Message.Contains(CfApiClient.ListBuildpacksPath));
Assert.AreEqual(1, _mockHttp.GetMatchCount(buildpacksRequest));
}
public async Task LoginAsync_ReturnsNull_AndDoesNotUpdateAccessToken_WhenLoginFails()
{
var expectedUri = new Uri(_fakeLoginAddress);
MockedRequest cfBasicInfoRequest = _mockHttp.Expect("https://api." + _fakeTargetDomain + "/")
.Respond("application/json", _fakeBasicInfoJsonResponse);
_mockUaaClient.Setup(mock => mock.RequestAccessTokenAsync(
expectedUri,
CfApiClient.DefaultAuthClientId,
CfApiClient.DefaultAuthClientSecret,
_fakeCfUsername,
_fakeCfPassword))
.ReturnsAsync(HttpStatusCode.Unauthorized);
_sut = new CfApiClient(_mockUaaClient.Object, _mockHttp.ToHttpClient());
var initialAccessToken = _sut.AccessToken;
var result = await _sut.LoginAsync(_fakeCfApiAddress, _fakeCfUsername, _fakeCfPassword);
Assert.IsNull(result);
Assert.AreEqual(initialAccessToken, _sut.AccessToken);
_mockUaaClient.VerifyAll();
Assert.AreEqual(1, _mockHttp.GetMatchCount(cfBasicInfoRequest));
}
public async Task StartAppWithGuid_ThrowsException_WhenStatusCodeIsNotASuccess()
{
string fakeAppGuid = "1234";
string expectedPath = _fakeCfApiAddress + CfApiClient.ListAppsPath + $"/{fakeAppGuid}/actions/start";
Exception thrownException = null;
MockedRequest appsRequest = _mockHttp.Expect(expectedPath)
.WithHeaders("Authorization", $"Bearer {_fakeAccessToken}")
.Respond(HttpStatusCode.Unauthorized);
_sut = new CfApiClient(_mockUaaClient.Object, _mockHttp.ToHttpClient());
try
{
await _sut.StartAppWithGuid(_fakeCfApiAddress, _fakeAccessToken, fakeAppGuid);
}
catch (Exception e)
{
thrownException = e;
}
Assert.IsNotNull(thrownException);
Assert.IsTrue(thrownException.Message.Contains(CfApiClient.ListAppsPath));
Assert.AreEqual(1, _mockHttp.GetMatchCount(appsRequest));
}
public async Task GetLoginServerInformation_ReturnsLoginInfoResponse_WhenRequestsSucceed()
{
Exception thrownException = null;
Assert.IsTrue(_fakeBasicInfoJsonResponse.Contains(_fakeLoginAddress));
var fakeLoginServerInfo = new LoginInfoResponse
{
Prompts = new System.Collections.Generic.Dictionary <string, string[]>
{
{ "username", new[] { "text", "Email" } },
{ "password", new[] { "password", "Password" } },
}
};
MockedRequest cfBasicInfoRequest = _mockHttp.Expect(_fakeCfApiAddress + "/")
.Respond("application/json", _fakeBasicInfoJsonResponse);
MockedRequest loginServerInfoRequest = _mockHttp.Expect(_fakeLoginAddress + "/login")
.Respond("application/json", JsonConvert.SerializeObject(fakeLoginServerInfo));
try
{
var result = await _sut.GetLoginServerInformation(_fakeCfApiAddress);
}
catch (Exception ex)
{
thrownException = ex;
}
Assert.IsNull(thrownException);
Assert.AreEqual(1, _mockHttp.GetMatchCount(cfBasicInfoRequest));
Assert.AreEqual(1, _mockHttp.GetMatchCount(loginServerInfoRequest));
}
public async Task DeleteRouteWithGuid_ReturnsTrue_WhenStatusCodeIs202()
{
var fakeAppGuid = "my fake guid";
string expectedPath = _fakeCfApiAddress + CfApiClient.DeleteRoutesPath + $"/{fakeAppGuid}";
MockedRequest cfDeleteRouteRequest = _mockHttp.Expect(expectedPath)
.Respond(HttpStatusCode.Accepted);
_sut = new CfApiClient(_mockUaaClient.Object, _mockHttp.ToHttpClient());
Exception resultException = null;
bool routeWasDeleted = false;
try
{
routeWasDeleted = await _sut.DeleteRouteWithGuid(_fakeCfApiAddress, _fakeAccessToken, fakeAppGuid);
}
catch (Exception e)
{
resultException = e;
}
Assert.AreEqual(1, _mockHttp.GetMatchCount(cfDeleteRouteRequest));
Assert.IsNull(resultException);
Assert.IsTrue(routeWasDeleted);
}
public async Task LoginAsync_ThrowsException_WhenCfTargetIsMalformed()
{
Exception expectedException = null;
MockedRequest catchallRequest = _mockHttp.When("*")
.Throw(new Exception("Malformed uri exception should be thrown before httpClient is used"));
_sut = new CfApiClient(_mockUaaClient.Object, _mockHttp.ToHttpClient());
try
{
var malformedCfTargetString = "what-a-mess";
await _sut.LoginAsync(malformedCfTargetString, _fakeCfUsername, _fakeCfPassword);
}
catch (Exception e)
{
expectedException = e;
}
Assert.IsNotNull(expectedException);
_mockUaaClient.Verify(mock =>
mock.RequestAccessTokenAsync(
It.IsAny <Uri>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>()), Times.Never);
Assert.AreEqual(0, _mockHttp.GetMatchCount(catchallRequest));
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
var integrationTestConfig = new ConfigurationBuilder()
.AddJsonFile("integrationtestsettings.json")
.Build();
builder
.UseSolutionRelativeContentRoot("src/GraphIoT.Digitalstrom")
.ConfigureAppConfiguration(config =>
{
config.AddConfiguration(integrationTestConfig);
})
.ConfigureServices(services =>
{
// Build a http mock for requests to the digitalstrom server
services.AddSingleton(fac =>
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.AddAuthMock()
.AddStructureMock()
.AddCircuitZonesMocks(new Zone[] { 4, 32027 })
.AddEnergyMeteringMocks()
.AddSensorMocks()
.AddInitialAndSubscribeMocks();
MockedEventResponse = mockHttp.When($"{MockDigitalstromConnection.BaseUri}/json/event/get")
.WithExactQueryString($"subscriptionID=10&timeout=60000&token={MockDigitalstromConnection.AppToken}")
.Respond("application/json", SceneCommand.Preset0.ToMockedSceneEvent());
return(mockHttp);
});
// Build a database context using an in-memory database for testing
var dbRoot = new InMemoryDatabaseRoot();
void dbConfig(DbContextOptionsBuilder options)
{
options.UseInMemoryDatabase("InMemoryDbIntegrationTest", dbRoot);
options.UseInternalServiceProvider(new ServiceCollection()
.AddEntityFrameworkInMemoryDatabase()
.BuildServiceProvider());
}
// Add all digitalstrom services using the mocked in-memory db
services.AddDigitalstromHost <IntegrationTestDbContext>(dbConfig,
integrationTestConfig.GetSection("DigitalstromConfig"),
integrationTestConfig.GetSection("TokenStoreConfig"),
integrationTestConfig.GetSection("Network")
);
// Replace the digitalstrom connection provider with a http mock for testing
var existingProvider = services.FirstOrDefault(descriptor => descriptor.ServiceType == typeof(IDigitalstromConnectionProvider));
if (existingProvider != null)
{
services.Remove(existingProvider);
}
services.AddTransient <IDigitalstromConnectionProvider, DigitalstromConnectionProvider>(fac =>
fac.GetRequiredService <MockHttpMessageHandler>().ToMockProvider());
});
}
public static MockedRequest WithJson(
this MockedRequest handler,
string jsonObject)
{
handler.With(new JsonMatcher(jsonObject));
return(handler);
}
public static MockedRequest RespondWithJson <T>(this MockedRequest request, T json)
{
var body = JsonSerializer.Serialize <T>(json, new JsonSerializerOptions
{
IgnoreNullValues = true,
});
return(request.Respond("application/json", body));
}
public static MockedRequest WithJsonContent <T>(this MockedRequest request, T json)
{
var body = JsonSerializer.Serialize <T>(json, new JsonSerializerOptions
{
IgnoreNullValues = true,
});
return(request.WithContent(body));
}
public static void Throw(this MockedRequest source)
{
source.Respond(message =>
{
var content = message.Content?.ReadAsStringAsync().GetAwaiter().GetResult();
throw new InvalidOperationException(
$"No matching mock handler. Message: {message}. Content: {content}");
});
}
/// <summary>
/// Adds a requirement that the request has an authorization header.
/// </summary>
/// <param name="request">The mocked request.</param>
/// <returns>The request; with the new requirement.</returns>
public static MockedRequest WithAuthentication(this MockedRequest request)
{
return(request.With
(
m => m
.Headers.Authorization?.Scheme == "Bot" &&
!string.IsNullOrWhiteSpace(m.Headers.Authorization.Parameter)
));
}
public static MockedRequest WithContent(
this MockedRequest handler,
string contentType,
string content)
{
handler.WithContent(content);
handler.With(new ContentTypeMatcher(contentType));
return(handler);
}
public And BeMediaType(string contentType)
{
var mockedRequest = new MockedRequest();
mockedRequest.With(message => message.Content?.Headers.ContentType?.MediaType == contentType);
Execute.Assertion
.ForCondition(mockedRequest.Matches(Subject))
.FailWith("Expected request content media type to be {0}, but found {1}.", contentType, Subject.Content?.Headers.ContentType?.MediaType);
return(new(this));
}
public static MockedRequest RespondJson <T>(this MockedRequest request, Func <T> contentProvider)
{
request.Respond(req =>
{
var response = new HttpResponseMessage(HttpStatusCode.OK);
response.Content = new StringContent(JsonSerializer.Serialize(contentProvider()));
response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
return(response);
});
return(request);
}
/// <summary>
/// Adds a requirement that the request has a Json body.
/// </summary>
/// <param name="request">The mocked request.</param>
/// <param name="elementMatcherBuilder">The additional requirements on the Json body.</param>
/// <returns>The request; with the new requirements.</returns>
public static MockedRequest WithJson
(
this MockedRequest request, Action <JsonElementMatcherBuilder>?elementMatcherBuilder = null
)
{
var elementMatcher = new JsonElementMatcherBuilder();
elementMatcherBuilder?.Invoke(elementMatcher);
return(request.With(new JsonRequestMatcher(elementMatcher.Build())));
}
public static MockedRequest RespondText(this MockedRequest request, string content)
{
request.Respond(req =>
{
var response = new HttpResponseMessage(HttpStatusCode.OK);
response.Content = new StringContent(content);
response.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
return(response);
});
return(request);
}
/// <summary>
/// Sets the response of the current <see cref="T:MockedRequest"/>
/// </summary>
/// <param name="source">The source mocked request</param>
/// <param name="statusCode">The <see cref="T:HttpStatusCode"/> of the response</param>
/// <param name="headers">A list of HTTP header name/value pairs to add to the response.</param>
/// <param name="mediaType">The media type of the response</param>
/// <param name="handler">A delegate that will return a content stream at runtime</param>
public static MockedRequest Respond(this MockedRequest source, HttpStatusCode statusCode, IEnumerable <KeyValuePair <string, string> > headers, string mediaType, Func <HttpRequestMessage, Stream> handler)
{
return(source.Respond(statusCode, headers, request =>
{
var content = handler(request);
var streamContent = new StreamContent(content);
streamContent.Headers.ContentType = new MediaTypeHeaderValue(mediaType);
return streamContent;
}));
}
protected MockHttpMessageHandler CreateMockHttpMessageHandler(HttpMethod httpMethod, string url, string response, string expectedPartialContent = null)
{
MockHttpMessageHandler mockHttp = new MockHttpMessageHandler();
MockedRequest mockedRequest = mockHttp.Expect(httpMethod, url)
.Respond("application/json", response);
if (!string.IsNullOrEmpty(expectedPartialContent))
{
mockedRequest.WithPartialContent(expectedPartialContent);
}
return(mockHttp);
}
public static MockedRequest WithContent(
this MockedRequest handler,
string contentType,
string content)
{
Contract.Requires(handler != null);
Contract.Requires(!string.IsNullOrEmpty(contentType));
Contract.Requires(!string.IsNullOrEmpty(content));
handler.WithContent(content);
handler.With(new ContentTypeMatcher(contentType));
return(handler);
}
/// <summary>
/// Sets the response of the current <see cref="T:MockedRequest"/>
/// </summary>
/// <param name="source">The source mocked request</param>
/// <param name="statusCode">The <see cref="T:HttpStatusCode"/> of the response</param>
/// <param name="headers">A list of HTTP header name/value pairs to add to the response.</param>
/// <param name="content">The content of the response</param>
public static MockedRequest Respond(this MockedRequest source, HttpStatusCode statusCode, IEnumerable <KeyValuePair <string, string> > headers, HttpContent content)
{
return(source.Respond(req =>
{
var res = new HttpResponseMessage(statusCode)
{
Content = content
};
foreach (var header in headers)
{
res.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
return res;
}));
}
public async Task TestRetriesFlow_NonTransientIssue()
{
MockedRequest nextReq = null;
var(httpClient, mockHandler) = GetHttpMocks((handler =>
{
handler.Expect("http://home").Respond((req) => Task.FromResult(new HttpResponseMessage(HttpStatusCode.NotFound)));
nextReq = handler.Expect("http://home").Respond((req) => Task.FromResult(new HttpResponseMessage(HttpStatusCode.InternalServerError)));
}));
var resp = await httpClient.GetAsync("http://home");
resp.StatusCode.Should().Be(HttpStatusCode.NotFound);
mockHandler.GetMatchCount(nextReq).Should().Be(0);
}
