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