public void WhenRegisteringAnInteractionThatIsNeverSent_ThenPactFailureExceptionIsThrown() { _mockProviderService .UponReceiving("A POST request to create a new thing") .With(new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/things", Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new { thingId = 1234, type = "Awesome" } }) .WillRespondWith(new ProviderServiceResponse { Status = 201 }); Assert.Throws <PactFailureException>(() => _mockProviderService.VerifyInteractions()); }
public async Task be_able_to_order_a_beer_when_is_old_enoughAsync() { mockProviderService .Given("A client is adult (age >= 18)") .UponReceiving("A POST request to order a beer") .With(new ProviderServiceRequest { Method = HttpVerb.Post, Path = BEERS_PATH, Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" }, }, Body = new { Age = 18 } }) .WillRespondWith(new ProviderServiceResponse { Status = 201, Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" } }, Body = "Created" }); await alcoholic.OrderAsync(ADULT); mockProviderService.VerifyInteractions(); }
public void TestGetTribbleReturnsATribble() { _mockProviderService .Given("There is a tribble with id '1'") .UponReceiving("A GET request to retrieve the tribble") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/tribbles/1", Headers = new Dictionary <string, string> { { "Accept", "application/json" } } }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, string> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new { Id = 1, Colour = "blue", Furryness = "High", Hungry = true } }); var consumer = new TribbleClient.Client(_mockProviderServiceBaseUri); var result = consumer.GetTribble(1); Assert.AreEqual("blue", result.Colour); _mockProviderService.VerifyInteractions(); }
public async Task TestGetOnRootOfExampleApiReturnsExpectedThing() { _mockProviderService.Given("I just hit controller root") .UponReceiving("A GET request at the root of the controller") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/" }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, object> { { "Content-Type", "text/plain; charset=utf-8" } }, Body = "Ahh OK" }); var consumer = new ExampleApiClient(); var result = await consumer.GetString(_mockProviderServiceBaseUri); Assert.AreEqual("Ahh OK", result); _mockProviderService.VerifyInteractions(); //NOTE: Verifies that interactions registered on the mock provider are called at least once }
public async Task WhenCryptocurrencyIsNotSupportedReturnsNotFound() { const string cryptocurrency = "unknownCryptocurrency"; var endpointUnderTest = $"/api/priceindex/{cryptocurrency}"; _mockProviderService .UponReceiving($"A GET request to get price indexes for '{cryptocurrency}' cryptocurrency") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = endpointUnderTest }) .WillRespondWith(new ProviderServiceResponse { Status = (int)HttpStatusCode.NotFound }); var consumer = new TestWebClient(_mockProviderServiceBaseUri); var(statusCode, coinDeskResponse) = await consumer.Get(endpointUnderTest); Assert.Equal(HttpStatusCode.NotFound, statusCode); Assert.Null(coinDeskResponse); _mockProviderService.VerifyInteractions(); }
public void GetAllCars_WhenCalled_ReturnsAllEvents() { var test = new[] { new { carId = Guid.Parse("45D80D13-D5A2-48D7-8353-CBB4C0EAABF5"), mileage1 = 0, fuel = "Gasoline" }, new { carId = Guid.Parse("83F9262F-28F1-4703-AB1A-8CFD9E8249C9"), mileage1 = 0, fuel = "Gasoline" }, new { carId = Guid.Parse("3E83A96B-2A0C-49B1-9959-26DF23F83AEB"), mileage1 = 15000, fuel = "Diesel" } }; var res = new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" } }, Body = test }; //Arrange _mockProviderService.Given("there are cars with ids '45D80D13-D5A2-48D7-8353-CBB4C0EAABF5', '83F9262F-28F1-4703-AB1A-8CFD9E8249C9' and '3E83A96B-2A0C-49B1-9959-26DF23F83AEB'") .UponReceiving("a request to retrieve all cars") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/cars", Headers = new Dictionary <string, object> { { "Accept", "application/json" }, } }) .WillRespondWith(res); var consumer = new CarsApiClient(_mockProviderServiceBaseUri); //Act var events = consumer.GetAllCars(); //Assert Assert.NotEmpty(events); Assert.Equal(3, events.Count()); _mockProviderService.VerifyInteractions(); }
public void GetAllEvents_WhenCalled_ReturnsAllEvents() { //Arrange _mockProviderService.Given("There are events with ids '45D80D13-D5A2-48D7-8353-CBB4C0EAABF5', '83F9262F-28F1-4703-AB1A-8CFD9E8249C9' and '3E83A96B-2A0C-49B1-9959-26DF23F83AEB'") .UponReceiving("A GET request to retrieve all events") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/events", Headers = new Dictionary <string, string> { { "Accept", "application/json" } } }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, string> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new [] { new { eventId = Guid.Parse("45D80D13-D5A2-48D7-8353-CBB4C0EAABF5"), timestamp = "2014-06-30T01:37:41.0660548", eventType = "SearchView" }, new { eventId = Guid.Parse("83F9262F-28F1-4703-AB1A-8CFD9E8249C9"), timestamp = "2014-06-30T01:37:52.2618864", eventType = "DetailsView" }, new { eventId = Guid.Parse("3E83A96B-2A0C-49B1-9959-26DF23F83AEB"), timestamp = "2014-06-30T01:38:00.8518952", eventType = "SearchView" } } }); var consumer = new EventsApiClient(_mockProviderServiceBaseUri); //Act var events = consumer.GetAllEvents(); //Assert Assert.NotEmpty(events); Assert.Equal(3, events.Count()); _mockProviderService.VerifyInteractions(); }
public void GetAllEvents_WithNoAuthorizationToken_ShouldFail() { //Arrange _mockProviderService.Given("there are events with ids '45D80D13-D5A2-48D7-8353-CBB4C0EAABF5', '83F9262F-28F1-4703-AB1A-8CFD9E8249C9' and '3E83A96B-2A0C-49B1-9959-26DF23F83AEB'") .UponReceiving("a request to retrieve all events with no authorization") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/events", Headers = new Dictionary <string, string> { { "Accept", "application/json" } } }) .WillRespondWith(new ProviderServiceResponse { Status = 401, Headers = new Dictionary <string, string> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new { message = "Authorization has been denied for this request." } }); var consumer = new EventsApiClient(_mockProviderServiceBaseUri); //Act //Assert Assert.Throws <HttpRequestException>(() => consumer.GetAllEvents()); _mockProviderService.VerifyInteractions(); }
public void GetUser_WhenPactExists_ReturnsUser() { // Arrange var expectedUser = new User { Id = 0, Name = "Tony Stark", Occupation = "Iron Man", Roles = new List <Role> { new Role { Name = "Genius", Description = "Building Jarvis, aka Vision, aka AI" }, new Role { Name = "CEO", Description = "Lying to the board" }, new Role { Name = "Fighter", Description = "Made Thanos bleed" } } }; _mockProviderService .Given("There is a user for the id") .UponReceiving("A properly formatted GET request with the user id") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/api/user/0" }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" } }, Body = expectedUser }); var consumer = new PactNetClient(_baseUri); // Act var result = consumer.Get(0).GetAwaiter().GetResult(); // Assert Assert.NotNull(result); Assert.Equal(result.Id, expectedUser.Id); Assert.Equal(result.Name, expectedUser.Name); _mockProviderService.VerifyInteractions(); }
public void Return_RegionStock_Status_WHEN_Variant_Is_Found() { // Arrange var variantId = 4567; var regionId = "US"; var stockStatus = "InStock"; _mockProviderService .Given($"Variant {variantId} exists in region {regionId} and has status {stockStatus}") .UponReceiving($"A GET request to retrieve the RegionStock status for variant {variantId} to region {regionId}") .With(BuildRegionStockStatusRequest(regionId, variantId)) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, string> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new { variantId, status = "InStock" } }); // Act var regionStock = _sqsRegionStockApiClient.GetRegionStockStatus(regionId, variantId); // Assert regionStock.Should().NotBeNull(); regionStock.Value.Should().Be(RegionStockStatus.InStock); _mockProviderService.VerifyInteractions(); }
public async Task Given_Valid_Id_Should_Return_Dto() { _mockProviderService .Given("Some value") .UponReceiving("A GET Request") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/api/values" }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" } }, Body = Match.Type(new { NumberParam = 888, StringParam = "fake" }) }); var httpClient = new HttpClient(); var response = await httpClient.GetAsync($"{_serviceUri}/api/values"); var json = await response.Content.ReadAsStringAsync(); var someDto = JsonConvert.DeserializeObject <SomeDto>(json); Assert.Equal(888, someDto.NumberParam); _mockProviderService.VerifyInteractions(); }
public void IsAlive_WhenApiIsAlive_ReturnsTrue() { //Arrange Guid fixtureIdSet = new Guid("713be2bd-36e3-43b8-ae2b-0ddeac06cd9f"); _mockProviderService.Given("a request to check the api response") .UponReceiving("I call fixture service using a valid fixture Id") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = $"/api/v1.0/fixture/{fixtureIdSet}", Headers = new Dictionary <string, object> { { "Accept", "application/json" }, { "X-Clarksons-Security-Cloud", "9xoNm1ZZk6zn3uzu2X18xXtRM5MurptRBsWGA4A1zIM+HSZdJDp9aqlRD+oCsNDOL4UPwU5oFNJHa3T/c1FeVG4EBodw/ybiZq8xb4XSPcELNZ3IKbM1d1tvVGBbWi8q7QfxRODngc+yd25V6fW+Lw==" } } }) .WillRespondWith(new ProviderServiceResponse { Status = 200, }); var consumer = new FixtureConsumer(_mockProviderServiceBaseUri); //Act var result = consumer.GetFixture(fixtureIdSet, "9xoNm1ZZk6zn3uzu2X18xXtRM5MurptRBsWGA4A1zIM+HSZdJDp9aqlRD+oCsNDOL4UPwU5oFNJHa3T/c1FeVG4EBodw/ybiZq8xb4XSPcELNZ3IKbM1d1tvVGBbWi8q7QfxRODngc+yd25V6fW+Lw=="); //Assert //Assert.Equal(fixtureIdSet, result.FixtureId); _mockProviderService.VerifyInteractions(); }
public async Task Search_WhenApiFindsCustomer_ReturnsTheCustomer() { // Arrange _mockProviderService .Given("There is a customer with an ID of 1") .UponReceiving("A GET request to retrieve the customer") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/customer/1", Headers = new Dictionary <string, object> { { "Accept", "application/json" } } }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new { id = 1, firstName = "Paul", surname = "Davidson" } }); var consumer = GetCustomerClient(); // Act var customer = await consumer.GetAsync(1); // Assert Assert.Equal(1, customer.Id); Assert.Equal("Paul", customer.FirstName); Assert.Equal("Davidson", customer.Surname); _mockProviderService.VerifyInteractions(); }
public async Task GetQuizzes_WhenSomeQuizzesExists_ReturnsTheQuizzes() { _mockProviderService .Given("There are some quizzes") .UponReceiving("A GET request to retrieve the quizzes") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/api/quizzes", Headers = new Dictionary <string, object> { { "Accept", "application/json" } } }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new[] { new { id = 123, title = "This is quiz 123" }, new { id = 124, title = "This is quiz 124" } } }); var consumer = new QuizClient(_mockProviderServiceBaseUri, Client); var result = await consumer.GetQuizzesAsync(CancellationToken.None); Assert.True(string.IsNullOrEmpty(result.ErrorMessage), result.ErrorMessage); Assert.Equal(HttpStatusCode.OK, result.StatusCode); Assert.NotEmpty(result.Value); Assert.Equal(2, result.Value.Count()); _mockProviderService.VerifyInteractions(); }
public void failed_test_case_send_request_without_extra_header() { _mockProviderService .Given("There is a something with id 'tester'") .UponReceiving("A GET request to retrieve the something") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/somethings/tester", Headers = new Dictionary <string, string> { { "Accept", "application/json" }, { "Origin", "http://localhost.com" }, { "Referrer", "http://baidu.com/index.html" }, { "Agent", "1111" }, { "Service", "Product" }, } }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, string> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new { id = "tester", firstName = "Totally", lastName = "Awesome" } }); using (var client = new HttpClient { BaseAddress = new Uri(_mockProviderServiceBaseUri) }) { var request = new HttpRequestMessage(HttpMethod.Get, "/somethings/tester"); request.Headers.Add("Accept", "application/json"); client.SendAsync(request).Wait(); } _mockProviderService.VerifyInteractions(); }
public async void GetRecipes_WillReturn200() { var response = new List <object>(); response.Add( new { name = "My another recipe", author = "*****@*****.**", userId = "auth0|foobar", style = "IPA" } ); _mockProviderService .Given("There is some recipes") .UponReceiving("GET request to retrieve recipes") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/v1/recipe", Query = "userId=auth0userid" }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Body = response, Headers = new Dictionary <string, object> { { "Content-Type", "application/json" } } }); var consumer = CreateConsumer(); var result = await consumer.SearchRecipes(new RecipeSearchFilters { UserId = "auth0userid" }); Assert.Equal(result.Count(), response.Count()); _mockProviderService.VerifyInteractions(); }
public async Task AddWord_Should_Return_First_Letter_And_Modify_State() { //Arrange _mockProviderService.Given("there is a count of 1 for words beginning with 'A'") .UponReceiving("a request with the word 'Aardvark'") .With(new ProviderServiceRequest { Method = HttpVerb.Put, Path = "/AddWord/Aardvark", Headers = new Dictionary <string, string> { { "Content-Length", "0" }, { "Content-Type", "text/plain; charset=utf-8" }, { "Host", "localhost:1234" } } }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, string> { { "Content-Type", "application-json; charset=utf-8" } }, Body = new { Letter = "A", Count = "2" } }); var uriResolver = A.Fake <IServiceUriResolver>(); A.CallTo(() => uriResolver.GetServiceUri()).Returns(new Uri(_mockProviderServiceBaseUri)); var httpCommunicationClientFactory = A.Fake <ICommunicationClientFactory <HttpCommunicationClient> >(); A.CallTo(httpCommunicationClientFactory) .WithReturnType <Task <HttpCommunicationClient> >() .Returns(new HttpCommunicationClient(new HttpClient(), _mockProviderServiceBaseUri)); var fabricClientQueryManager = A.Fake <IFabricClientQueryManager>(); var consumer = new DefaultController(uriResolver, fabricClientQueryManager, httpCommunicationClientFactory ); var result = await consumer.AddWord("Aardvark"); var content = await((StringContent)result.Content).ReadAsStringAsync(); Assert.Equal("<h1>Aardvark</h1> added to partition with key <h2>1</h2>", content); _mockProviderService.VerifyInteractions(); }
public void GetAsync_WhenIdAndCancellationTokenIsPassedIn_ReturnsEntity() { // arrange DateTime?startDate = new DateTime(2014, 10, 22); DateTime?endDate = new DateTime(2014, 10, 29); _mockProviderService .Given(string.Format("Given I have Timesheet data for the date range {0} to {1}", startDate, endDate)) .UponReceiving(string.Format("A GET request for Timesheet data for the daternage {0} to {1}", startDate, endDate)) .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = string.Format("/accountright/{0}/{1}/{2}", _cfUid, _service.Route, _uid), Headers = new Dictionary <string, string> { { "Authorization", "Bearer" }, { "Accept-Encoding", "gzip" }, { "User-Agent", ApiRequestHelper.UserAgent }, { "x-myobapi-key", "" }, { "x-myobapi-version", "v2" }, { "x-myobapi-cftoken", Convert.ToBase64String(Encoding.UTF8.GetBytes("Administrator:")) }, }, Query = string.Format("StartDate={0}&EndDate={1}", startDate.Value.Date.ToString("s"), endDate.Value.Date.ToString("s")) }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, string> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new //NOTE: Note the case sensitivity here, the body will be serialised as per the casing defined { StartDate = startDate.Value.Date.ToString("s"), EndDate = endDate.Value.Date.ToString("s") } }); // act var result = _service.GetAsync(_cf, _uid, startDate.Value, endDate.Value, new CompanyFileCredentials("Administrator", ""), new CancellationToken()).Result; // assert Assert.NotNull(result); _mockProviderService.VerifyInteractions(); }
public void GetSomething_WhenTheTesterSomethingExists_ReturnsTheSomething() { //Arrange _mockProviderService .Given("There is a something with id 'tester'") .UponReceiving("A POST request to retrieve the something") .With(new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/posts", Headers = new Dictionary <string, object> { { "Content-Type", "application/json" }, { "Accept", "application/json" } }, Body = new //NOTE: Note the case sensitivity here, the body will be serialised as per the casing defined { UserId = "123", Body = "postBody", Id = "1234", Title = "postTitle" } } ) .WillRespondWith(new ProviderServiceResponse { Status = 201, Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" } } }); //NOTE: WillRespondWith call must come last as it will register the interaction //_mockProviderService.VerifyInteractions(); //NOTE: Verifies that interactions registered on the mock provider are called once and only once var consumer = new ApiClient(_mockProviderServiceBaseUri); //Act var result = consumer.GetResponse("Created"); //Assert Assert.AreEqual("Created", result.ToString()); _mockProviderService.VerifyInteractions(); //NOTE: Verifies that interactions registered on the mock provider are called once and only once }
public void GetWeather_CityExists_ReturnsWeather() { _mockService .Given("Helsinki is a valid city") .UponReceiving("A GET request to retrieve weather for Helsinki") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/weather/Helsinki", Headers = new Dictionary <string, object> { { "Accept", "application/json" } } }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new { temperature = -15.0, humidity = 80.0, windSpeed = 5.0 } }); var api = new ApiClient(_mockServiceUri); var result = api.GetWeather("Helsinki").Result; Assert.AreEqual(-15.0, result.Temperature); Assert.AreEqual(80.0, result.Humidity); Assert.AreEqual(5.0, result.WindSpeed); _mockService.VerifyInteractions(); }
public void Able_To_Retrieve_Consumers() { mockProviderService = consumerPact.MockProviderService; mockProviderServiceBaseUri = consumerPact.MockProviderServiceBaseUri; consumerPact.MockProviderService.ClearInteractions(); mockProviderService .Given("Get customers'") .UponReceiving("A GET request to retrieve the customers") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/customers", Headers = new Dictionary <string, object>() { { "Accept", "application/json" } } }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Body = new GetCustomersResponse { _Embedded = new Embedded { Customer = new Customer[] { new Customer { FirstName = "Tester", LastName = "Toster" } } } }, Headers = new Dictionary <string, object>() { { "Content-Type", "application/json; charset=utf-8" } } }); var consumer = new WebShopApiClient(new Uri(mockProviderServiceBaseUri), "user", "password"); var result = consumer.GetCustomers().Result; Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(GetCustomersResponse)); mockProviderService.VerifyInteractions(); consumerPact.Dispose(); }
public async Task GetSomething_TheTesterSomethingExists_ReturnsTheSomething() { // arrange const string expectedId = "83F9262F-28F1-4703-AB1A-8CFD9E8249C9"; const string expectedFirstName = "some-first-name-03"; const string expectedLastName = "some-last-name"; const int expectedAge = 42; var expectedSomething = new Something(expectedId, expectedFirstName, expectedLastName, expectedAge); const string guidRegex = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"; _mockProviderService .Given("Some application state") .UponReceiving("A GET request to retrieve something") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = Match.Regex($"/somethings/{expectedId}", $"^\\/somethings\\/{guidRegex}$"), Query = "field1=value1&field2=value2", Headers = new Dictionary <string, object> { { "Accept", "application/json" } } }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" } }, Body = Match.Type(new { id = "83F9262F-28F1-4703-AB1A-8CFD9E8249C9", firstName = "some-first-name-03", lastName = "some-last-name", age = 42 }) }); var consumer = new SomethingApiClient($"http://localhost:{MockServerPort}"); // act Something actualSomething = await consumer.GetSomething(expectedId).ConfigureAwait(false); // assert _mockProviderService.VerifyInteractions(); actualSomething.Should().BeEquivalentTo(expectedSomething); }
public void WhenApiIsUp_ReturnsTrue() { //Arrange _mockProviderService.UponReceiving("a request to check the api status") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Headers = new Dictionary <string, object> { { "Accept", "application/json" } }, Path = "/echo/status" }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new { up = true, upSince = DateTime.UtcNow, version = "2.0.0", message = "I'm up and running from last 19 hours." } }); var consumer = new ProductApiClient(_serviceBaseUri); //Act var result = consumer.ApiStatus().Up; //Assert Assert.True(result); _mockProviderService.VerifyInteractions(); }
static void Main(string[] args) { var consumerPact = new ConsumerMyApiPact(); _mockProviderService = consumerPact.MockProviderService; _mockProviderServiceBaseUri = consumerPact.MockProviderServiceBaseUri; consumerPact.MockProviderService.ClearInteractions(); //NOTE: Clears any previously registered interactions before the test is run _mockProviderService .Given("Get user with id '1'") .UponReceiving("A GET request to retrieve the user") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/user/1", Headers = new Dictionary <string, string> { { "Accept", "application/json" } } }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, string> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new //NOTE: Note the case sensitivity here, the body will be serialised as per the casing defined { id = 1, firstName = "Tanmoy", lastName = "Saha" } }); //NOTE: WillRespondWith call must come last as it will register the interaction var consumer = new UserApiClient(_mockProviderServiceBaseUri); //Act var result = consumer.GetUsers(1); //Assert result.Should().NotBeNull(); _mockProviderService.VerifyInteractions(); //NOTE: Verifies that interactions registered on the mock provider are called once and only once consumerPact.Dispose(); }
public void GetCustomerById_WithNoAuthorizationToken_ShouldFail() { int customerId = 20; //Arrange _mockProviderService.Given(String.Format("there is a customer with id '{0}'", customerId)) .UponReceiving(String.Format("a request to retrieve customer with id '{0}' with no authorization", customerId)) .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = String.Format("/template/api/v1/customer/{0}", customerId) }) .WillRespondWith(new ProviderServiceResponse { Status = 401 }); var consumer = new CustomerController(_mockProviderServiceBaseUri); //Act //Assert Assert.ThrowsAny <Exception>(() => consumer.GetCustomerById(customerId)); _mockProviderService.VerifyInteractions(); }
public void Add_customer() { //Arrange _mockProviderService .Given("There is a service") .UponReceiving("A POST request to create a customer") .With(new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/customers", Query = "", Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new Customer { Firstname = "richard", Surname = "parkins" } }) .WillRespondWith(new ProviderServiceResponse { Status = 201, Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" }, { "Location", "http://localhost:5000/customers/richard-parkins" } }, Body = new Customer { Id = "richard-parkins", Firstname = "richard", Surname = "parkins" } }); var consumer = new PactConsumer(_mockProviderServiceBaseUri); //Act var result = consumer.CreateUser("richard", "parkins").Result; //Assert Assert.EndsWith("/customers/richard-parkins", result.ToString()); _mockProviderService.VerifyInteractions(); }
public async Task GetSomething_WhenTheTesterSomethingExists_ReturnsTheSomething() { string expectedId = "tester"; // Arrange _mockProviderService .Given("There is a something with id 'tester'") .UponReceiving("A Get request to retrieve the Id of something") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = $"/Somethings/{expectedId}", Headers = new Dictionary <string, object> { { "Accept", "applciation/json" } } }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new { Id = "tester", FirstName = "Totally", LastName = "Awesome" } }); var consumer = new SomethingApiClient(_serviceUri); // var httpClient = new HttpClient(); // var response = await httpClient.GetAsync($"{_serviceUri}/somethings/tester"); // var json = await response.Content.ReadAsStringAsync(); // var something = JsonConvert.DeserializeObject<Something>(json); // Act var result = await consumer.GetSomething("tester"); // Assert Assert.Equal(expectedId, result.Id); Assert.Equal("Totally", result.FirstName); Assert.Equal("Awesome", result.LastName); _mockProviderService.VerifyInteractions(); }
public async Task Test1() { _mockProviderService .UponReceiving("Receber a previsão do tempo para amanhã") .With(new ProviderServiceRequest { Path = "/WeatherForecast/tomorrow", Method = HttpVerb.Get, Headers = new Dictionary <string, object> { { "Accept", "application/json" } } }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new { date = DateTime.Today.AddDays(1), summary = "Chilly", temperatureC = 15, temperatureF = 58 } }); var consumer = new WeatherForecastApiClient(_mockProviderServiceBaseUri); // Act var result = await consumer.GetForecastTomorrow(); // Assert result.Should().BeEquivalentTo( new WeatherForecastResponse { Date = DateTime.Today.AddDays(1), Summary = "Chilly", TemperatureC = 15, TemperatureF = 58 } ); _mockProviderService.VerifyInteractions(); }
public void GetSomething_WhenTheTesterSomethingExists_ReturnsTheSomething() { //Arrange _mockProviderService .Given("There is a something with id 'tester'") .UponReceiving("A GET request to retrieve the something") .With(GetTesterSomethingRequest()) .WillRespondWith(GetTesterSomethingResponse()); var consumer = new SomethingApiClient(_mockProviderServiceBaseUri); //Act var result = consumer.GetSomething("tester"); //Assert Assert.Equal("tester", result.id); _mockProviderService.VerifyInteractions(); }
public void GetUserById_WhenTheUserExists_ReturnsUser() { //Arrange var guidRegex = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"; var userId = Guid.Parse("83F9262F-28F1-4703-AB1A-8CFD9E8249C9"); _mockProviderService .Given($"There is an user with id {userId}") .UponReceiving($"a request to retrieve user id {userId}") .With(new ProviderServiceRequest { Method = HttpVerb.Get, Path = Match.Regex($"/api/users/{userId}", $"^\\/api\\/users\\/{guidRegex}$"), Headers = new Dictionary <string, object> { { "Accept", "application/json" } } }) .WillRespondWith(new ProviderServiceResponse { Status = 200, Headers = new Dictionary <string, object> { { "Content-Type", "application/json; charset=utf-8" }, { "Server", Match.Type("RubyServer") } }, Body = new { userid = userId, firstName = "Jean", lastName = "du Jardin" } }); var consumer = new UserApiClient(_mockProviderServiceBaseUri); //Act var result = consumer.GetUserById(userId); //Assert Assert.Equal(userId, result.UserId); Assert.Equal("Jean", result.FirstName); _mockProviderService.VerifyInteractions(); }