public void TestFetchTokenAsync_RefreshTokenRequest()
{
var handler = new FetchTokenMessageHandler();
handler.RefreshTokenRequest = new RefreshTokenRequest()
{
RefreshToken = "REFRESH",
Scope = "a"
};
MockHttpClientFactory mockFactory = new MockHttpClientFactory(handler);
var flow = CreateFlow(httpClientFactory: mockFactory);
var response = flow.FetchTokenAsync("user", handler.RefreshTokenRequest, CancellationToken.None).Result;
SubtestTokenResponse(response);
}
public void WHEN_post_fails_with_error_message_SHOULD_throw_message()
{
//Arrange
MockHttpClientFactory.Where_CreateClient_returns(new HttpClient(MockMessageHandler
.Where_SendAsync_returns_StatusCode(HttpStatusCode.BadRequest)
.Where_SendAsync_returns_Content(JsonConvert.SerializeObject(new HttpError
{
Message = "bad luck"
}))
.Build().Object));
//Assert
Assert.ThrowsAsync <HttpClientServiceServerError>(async() =>
await Sut.PostAsync("http://baseaddress.com/testroute", new TestDto {
TestDtoProperty = "hello world"
}, CancellationToken.None), "bad luck");
}
public async Task DeleteUserNotFound()
{
var handler = new MockMessageHandler()
{
StatusCode = HttpStatusCode.NotFound,
};
var factory = new MockHttpClientFactory(handler);
var userManager = new FirebaseUserManager(
new FirebaseUserManagerArgs
{
Credential = MockCredential,
ProjectId = MockProjectId,
ClientFactory = factory,
});
await Assert.ThrowsAsync <FirebaseException>(
async() => await userManager.DeleteUser("user1"));
}
public void WHEN_post_fails_with_error_message_SHOULD_throw()
{
//Arrange
var wrapper = GetWrapper();
MockHttpClientFactory.Where_CreateClient_returns(new HttpClient(MockMessageHandler
.Where_SendAsync_returns_StatusCode(HttpStatusCode.BadRequest)
.Where_SendAsync_returns_Content(JsonConvert.SerializeObject(new HttpError
{
Message = "bad luck"
}))
.Build().Object));
//Assert
Assert.ThrowsAsync <HttpClientServiceServerError>(async() =>
await ExecuteAsync(wrapper, CancellationToken.None), "bad luck");
}
public async Task SHOULD_return_deserialized_dto()
{
//Arrange
var wrapper = GetWrapper();
MockHttpClientFactory.Where_CreateClient_returns(new HttpClient(MockMessageHandler
.Where_SendAsync_returns_Content(JsonConvert.SerializeObject(new TestDto {
TestDtoProperty = "Hello back"
}))
.Build().Object));
//Act
var result = await ExecuteAsync(wrapper, CancellationToken.None);
//Assert
Assert.That(result.TestDtoProperty, Is.EqualTo("Hello back"));
}
public async Task SHOULD_append_analytics_headers_if_present()
{
//Arrange
MockAnalyticsService.With(x => x.AnalyticsOperationHeaders, new Dictionary <string, string>
{
{ "analyticsHeaderKey", "analyticsHeaderValue" }
});
var wrapper = GetWrapper();
MockHttpClientFactory.Where_CreateClient_returns(new HttpClient(MockMessageHandler.Build().Object));
//Act
await ExecuteAsync(wrapper, CancellationToken.None);
//Assert
MockMessageHandler.VerifyHeader("analyticsHeaderKey", "analyticsHeaderValue");
}
public CollectionManagerTests()
{
using var handler = FakeHttpMessageHandler.Create(req => new HttpResponseMessage
{
Content = new StreamContent(new MemoryStream())
});
var httpClient = new HttpClient(handler);
var httpClientFactory = new MockHttpClientFactory(httpClient);
var logger = new Mock <ILogger <CollectionManager> >().Object;
var redactor = new Mock <IRedactor>().Object;
var serviceUriProviderMock = new Mock <IServiceUriProvider>();
serviceUriProviderMock.Setup(x => x.GetRandomManagementUri()).Returns(BaseUri);
var serviceProvider = serviceUriProviderMock.Object;
_collectionManager = new CollectionManager(BucketName, serviceProvider, httpClientFactory, logger, redactor);
}
public async Task SHOULD_append_headers_if_provided()
{
//Arrange
var wrapper = GetWrapper()
.WithRequestHeader("userId", "123")
.WithRequestHeader("name", "Bob")
.WithAuthorizationHeader("Bearer", "bearerToken");
MockHttpClientFactory.Where_CreateClient_returns(new HttpClient(MockMessageHandler.Build().Object));
//Act
await ExecuteAsync(wrapper, CancellationToken.None);
//Assert
MockMessageHandler.VerifyHeader("userId", "123");
MockMessageHandler.VerifyHeader("name", "Bob");
MockMessageHandler.VerifyAuthHeader("Bearer", "bearerToken");
}
public async Task GetUserById()
{
var handler = new MockMessageHandler()
{
Response = new UserRecord("user1"),
};
var factory = new MockHttpClientFactory(handler);
var userManager = new FirebaseUserManager(
new FirebaseUserManagerArgs
{
Credential = MockCredential,
ProjectId = MockProjectId,
ClientFactory = factory,
});
var userRecord = await userManager.GetUserById("user1");
Assert.Equal("user1", userRecord.Uid);
}
public void TestFetchTokenAsync_AuthorizationCodeRequest()
{
var handler = new FetchTokenMessageHandler();
handler.AuthorizationCodeTokenRequest = new AuthorizationCodeTokenRequest()
{
Code = "c0de",
RedirectUri = "redIrect",
Scope = "a"
};
MockHttpClientFactory mockFactory = new MockHttpClientFactory(handler);
var flow = CreateFlow(httpClientFactory: mockFactory);
var response = flow.FetchTokenAsync("user", handler.AuthorizationCodeTokenRequest,
CancellationToken.None).Result;
SubtestTokenResponse(response);
}
public async Task AccountDiscoveryError()
{
var bytes = Encoding.UTF8.GetBytes("signature");
var handler = new MockMessageHandler()
{
StatusCode = HttpStatusCode.InternalServerError,
};
var factory = new MockHttpClientFactory(handler);
var signer = new IAMSigner(factory, GoogleCredential.FromAccessToken("token"));
await Assert.ThrowsAsync <FirebaseException>(
async() => await signer.GetKeyIdAsync());
Assert.Equal(1, handler.Calls);
await Assert.ThrowsAsync <FirebaseException>(
async() => await signer.GetKeyIdAsync());
Assert.Equal(1, handler.Calls);
}
public async Task UnexpectedSignError()
{
var handler = new MockMessageHandler()
{
StatusCode = HttpStatusCode.InternalServerError,
Response = "not json",
};
var factory = new MockHttpClientFactory(handler);
var signer = new FixedAccountIAMSigner(
factory, GoogleCredential.FromAccessToken("token"), "test-service-account");
Assert.Equal("test-service-account", await signer.GetKeyIdAsync());
byte[] data = Encoding.UTF8.GetBytes("Hello world");
var ex = await Assert.ThrowsAsync <FirebaseException>(
async() => await signer.SignDataAsync(data));
Assert.Contains("not json", ex.Message);
}
public void InvalidArguments()
{
var clock = new MockClock();
var handler = new MockMessageHandler()
{
Response = File.ReadAllBytes("./resources/public_keys.json"),
};
var clientFactory = new MockHttpClientFactory(handler);
Assert.Throws <ArgumentException>(
() => new HttpPublicKeySource(null, clock, clientFactory));
Assert.Throws <ArgumentException>(
() => new HttpPublicKeySource(string.Empty, clock, clientFactory));
Assert.Throws <ArgumentNullException>(
() => new HttpPublicKeySource("https://example.com/certs", null, clientFactory));
Assert.Throws <ArgumentNullException>(
() => new HttpPublicKeySource("https://example.com/certs", clock, null));
}
public void WriteIntegration_IncludeSourceInMessage()
{
// act
MockHttpClientFactory httpClientFactory = GetHttpClientFactory();
var buildServer = new AppVeyor(GetLogger(), GetEnvironment(), httpClientFactory);
buildServer.ApplyParameters(true);
var output = new StringBuilder();
var writer = new StringWriter(output);
Console.SetOut(writer);
var issues = GetIssues();
// arrange
foreach (var issue in issues)
{
buildServer.WriteMessage(issue);
}
// assert
Assert.Equal(3, httpClientFactory.HttpMessageHandler.Requests.Count);
Assert.Equal(HttpMethod.Post, httpClientFactory.HttpMessageHandler.Requests[0].Item1.Method);
Assert.Equal("http://localhost:8080/api/build/compilationmessages", httpClientFactory.HttpMessageHandler.Requests[0].Item1.RequestUri.AbsoluteUri);
Assert.Equal("utf-8", httpClientFactory.HttpMessageHandler.Requests[0].Item1.Content.Headers.ContentType.CharSet);
Assert.Equal("application/json", httpClientFactory.HttpMessageHandler.Requests[0].Item1.Content.Headers.ContentType.MediaType);
Assert.Equal("{\"Message\":\"[Source1] Message1\",\"Category\":\"information\",\"FileName\":\"FilePath1\",\"Line\":42,\"ProjectName\":\"Project1\"}", httpClientFactory.HttpMessageHandler.Requests[0].Item2);
Assert.Equal(HttpMethod.Post, httpClientFactory.HttpMessageHandler.Requests[1].Item1.Method);
Assert.Equal("http://localhost:8080/api/build/compilationmessages", httpClientFactory.HttpMessageHandler.Requests[1].Item1.RequestUri.AbsoluteUri);
Assert.Equal("utf-8", httpClientFactory.HttpMessageHandler.Requests[1].Item1.Content.Headers.ContentType.CharSet);
Assert.Equal("application/json", httpClientFactory.HttpMessageHandler.Requests[1].Item1.Content.Headers.ContentType.MediaType);
Assert.Equal("{\"Message\":\"[Source2] Message2\",\"Category\":\"warning\",\"FileName\":\"FilePath2\",\"Line\":465,\"ProjectName\":\"Project1\"}", httpClientFactory.HttpMessageHandler.Requests[1].Item2);
Assert.Equal(HttpMethod.Post, httpClientFactory.HttpMessageHandler.Requests[2].Item1.Method);
Assert.Equal("http://localhost:8080/api/build/compilationmessages", httpClientFactory.HttpMessageHandler.Requests[2].Item1.RequestUri.AbsoluteUri);
Assert.Equal("utf-8", httpClientFactory.HttpMessageHandler.Requests[2].Item1.Content.Headers.ContentType.CharSet);
Assert.Equal("application/json", httpClientFactory.HttpMessageHandler.Requests[2].Item1.Content.Headers.ContentType.MediaType);
Assert.Equal("{\"Message\":\"[Source3] Message3\",\"Category\":\"error\",\"FileName\":\"FilePath3\",\"Line\":82,\"ProjectName\":\"Project2\"}", httpClientFactory.HttpMessageHandler.Requests[2].Item2);
Assert.Equal(string.Empty, _loggerOutput.ToString());
}
public async Task NetworkError()
{
var handler = new MockMessageHandler()
{
Exception = new HttpRequestException("Low-level network error"),
};
var factory = new MockHttpClientFactory(handler);
var httpClient = new ErrorHandlingHttpClient <FirebaseException>(
this.CreateArgs(factory));
var exception = await Assert.ThrowsAsync <FirebaseException>(
async() => await httpClient.SendAndDeserializeAsync <Dictionary <string, string> >(
this.CreateRequest()));
Assert.Equal(ErrorCode.Unknown, exception.ErrorCode);
Assert.Equal("Network error", exception.Message);
Assert.Same(handler.Exception, exception.InnerException);
Assert.Null(exception.HttpResponse);
}
public async Task SuccessfulRequest()
{
var handler = new MockMessageHandler()
{
Response = @"{""foo"": ""bar""}",
};
var factory = new MockHttpClientFactory(handler);
var httpClient = new ErrorHandlingHttpClient <FirebaseException>(
this.CreateArgs(factory));
var response = await httpClient.SendAndDeserializeAsync <Dictionary <string, string> >(
this.CreateRequest());
Assert.NotNull(response.HttpResponse);
Assert.Equal(handler.Response, response.Body);
Assert.Single(response.Result);
Assert.Equal("bar", response.Result["foo"]);
Assert.Equal(1, handler.Calls);
}
public async Task DeserializeError()
{
var handler = new MockMessageHandler()
{
Response = "not json",
};
var factory = new MockHttpClientFactory(handler);
var httpClient = new ErrorHandlingHttpClient <FirebaseException>(
this.CreateArgs(factory));
var exception = await Assert.ThrowsAsync <FirebaseException>(
async() => await httpClient.SendAndDeserializeAsync <Dictionary <string, string> >(
this.CreateRequest()));
Assert.Equal(ErrorCode.Unknown, exception.ErrorCode);
Assert.Equal("Response parse error", exception.Message);
Assert.NotNull(exception.InnerException);
Assert.NotNull(exception.HttpResponse);
}
public void E120_PatchPostCodes_MockHttpClient_ConcurrenyError()
{
var mcf = MockHttpClientFactory.Create();
var mc = mcf.CreateClient("zippo", new Uri("http://api.zippopotam.us/"));
mc.Request(HttpMethod.Get, "US/WA/Redmond").Respond.WithJsonResource("B140_GetPostCodes_MockedHttpClient_Found.json");
using var agentTester = Beef.Test.NUnit.AgentTester.CreateWaf <Startup>(sc => mcf.Replace(sc));
var res = agentTester.Test <PostalInfoAgent, PostalInfo>()
.ExpectStatusCode(HttpStatusCode.OK)
.Run(a => a.GetPostCodesAsync("US", "WA", "Redmond"));
res = agentTester.Test <PostalInfoAgent, PostalInfo>()
.ExpectStatusCode(HttpStatusCode.PreconditionFailed)
.Run(a => a.PatchPostCodesAsync(WebApiPatchOption.MergePatch, TestSetUp.GetResourceStream("E110_PatchPostCodes_Request.json").ReadToEnd(), "US", "WA", "Redmond", new WebApiRequestOptions {
ETag = "XXX"
}));
}
public async Task TransportError()
{
var handler = new MockMessageHandler()
{
Exception = new HttpRequestException("Transport error"),
};
var factory = new MockHttpClientFactory(handler);
var signer = this.CreateFixedAccountIAMSigner(factory);
byte[] data = Encoding.UTF8.GetBytes("Hello world");
var ex = await Assert.ThrowsAsync <FirebaseAuthException>(
async() => await signer.SignDataAsync(data));
Assert.Equal(ErrorCode.Unknown, ex.ErrorCode);
Assert.Null(ex.AuthErrorCode);
Assert.Null(ex.HttpResponse);
Assert.NotNull(ex.InnerException);
Assert.Equal(5, handler.Calls);
}
public void EnhancedPreparedStatements_defaults_to_false()
{
var httpClient = new HttpClient(new HttpClientHandler())
{
BaseAddress = new Uri("http://localhost:8091")
};
var httpClientFactory = new MockHttpClientFactory(httpClient);
var mockServiceUriProvider = new Mock <IServiceUriProvider>();
mockServiceUriProvider
.Setup(m => m.GetRandomQueryUri())
.Returns(new Uri("http://localhost:8093"));
var client = new QueryClient(httpClientFactory, mockServiceUriProvider.Object, new DefaultSerializer(),
new Mock <ILogger <QueryClient> >().Object, NoopRequestTracer.Instance);
Assert.False(client.EnhancedPreparedStatementsEnabled);
}
public async Task CreateClient_WithMockContext_ReturnsMockedData()
{
const string expectedContent = "TestData";
var context = new MockHttpClientContext();
context
.Respond()
.ForUri("http://test.com/")
.ReturnText(expectedContent, HttpStatusCode.OK);
var httpClientFactory = new MockHttpClientFactory(context.CreateMessageHandler());
var client = httpClientFactory.CreateClient(string.Empty);
var response = await client.GetStringAsync("http://test.com").ConfigureAwait(false);
Assert.Equal(expectedContent, response);
}
public async Task DeleteUser()
{
var handler = new MockMessageHandler()
{
Response = new Dictionary <string, string>()
{
{ "kind", "identitytoolkit#DeleteAccountResponse" },
},
};
var factory = new MockHttpClientFactory(handler);
var userManager = new FirebaseUserManager(
new FirebaseUserManagerArgs
{
Credential = MockCredential,
ProjectId = MockProjectId,
ClientFactory = factory,
});
await userManager.DeleteUser("user1");
}
public void TestGetUSDGBPOnNewYearsDay2018()
{
ILoggerFactory loggerFactory = new LoggerFactory();
var environmentServiceMock = new Mock <IEnvironmentService>();
string fakeKey = "abcd";
environmentServiceMock
.Setup(es => es.GetFixerKey())
.Returns(fakeKey);
string date = "2018-01-01";
decimal GbpPerEur = 0.889131m;
decimal UsdPerEur = 1.201496m;
decimal UsdPerGbp = UsdPerEur / GbpPerEur;
var mockedResponsesByRequestUri = new Dictionary <string, HttpResponseMessage>()
{
{
$"http://data.fixer.io/{date}?access_key={fakeKey}",
new HttpResponseMessage
{
StatusCode = System.Net.HttpStatusCode.OK,
Content = new StringContent
(
$"{{ base: \"EUR\", date: \"{date}\", rates: {{ GBP: {GbpPerEur}, USD: {UsdPerEur} }} }}"
)
}
}
};
HttpClientHandler httpClientHandler = new MockHttpClientHandler(mockedResponsesByRequestUri);
IHttpClientFactory httpClientFactory = new MockHttpClientFactory(httpClientHandler);
var service = new FixerIOCurrencyExchangeService(
loggerFactory,
environmentServiceMock.Object,
httpClientFactory
);
decimal gbpUsdRate = service.GetExchangeRate("GBP", "USD", new DateTime(2018, 1, 1));
Assert.AreEqual(UsdPerGbp, gbpUsdRate);
}
public async Task Test(string file, HttpStatusCode httpStatusCode, Type errorType)
{
using (var response = ResourceHelper.ReadResourceAsStream(@"Documents\Query\" + file))
{
var buffer = new byte[response.Length];
response.Read(buffer, 0, buffer.Length);
var handlerMock = new Mock <HttpMessageHandler>();
handlerMock.Protected().Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>()).ReturnsAsync(new HttpResponseMessage
{
StatusCode = httpStatusCode,
Content = new ByteArrayContent(buffer)
});
var httpClient = new HttpClient(handlerMock.Object)
{
BaseAddress = new Uri("http://localhost:8091")
};
var httpClientFactory = new MockHttpClientFactory(httpClient);
var mockServiceUriProvider = new Mock <IServiceUriProvider>();
mockServiceUriProvider
.Setup(m => m.GetRandomQueryUri())
.Returns(new Uri("http://localhost:8093"));
var serializer = new DefaultSerializer();
var client = new QueryClient(httpClientFactory, mockServiceUriProvider.Object, serializer,
new Mock <ILogger <QueryClient> >().Object, NoopRequestTracer.Instance);
try
{
await client.QueryAsync <DynamicAttribute>("SELECT * FROM `default`", new QueryOptions()).ConfigureAwait(false);
}
catch (Exception e)
{
Assert.Equal(errorType, e.GetType());
}
}
}
public async Task GetNewLightsAsync_WhenCalled_ReturnNewLightsAsync()
{
httpClientFactory = MockHttpClientFactory.Create(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(
@"{
""7"": {""name"": ""Hue Lamp 7""},
""8"": {""name"": ""Hue Lamp 8""},
""lastscan"": ""2012-10-29T12:00:00""
}"
)
});
var api = new PhilipsHueApi("http://fake_url", "fake_username", httpClientFactory);
var newLights = await api.GetNewLightsAsync(CancellationToken.None);
Assert.That(newLights.First().GetType() == typeof(NewLight));
}
public async Task SHOULD_append_default_headers_if_set()
{
//Arrange
var wrapper = GetWrapper();
Sut.SetDefaultRequestHeader("userId", "123");
Sut.SetDefaultRequestHeader("name", "Bob");
MockAccessToken
.With(x => x.Scheme, "Bearer")
.With(x => x.Token, "bearerToken");
MockHttpClientFactory.Where_CreateClient_returns(new HttpClient(MockMessageHandler.Build().Object));
//Act
await ExecuteAsync(wrapper, CancellationToken.None);
//Assert
MockMessageHandler.VerifyHeader("userId", "123");
MockMessageHandler.VerifyHeader("name", "Bob");
MockMessageHandler.VerifyAuthHeader("Bearer", "bearerToken");
}
public async Task Then_It_Should_Return_A_Valid_Token(AuthToken authToken)
{
// Arrange
var token = new StringContent(JsonConvert.SerializeObject(authToken), Encoding.UTF8, "application/json");
var fakeHttpMessageHandler = new FakeHttpMessageHandler(token, HttpStatusCode.OK);
MockHttpClientFactory.Setup(x => x.CreateClient(It.IsAny <string>())).Returns(new HttpClient(fakeHttpMessageHandler));
_sut = new SpotifyWebApiClient(Mapper, MockHttpClientFactory.Object, MockApiSettings.Object, MockLogger.Object);
// Act
var response = await _sut.GetTokenAsync().ConfigureAwait(false);
// Aseert
response.ShouldNotBe(null);
response.AccessToken.ShouldBe("NgCXRK");
response.ExpiresIn.ShouldBe(3600);
response.RefreshToken.ShouldBe("NgAagA");
response.TokenType.ShouldBe("Bearer");
}
public async Task ErrorResponse()
{
var handler = new MockMessageHandler()
{
StatusCode = HttpStatusCode.InternalServerError,
Response = "{}",
};
var factory = new MockHttpClientFactory(handler);
var httpClient = new ErrorHandlingHttpClient <FirebaseException>(
this.CreateArgs(factory));
var exception = await Assert.ThrowsAsync <FirebaseException>(
async() => await httpClient.SendAndDeserializeAsync <Dictionary <string, string> >(
this.CreateRequest()));
Assert.Equal(ErrorCode.Internal, exception.ErrorCode);
Assert.Equal("Example error message: {}", exception.Message);
Assert.Null(exception.InnerException);
Assert.NotNull(exception.HttpResponse);
}
public async Task GetPublicKeysWithoutCaching()
{
var clock = new MockClock();
var handler = new MockMessageHandler()
{
Response = File.ReadAllBytes("./resources/public_keys.json"),
};
var clientFactory = new MockHttpClientFactory(handler);
var keyManager = new HttpPublicKeySource(
"https://example.com/certs", clock, clientFactory);
var keys = await keyManager.GetPublicKeysAsync();
Assert.Equal(2, keys.Count);
Assert.Equal(1, handler.Calls);
var keys2 = await keyManager.GetPublicKeysAsync();
Assert.Equal(2, keys.Count);
Assert.Equal(2, handler.Calls);
Assert.NotSame(keys, keys2);
}
public async Task Unavailable()
{
var handler = new MockMessageHandler()
{
StatusCode = HttpStatusCode.ServiceUnavailable,
Response = @"{""error"": {""message"": ""test reason""}}",
};
var factory = new MockHttpClientFactory(handler);
var signer = this.CreateFixedAccountIAMSigner(factory);
byte[] data = Encoding.UTF8.GetBytes("Hello world");
var ex = await Assert.ThrowsAsync <FirebaseAuthException>(
async() => await signer.SignDataAsync(data));
Assert.Equal(ErrorCode.Unavailable, ex.ErrorCode);
Assert.Equal("test reason", ex.Message);
Assert.Null(ex.AuthErrorCode);
Assert.NotNull(ex.HttpResponse);
Assert.Null(ex.InnerException);
Assert.Equal(5, handler.Calls);
}
