private WebServiceClient CreateClient(string type, string ipAddress = "1.2.3.4", HttpStatusCode status = HttpStatusCode.OK, string?contentType = null, string content = "") { var service = type.Replace("Async", ""); contentType ??= $"application/vnd.maxmind.com-{service}+json"; _server .Given( Request.Create() .WithPath($"/geoip/v2.1/{service}/{ipAddress}") .UsingGet() ) .RespondWith( Response.Create() .WithStatusCode(status) .WithHeader("Content-Type", contentType) .WithBody(content) ); var host = _server.Urls[0].Replace("http://", ""); return(new WebServiceClient(6, "0123456789", locales: new List <string> { "en" }, host: host, timeout: 3000, disableHttps: true )); }
public async Task ShouldCreateScheduleWhenRequested() { var scheduleWebAPi = RestService.For <IScheduleWebApi>(ScheduleWebApiBaseUrl); var workloadItems = new List <WorkloadItem> { Any.Instance <WorkloadItem>(), Any.Instance <WorkloadItem>() }; var maintenanceWindowServiceLocation = new ServiceLocation { Location = new Uri("http://localhost:5678") }; _mockServer.Given( Request.Create().UsingGet().WithPath("/MaintenanceWindowService")) .RespondWith( Response.Create().WithSuccess().WithBodyAsJson(maintenanceWindowServiceLocation)); var maintenanceWindows = Any.Instance <MaintenanceWindow>(); _mockServer.Given( Request.Create().UsingGet().WithPath("/Planned")) .RespondWith( Response.Create().WithSuccess().WithBodyAsJson(maintenanceWindows)); var result = await scheduleWebAPi.CreateScheduleAsync(workloadItems); result.Should().NotBe(Guid.Empty); }
public async Task ShouldCreateScheduleWhenRequested() { var scheduleWebApiClient = new JsonServiceClient(ScheduleWebApiBaseUrl); var maintenanceWindowServiceLocation = new ServiceLocation { Location = new Uri("http://localhost:5678") }; _mockServer.Given( Request.Create().UsingGet().WithPath("/MaintenanceWindowService")) .RespondWith( Response.Create().WithSuccess().WithBodyAsJson(maintenanceWindowServiceLocation)); var maintenanceWindows = Any.Instance <MaintenanceWindow>(); _mockServer.Given( Request.Create().UsingGet().WithPath("/Planned")) .RespondWith( Response.Create().WithSuccess().WithBodyAsJson(maintenanceWindows)); var workloadItems = new List <WorkloadItem> { Any.Instance <WorkloadItem>(), Any.Instance <WorkloadItem>() }; var createScheduleRequest = new CreateScheduleRequest { WorkloadItems = workloadItems }; var result = await scheduleWebApiClient.PostAsync(createScheduleRequest).ConfigureAwait(false); result.Id.Should().NotBe(Guid.Empty); }
private void BuildTestScenario(WireMockServer p_server) { p_server .Given(Request.Create() .WithPath("/todo/items") .UsingGet()) .InScenario("To do list") .WillSetStateTo("TodoList State Started") .RespondWith(Response.Create() .WithBody("Buy milk")); p_server .Given(Request.Create() .WithPath("/todo/items") .UsingPost()) .InScenario("To do list") .WhenStateIs("TodoList State Started") .WillSetStateTo("Cancel newspaper item added") .RespondWith(Response.Create() .WithStatusCode(201)); p_server .Given(Request.Create() .WithPath("/todo/items") .UsingGet()) .InScenario("To do list") .WhenStateIs("Cancel newspaper item added") .RespondWith(Response.Create() .WithBody("Buy milk;Cancel newspaper subscription")); }
public async Task Return_Success_Response_When_Request_Is_Successful() { BankPaymentResponse bankPaymentResponse = (new BankPaymentResponse { PaymentIdentifier = Guid.NewGuid().ToString(), PaymentStatus = PaymentStatus.Success }); _server .Given(Request.Create() .WithPath($"/api/payment").UsingPost()) .RespondWith(Response.Create() .WithStatusCode(200) .WithHeader("Content-Type", "application/json") .WithBody(bankPaymentResponse.ToJson())); _mockAcquiryBankOptions.SetupGet(x => x.CurrentValue) .Returns(new AcquiringBankSettings { ApiUrl = _server.Urls.First() }); var sut = new AcquiringBankClient(new HttpClient(), _mockAcquiryBankOptions.Object, _mockLogger.Object); var response = await sut.ProcessPayment(new BankPaymentRequest { Amount = 100, Currency = "EUR", CardExpiryYear = "24", CardExpiryMonth = "4", CardNumber = "5564876598743467", CVV = "782", MerchantId = Guid.NewGuid().ToString() }); response.Should().BeEquivalentTo(bankPaymentResponse); }
public async Task CanGetEmptyStatusListAsync() { server.Reset(); var expected = new List <DurableFunctionStatus>(); server .Given( Request .Create() .WithPath("/runtime/webhooks/durabletask/instances") .UsingGet() ) .RespondWith( Response .Create() .WithStatusCode(200) .WithBody("[]") ); var client = new DurableFunctionClient(server.Ports[0]); var actual = await client.GetAllFunctionStatuses(); actual.Should().BeEquivalentTo(expected); }
public async Task TestClientAuthenticationWithApiKeyAuthentication() { var user = UserTestData.Users.First(); using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo); IDictionary <string, WireMockList <string> > headers = null; _wireMockServer .Given(Request.Create().WithPath($"/{UserEndpoints.Base}").UsingGet()) .RespondWith(Response.Create().WithStatusCode(200) .WithBody(x => { headers = x.Headers; return(WireMockResponseHelper.CreateTestResponse(user)); })); await client.Users.GetDetailsAsync(); headers.Should().ContainKey("X-Auth-Email"); headers.First(x => x.Key == "X-Auth-Email").Value.Should().BeEquivalentTo(WireMockConnection.EmailAddress); headers.Should().ContainKey("X-Auth-Key"); headers.First(x => x.Key == "X-Auth-Key").Value.Should().BeEquivalentTo(WireMockConnection.Key); }
public MiddlewareAndPolicyTests() { _server = WireMockServer.Start(); _server .Given(Request.Create() .WithPath(_endpointUri) .UsingGet()) .InScenario("Timeout-then-resolved") .WillSetStateTo("Transient issue resolved") .RespondWith(Response.Create() .WithStatusCode(HttpStatusCode.RequestTimeout)); _server .Given(Request.Create() .WithPath(_endpointUri) .UsingGet()) .InScenario("Timeout-then-resolved") .WhenStateIs("Transient issue resolved") .WillSetStateTo("All ok") .RespondWith(Response.Create() .WithStatusCode(HttpStatusCode.OK) .WithHeader("Content-Type", "text/plain") .WithBody("Hello world!")); _server .Given(Request.Create() .WithPath(_endpointUriTimeout) .UsingGet()) .RespondWith(Response.Create() .WithStatusCode(HttpStatusCode.RequestTimeout)); }
public void Setup() { _server = WireMockServer.Start(); _server .Given( Request.Create() .UsingGet() .WithPath($"/api/v1/data/1")) .RespondWith( Response.Create() .WithStatusCode(HttpStatusCode.OK) .WithHeader("Content-Type", "application/json") .WithBody(TestData.DataObjTests.DefaultJson)); _server .Given( Request.Create() .UsingGet() .WithPath($"/api/v1/person/1")) .RespondWith( Response.Create() .WithStatusCode(HttpStatusCode.OK) .WithHeader("Content-Type", "application/json") .WithBody(TestData.PersonTests.DefaultJson)); _restClient = new RestClient($"http://localhost:{_server.Ports.FirstOrDefault()}") { Encoding = Encoding.UTF8, AutomaticDecompression = true, UseSynchronizationContext = false }; _restClient.UseSerializer(() => new JsonSerializer { DateFormat = "yyyy-MM-ddTHH:mm:ss.FFFFFFFZ" }); }
public SampleWireMock ConfigureBuilder() { mockServer .Given( Request.Create().WithPath($"/".Split('?')[0]).UsingGet() ) .RespondWith( Response.Create() .WithStatusCode(200) ); mockServer .Given( Request.Create().WithPath($"/").UsingGet() ) .RespondWith( Response.Create() .WithStatusCode(200) ); mockServer .Given( Request.Create().WithPath($"/api/health").UsingGet() ) .RespondWith( Response.Create() .WithStatusCode(200) ); return(this); }
public async Task TestAPIBaz() { // Arrange TestServer _server = new TestServer(new WebHostBuilder() .UseStartup <Startup>()); // HttpClient _client = _server.CreateClient(); _wireMockServer //.Given(Request.Create().WithUrl("https://api.ipify.org?format=json").UsingGet()) .Given(Request.Create().WithPath("/api/learning/baz").UsingGet()) .RespondWith( Response.Create() .WithStatusCode(200) .WithBody(@"{ ""ip"": ""0.0.0.0"" }") ); // Act var httpClient = new HttpClient(); var response = await httpClient.GetAsync($"{_wireMockServer.Urls[0]}/api/learning/baz"); response.EnsureSuccessStatusCode(); var responseString = await response.Content.ReadAsStringAsync(); // Assert Assert.AreEqual(@"{ ""ip"": ""0.0.0.0"" }", responseString); }
public async Task ValidateShouldReturnTrueOnValidTIHJwt() { var validToken = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOiIxNTk5NzUzMTk5IiwiYWNjZXNzX3Rva2VuIjoidGVzdF9hY2Nlc3NfdG9rZW4iLCJpZCI6IjAifQ.osL8kyPx90gUapZzz6Iv-H8DPwgtJTMSKTJA1VtMirU"; var validExp = _DateTimeProvider.Now().AddHours(_ClaimLifetimeHours - .1).ToUnixTimeU64(); var testClaims = new Dictionary <string, string> { { "id", "0" }, { "exp", validExp.ToString() }, { "access_token", validToken } }; _Server.Reset(); _Server.Given( Request.Create() .WithHeader("Authorization", "Bearer " + validToken) .WithPath("/ggdghornl_test/oauth2/v1/verify").UsingGet() ) .RespondWith( Response.Create() .WithStatusCode(200) .WithHeader("Content-Type", "application/json") .WithBody("{\"audience\":1234}") ); Assert.True(await _JwtClaimValidator.ValidateAsync(testClaims)); }
public FederatedEndpointFixture() { Server1 = WireMockServer.Start(); Server2 = WireMockServer.Start(); Server1.Given(Request.Create() .WithPath("/query") .UsingGet() .WithParam("query", MatchBehaviour.AcceptOnMatch)) .RespondWith(Response.Create() .WithBody(Server1ResultsXml, encoding: Encoding.UTF8) .WithHeader("Content-Type", MimeTypesHelper.SparqlResultsXml[0]) .WithStatusCode(HttpStatusCode.OK)); Server1.Given(Request.Create().WithPath("/query2").UsingGet().WithParam("query")) .RespondWith(Response.Create().WithBody(Server1ConstructResults, encoding: Encoding.UTF8) .WithHeader("Content-Type", "application/n-triples").WithStatusCode(HttpStatusCode.OK)); Server2 .Given(Request.Create().WithPath("/query").UsingGet().WithParam("query")) .RespondWith(Response.Create().WithBody(Server2ResultsXml, encoding: Encoding.UTF8) .WithHeader("Content-Type", MimeTypesHelper.SparqlResultsXml[0]).WithStatusCode(HttpStatusCode.OK)); Server2.Given(Request.Create().WithPath("/query2").UsingGet().WithParam("query")) .RespondWith(Response.Create().WithBody(Server2ConstructResults, encoding: Encoding.UTF8) .WithHeader("Content-Type", "application/n-triples").WithStatusCode(HttpStatusCode.OK)); Server2.Given(Request.Create().WithPath("/fail")) .RespondWith(Response.Create().WithStatusCode(HttpStatusCode.Forbidden)); Server2.Given(Request.Create().WithPath("/timeout")) .RespondWith(Response.Create().WithDelay(4000).WithBody(Server2ResultsXml, encoding: Encoding.UTF8) .WithHeader("Content-Type", MimeTypesHelper.SparqlResultsXml[0]).WithStatusCode(HttpStatusCode.OK)); }
public async Task TestGetUserMembershipsAsync() { var displayOptions = new DisplayOptions { Page = 1, PerPage = 20, Order = OrderType.Asc }; var membershipFilter = new MembershipFilter { AccountName = "tothnet", MembershipOrder = MembershipOrder.Status, Status = Status.Accepted }; _wireMockServer .Given(Request.Create() .WithPath($"/{MembershipEndpoints.Base}/") .WithParam(Filtering.Page) .WithParam(Filtering.PerPage) .WithParam(Filtering.Order) .WithParam(Filtering.Status) .WithParam(Filtering.AccountName) .WithParam(Filtering.Direction) .UsingGet()) .RespondWith(Response.Create().WithStatusCode(200) .WithBody(WireMockResponseHelper.CreateTestResponse(UserMembershipTestsData.Memberships))); using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo); var userMembership = await client.Users.Memberships.GetAsync(membershipFilter, displayOptions); userMembership.Result.Should().BeEquivalentTo(UserMembershipTestsData.Memberships); }
public void StubData() { Stub .Given(Request .Create() .WithUrl(BaseUrl) .UsingGet()) .RespondWith(Response.Create().WithBody("hello")); }
public async Task Setup() { var services = new ServiceCollection(); string eventsJson; var names = Assembly.GetExecutingAssembly().GetManifestResourceNames(); var eventsStream = Assembly.GetExecutingAssembly() .GetManifestResourceStream("EA.Usage.Tracking.Client.Test.Events.json"); using (var reader = new StreamReader(eventsStream, Encoding.UTF8)) eventsJson = await reader.ReadToEndAsync(); var events = new PagedResponse <UsageTrackingEvent>() { Data = new List <UsageTrackingEvent>() { new UsageTrackingEvent() { Id = 1, Name = "Test", DateCreated = DateTime.Now } } }; services.AddHttpClient("usageTracking", c => { c.BaseAddress = new Uri(baseUrl); }); services.AddScoped <IUsageTrackingClient, UsageTrackingClient>(); stub.Given( Request .Create() .WithPath("/ApplicationEvent")) .RespondWith( Response.Create() .WithStatusCode(200) .WithHeader("Content-Type", "application/json") .WithBodyAsJson(events)); stub.Given( Request .Create() .WithPath("/ApplicationUsage")) .RespondWith( Response.Create() .WithStatusCode(201)); var mockAuthClient = new Mock <IAuthClient>(); mockAuthClient.Setup(x => x.GetAuthenticationHeader()) .Returns(Task.FromResult(new AuthenticationHeaderValue("test"))); services.AddScoped <IAuthClient>(c => mockAuthClient.Object); _servicesProvider = services.BuildServiceProvider(); }
public FakeApiGatewayHost() { stub = FluentMockServer.Start(new FluentMockServerSettings { Urls = new[] { "http://+:5003" }, StartAdminInterface = true }); stub.Given( Request.Create() .WithPath("/api/eml/accounts/registrationemail") .WithHeader("ipm-eml-auth", "1234") //.WithHeader("Content-Type", "application/vnd.h2020ipmdecisions.email+json") .WithBody(new WildcardMatcher("*[email protected]*")) .UsingPost()) .RespondWith(Response.Create() .WithStatusCode(200) .WithHeader("Content-Type", "application/json")); stub.Given( Request.Create() .WithPath("/api/eml/accounts/registrationemail") .WithHeader("ipm-eml-auth", "1234") //.WithHeader("Content-Type", "application/vnd.h2020ipmdecisions.email+json") .WithBody(new WildcardMatcher("*emailservicedown*")) .UsingPost()) .RespondWith(Response.Create() .WithStatusCode(400) .WithHeader("Content-Type", "application/json") .WithBody(@"{ ""message"": ""No connection could be made because the target machine actively refused it."" }")); stub.Given( Request.Create() .WithPath("/api/eml/accounts/forgotpassword") .WithHeader("ipm-eml-auth", "1234") //.WithHeader("Content-Type", "application/vnd.h2020ipmdecisions.email+json") .WithBody(new WildcardMatcher("*")) .UsingPost()) .AtPriority(10) .RespondWith(Response.Create() .WithStatusCode(200) .WithHeader("Content-Type", "application/json")); stub.Given( Request.Create() .WithPath("/api/eml/accounts/forgotpassword") .WithHeader("ipm-eml-auth", "1234") //.WithHeader("Content-Type", "application/vnd.h2020ipmdecisions.email+json") .WithBody(new WildcardMatcher("*failemail*")) .UsingPost()) .AtPriority(1) .RespondWith(Response.Create() .WithStatusCode(400) .WithHeader("Content-Type", "application/json") .WithBody(@"{ ""message"": ""No connection could be made because the target machine actively refused it."" }")); }
public async Task TestCreateDnsRecordAsync() { var zone = ZoneTestData.Zones.First(); var dnsRecord = DnsRecordTestData.DnsRecords.First(); var newRecord = new NewDnsRecord { Name = dnsRecord.Name, Content = dnsRecord.Content, Priority = dnsRecord.Priority, Proxied = dnsRecord.Proxied, Ttl = dnsRecord.Ttl, Type = dnsRecord.Type }; _wireMockServer .Given(Request.Create().WithPath($"/{ZoneEndpoints.Base}/{zone.Id}/{DnsRecordEndpoints.Base}").UsingPost()) .RespondWith(Response.Create().WithStatusCode(200) .WithBody(WireMockResponseHelper.CreateTestResponse(dnsRecord))); using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo); var created = await client.Zones.DnsRecords.AddAsync(zone.Id, newRecord); created.Result.Should().BeEquivalentTo(dnsRecord); }
private static void SetupGetVendorDetailsResponse() { // Return sample values for Account 100 and ALE 2000 _fakeCustomerEngagementApi.Given( Request.Create().WithPath($"/Finance/{_customerEngagementCompanyName}/vendor/aleid={_hashedLegalEntityId}") .UsingGet() ) .RespondWith( Response.Create() .WithStatusCode((int)HttpStatusCode.OK) .WithHeader("Content-Type", "application/json") .WithBody(GetSampleJsonResponse("VendorData.json"))); }
private void RegisterSelectQueryGetHandler(string query = "SELECT * WHERE {?s ?p ?o}") { _server.Given(Request.Create() .WithPath("/sparql") .UsingGet() .WithParam(queryParams => queryParams.ContainsKey("query") && queryParams["query"].Any(q => HttpUtility.UrlDecode(q).StartsWith(query)))) .RespondWith(Response.Create() .WithBody(SparqlResultsXml, encoding: Encoding.UTF8) .WithHeader("Content-Type", MimeTypesHelper.SparqlResultsXml[0]) .WithStatusCode(HttpStatusCode.OK)); }
public ResponseWithProxyTests() { _guid = Guid.NewGuid(); _server = WireMockServer.Start(); _server.Given(Request.Create().UsingPost().WithPath($"/{_guid}")) .RespondWith(Response.Create().WithStatusCode(201).WithBodyAsJson(new { p = 42 }).WithHeader("Content-Type", "application/json")); _server.Given(Request.Create().UsingPost().WithPath($"/{_guid}/append")) .RespondWith(Response.Create().WithStatusCode(201).WithBodyAsJson(new { p = 10 }).WithHeader("Content-Type", "application/json")); _server.Given(Request.Create().UsingPost().WithPath($"/prepend/{_guid}")) .RespondWith(Response.Create().WithStatusCode(201).WithBodyAsJson(new { p = 11 }).WithHeader("Content-Type", "application/json")); _server.Given(Request.Create().UsingPost().WithPath($"/prepend/{_guid}/append")) .RespondWith(Response.Create().WithStatusCode(201).WithBodyAsJson(new { p = 12 }).WithHeader("Content-Type", "application/json")); }
public async Task GetBannerInfo_StudentIdentifier_ShouldCallCorrectApiAndReturnBackStudentInfo(string identifier) { var bannerInfo = new BannerPersonInfo() { EmailAddress = identifier, WVUPID = Utils.ParseOrDefault(identifier, 11243213), FirstName = "Billy", LastName = "Loel", Teacher = false }; var cleanedIdentifier = identifier.Split("@")[0]; server .Given(Request.Create().WithPath($"/student/{cleanedIdentifier}").UsingGet()) .RespondWith( Response.Create() .WithStatusCode(200) .WithHeader("Content-Type", "application/json") .WithBodyAsJson(bannerInfo) ); var studentInfo = await bannerApi.GetBannerInfo(identifier); Assert.NotNull(studentInfo); Assert.False(studentInfo.Teacher); }
public async Task WithProxyUrl_WhenACallWasMadeWithProxyUrl_Should_BeOK() { _server.ResetMappings(); _server.Given(Request.Create().UsingAnyMethod()) .RespondWith(Response.Create().WithProxy(new ProxyAndRecordSettings { Url = "http://localhost:9999" })); await _httpClient.GetAsync(""); _server.Should() .HaveReceivedACall() .WithProxyUrl($"http://localhost:9999"); }
public async Task List() { _server.Given(Request.Create().WithParam("watch", MatchBehaviour.RejectOnMatch, "true").UsingGet()) .RespondWith(Response.Create().WithBodyAsJson(TestData.ListPodsTwoItems)); var sut = new KubernetesInformer <V1Pod>(_kubernetes); var result = await sut.GetResource(ResourceStreamType.List).ToList().TimeoutIfNotDebugging();; result.Should().HaveCount(2); result[0].EventFlags.Should().HaveFlag(EventTypeFlags.ResetStart); result[1].EventFlags.Should().HaveFlag(EventTypeFlags.ResetEnd); result[0].Value.Should().BeEquivalentTo(TestData.ListPodsTwoItems.Items[0]); result[1].Value.Should().BeEquivalentTo(TestData.ListPodsTwoItems.Items[1]); }
private void RegisterSelectQueryGetHandler(Predicate <string> queryPredicate, string results) { _server .Given(Request.Create() .WithPath("/sparql") .UsingGet() .WithParam(queryParams => queryParams.ContainsKey("query") && queryParams["query"].Any(q => queryPredicate(HttpUtility.UrlDecode(q))))) .RespondWith(Response.Create() .WithBody(results, encoding: Encoding.UTF8) .WithHeader("Content-Type", MimeTypesHelper.SparqlResultsXml[0]) .WithStatusCode(HttpStatusCode.OK)); }
public async Task TestGetRolesAsync() { var accountId = AccountTestData.Accounts.First().Id; _wireMockServer .Given(Request.Create().WithPath($"/{AccountEndpoints.Base}/{accountId}/{AccountEndpoints.Roles}").UsingGet()) .RespondWith(Response.Create().WithStatusCode(200) .WithBody(WireMockResponseHelper.CreateTestResponse(RoleTestData.Roles))); using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo); var roles = await client.Accounts.Roles.GetAsync(accountId); roles.Result.Should().BeEquivalentTo(RoleTestData.Roles); }
public CommitmentsV2ApiBuilder WithPing() { _server .Given( Request.Create() .WithPath($"/api/ping") .UsingGet() ) .RespondWith( Response.Create() .WithStatusCode((int)HttpStatusCode.OK) ); return(this); }
public TrainingProviderApiBuilder WithPing() { _server .Given( Request.Create() .WithPath($"/ping") .UsingGet() ) .RespondWith( Response.Create() .WithStatusCode((int)HttpStatusCode.OK) ); return(this); }
public async Task TestGetUserDetailsAsync() { var user = UserTestData.Users.First(); _wireMockServer .Given(Request.Create().WithPath($"/{UserEndpoints.Base}").UsingGet()) .RespondWith(Response.Create().WithStatusCode(200) .WithBody(WireMockResponseHelper.CreateTestResponse(user))); using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo); var userDetails = await client.Users.GetDetailsAsync(); userDetails.Result.Should().BeEquivalentTo(user); }
public async Task Get_DeveRetornarOk_QuandoRequestForValido() { //Arrange var chaveCampeonato = ChaveClassificacaoBuilder.Novo().ComParticipantesFixos().Build(); var participantes = chaveCampeonato.ObterParticipantes(); _wireMockServer .Given(_request) .RespondWith(Response.Create().WithSuccess().WithBodyAsJson(participantes)); //Act var response = await _httpClient.GetAsync(_endpoint); //Assert response.Should().Be200Ok().And.BeAs(participantes); }