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();
        }
Esempio n. 2
0
        public void GivenAFilmThatDoesExistWhenGettingTheDescriptionThenTheDescriptionIsReturned(string url)
        {
            _fakeOmdbService.Given("The film Inception").UponReceiving("A request for it")
            .With(OmdbRequest("inception", "2010")).WillRespondWith(OmdbResponse(_inceptionPlot));

            var repository = new FilmDescriptionRepository(url);
            var result     = repository.GetDescriptionResult("inception", "2010");

            Assert.That(result.Result, Is.EqualTo(RepositoryResult.Successful));
            Assert.That(result.Value, Is.EqualTo(_inceptionPlot));
        }
Esempio n. 3
0
        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();
        }
Esempio n. 4
0
        public void ItHandlesInvalidInstrumentName()
        {
            // Arange
            const string instrument = "Ta";

            var invalidRequestMessage = $"{instrument} is not valid";

            //Mocking ProviderService
            //1-Provider State
            //2-Description for Specified Provider State
            //3-Specifing the Request
            //4-The Desired Response for Specified Request

            _mockProviderService
            .Given("There is no Instrument")
            .UponReceiving("An invalid GET request for Instruments with invalid name")
            .With(new ProviderServiceRequest
            {
                Method = HttpVerb.Get,
                Path   = "/api/Instrument",
                Query  = $"name={instrument}"
            })
            .WillRespondWith(new ProviderServiceResponse
            {
                Status  = 404,
                Headers = new Dictionary <string, object>
                {
                    { "Content-Type", "application/json; charset=utf-8" }
                },
                Body = new
                {
                    message = invalidRequestMessage,
                    result  = "Failed",
                    data    = ""
                }
            });

            // Act
            var result = HttpUtility.GetInstrumentDesc(instrument, _baseUri)
                         .GetAwaiter()
                         .GetResult();

            var resultBodyText = result.Content.ReadAsStringAsync()
                                 .GetAwaiter()
                                 .GetResult();

            // Assert
            Assert.Contains(invalidRequestMessage, resultBodyText); //Very simple assertion to assert if response message contains expected result.
        }
Esempio n. 5
0
        public void ItHandlesInvalidDateParam()
        {
            // Arange
            string personMessagebody = "{\"firstName\":\"Alireza\",\"lastName\":\"Oroumand\",\"id\":\"3fa85f64-5717-4562-b3fc-2c963f66afa6\"}";

            _mockProviderService.Given("There is data")
            .UponReceiving("Valid person Data")
            .With(new ProviderServiceRequest
            {
                Method = HttpVerb.Get,
                Path   = "/api/person/",
                Query  = "id=3fa85f64-5717-4562-b3fc-2c963f66afa6"
            })
            .WillRespondWith(new ProviderServiceResponse
            {
                Status  = 200,
                Headers = new Dictionary <string, object>
                {
                    {
                        "Content-Type", "application/json; charset=utf-8"
                    }
                },
                Body = personMessagebody
            });

            // Act
            var result         = APICaller.Call(_mockProviderServiceBaseUri, "3fa85f64-5717-4562-b3fc-2c963f66afa6").GetAwaiter().GetResult();
            var resultBodyText = result.Content.ReadAsStringAsync().GetAwaiter().GetResult();

            // Assert
            Assert.Equal(resultBodyText, personMessagebody);
        }
        public void ItHandlesInvalidDateParam()
        {
            // Arange
            var invalidRequestMessage = "validDateTime is not a date or time";

            _mockProviderService.Given("There is data")
            .UponReceiving("A invalid GET request for Date Validation with invalid date parameter")
            .With(new ProviderServiceRequest
            {
                Method = HttpVerb.Get,
                Path   = "/api/provider",
                Query  = "validDateTime=lolz"
            })
            .WillRespondWith(new ProviderServiceResponse {
                Status  = 400,
                Headers = new Dictionary <string, object>
                {
                    { "Content-Type", "application/json; charset=utf-8" }
                },
                Body = new
                {
                    message = invalidRequestMessage
                }
            });
            // Act
            var result         = ConsumerApiClient.ValidateDateTimeUsingProviderApi("lolz", _mockProviderServiceBaseUri).GetAwaiter().GetResult();
            var resultBodyText = result.Content.ReadAsStringAsync().GetAwaiter().GetResult();

            // Assert
            Assert.Contains(invalidRequestMessage, resultBodyText);
        }
Esempio n. 7
0
 public static void CreateOn(IMockProviderService customerApi)
 {
     customerApi
         .Given("There is a customer with ID tester")
         .UponReceiving("A GET request to retrieve the customer")
         .With(new ProviderServiceRequest
         {
             Method = HttpVerb.Get,
             Path = "/api/customers/tester",
             Headers = new Dictionary<string, string>
             {
                 {"Accept", "application/json"},
                 {"Another", "header"}
             }
         })
         .WillRespondWith(new ProviderServiceResponse
         {
             Status = (int)HttpStatusCode.OK,
             Headers = new Dictionary<string, string>
             {
                 {"Content-Type", "application/json; charset=utf-8" },
                 {"Another", "header"}
             },
             Body = new //NOTE: Note the case sensitivity here, the body will be serialised as per the casing defined
             {
                 Id = "tester",
                 FirstName = "Totally",
                 LastName = "Awesome"
             }
         }); //NOTE: WillRespondWith call must come last as it will register the interaction
 }
Esempio n. 8
0
 public static void CreateOn(IMockProviderService customerApi)
 {
     customerApi
     .Given("Version is 1.2.3.4")
     .UponReceiving("A GET request to retrieve the version")
     .With(new ProviderServiceRequest
     {
         Method  = HttpVerb.Get,
         Path    = "/api/version",
         Headers = new Dictionary <string, string>
         {
             { "Accept", "application/json" },
             { "Another", "header" }
         }
     })
     .WillRespondWith(new ProviderServiceResponse
     {
         Status  = (int)HttpStatusCode.OK,
         Headers = new Dictionary <string, string>
         {
             { "Content-Type", "application/json; charset=utf-8" },
             { "Another", "header" }
         },
         Body = new
         {
             Build = "1.2.3.4",
             Date  = "2015-09-17T20:29:13"
         }
     });
 }
Esempio n. 9
0
 public static void CreateOn(IMockProviderService customerApi)
 {
     customerApi
         .Given("Version is 1.2.3.4")
         .UponReceiving("A GET request to retrieve the version")
         .With(new ProviderServiceRequest
         {
             Method = HttpVerb.Get,
             Path="/api/version",
             Headers=new Dictionary<string, string>
             {
                 {"Accept", "application/json"},
                 {"Another", "header" }
             }
         })
         .WillRespondWith(new ProviderServiceResponse
         {
             Status = (int)HttpStatusCode.OK,
             Headers = new Dictionary<string, string>
             {
                 {"Content-Type", "application/json; charset=utf-8" },
                 {"Another", "header"}
             },
             Body = new
             {
                 Build="1.2.3.4",
                 Date="2015-09-17T20:29:13"
             }
         });
 }
Esempio n. 10
0
        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();
        }
Esempio n. 11
0
        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();
        }
Esempio n. 12
0
        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 async Task Consumer()
        {
            var article = new { text = "Test pact" };

            _mockProviderService
            .Given("New article")
            .UponReceiving("Valid POST Article object")
            .With(new ProviderServiceRequest
            {
                Method  = HttpVerb.Post,
                Path    = _path,
                Body    = article,
                Headers = new Dictionary <string, object> {
                    { "Content-Type", "application/json; charset=utf-8" }
                },
            })
            .WillRespondWith(new ProviderServiceResponse
            {
                Status  = (int)HttpStatusCode.Created,
                Headers = new Dictionary <string, object> {
                    { "Content-Type", "application/json; charset=utf-8" }
                },
                Body = new { id = Match.Type(1), creationDate = Match.Type(DateTime.Now), article.text }
            });

            var result = await _consumerPactClassFixture.PostAsync(_path, article);

            Assert.Equal(HttpStatusCode.Created, result.StatusCode);
            JsonSerializer.Deserialize <Article>(await result.Content.ReadAsStringAsync());
        }
        public async Task Consumer()
        {
            var firstArticle = DataSeed.GetFirstArticle();

            _mockProviderService
            .Given("Existing article id")
            .UponReceiving("Valid GET Article")
            .With(new ProviderServiceRequest
            {
                Method = HttpVerb.Get,
                Path   = _path,
            })
            .WillRespondWith(new ProviderServiceResponse
            {
                Status  = (int)HttpStatusCode.OK,
                Headers = new Dictionary <string, object> {
                    { "Content-Type", "application/json; charset=utf-8" }
                },
                Body = firstArticle
            });

            var result = await _consumerPactClassFixture.GetAsync(_path);

            Assert.Equal(HttpStatusCode.OK, result.StatusCode);
            JsonSerializer.Deserialize <Article>(await result.Content.ReadAsStringAsync());
        }
Esempio n. 15
0
 public static void CreateOn(IMockProviderService customerApi)
 {
     customerApi
     .Given("There is a customer with ID tester")
     .UponReceiving("A GET request to retrieve the customer")
     .With(new ProviderServiceRequest
     {
         Method  = HttpVerb.Get,
         Path    = "/api/customers/tester",
         Headers = new Dictionary <string, string>
         {
             { "Accept", "application/json" },
             { "Another", "header" }
         }
     })
     .WillRespondWith(new ProviderServiceResponse
     {
         Status  = (int)HttpStatusCode.OK,
         Headers = new Dictionary <string, string>
         {
             { "Content-Type", "application/json; charset=utf-8" },
             { "Another", "header" }
         },
         Body = new     //NOTE: Note the case sensitivity here, the body will be serialised as per the casing defined
         {
             Id        = "tester",
             FirstName = "Totally",
             LastName  = "Awesome"
         }
     });     //NOTE: WillRespondWith call must come last as it will register the interaction
 }
        public async void RetrieveProducts()
        {
            // Arrange
            _mockProviderService.Given("products exist")
            .UponReceiving("A request to get products")
            .With(new ProviderServiceRequest
            {
                Method = HttpVerb.Get,
                Path   = "/products",
            })
            .WillRespondWith(new ProviderServiceResponse {
                Status  = 200,
                Headers = new Dictionary <string, object>
                {
                    { "Content-Type", "application/json; charset=utf-8" }
                },
                Body = new MinTypeMatcher(new
                {
                    id   = "27",
                    name = "burger",
                    type = "food"
                }, 1)
            });

            // Act
            var            consumer = new ProductClient();
            List <Product> result   = await consumer.GetProducts(_mockProviderServiceBaseUri);

            // Assert
            result.Should().NotBeNull();
            result.Should().HaveCount(1);
            result[0].id.Should().Equals("27");
            result[0].name.Should().Equals("burger");
            result[0].type.Should().Equals("food");
        }
Esempio n. 17
0
        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();
        }
Esempio n. 19
0
        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();
        }
Esempio n. 20
0
 public override Task <IRestResponse> ExecuteTaskAsync(IRestRequest request)
 {
     _mockProviderService
     .Given(ConditionDescription)
     .UponReceiving(RequestDescription)
     .With(request)
     .WillRespondWith(Response);
     return(base.ExecuteTaskAsync(request));
 }
        public void ItHandlesInvalidDateParam()
        {
            /*
             * All test cases follow the same 3 steps
             * 1) Mock out an interaction withe provider api
             * 2) Interaction with the mocked out interaction using the Consumer [HttpDelete]
             * 3) Aseert the result is what we expected
             *
             *
             * public IActionResult Delete(inputType id)
             * {
             *  //TODO: Implement Realistic Implementation
             *  return Ok();
             * }
             */

            var invalidRequestMessage = "validDateTime is not a date or time";

            _mockProviderService.Given("There is data")
            .UponReceiving("A invalid Get request for Date Validation with invalid data")
            .With(new ProviderServiceRequest
            {
                Method = HttpVerb.Get,
                Path   = "/api/provider",
                Query  = "validDateTime=lolz"
            })
            .WillRespondWith(new ProviderServiceResponse
            {
                Status  = 400,
                Headers = new Dictionary <string, object>
                {
                    { "Content-type", "application/json; charset=utf-8" }
                },
                Body = new
                {
                    message = invalidRequestMessage
                }
            });

            var result         = ConsumerApiClient.ValidateDateTimeUsingProviderApi("lolz", _mockProviderServiceBaseUri).GetAwaiter().GetResult();
            var resultBodyText = result.Content.ReadAsStringAsync().GetAwaiter().GetResult();

            Assert.Contains(invalidRequestMessage, resultBodyText);
        }
Esempio n. 22
0
        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();
        }
Esempio n. 25
0
        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
        }
Esempio n. 26
0
        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();
        }
Esempio n. 27
0
        public async void GivenUserIsNotAMember_WhenGetMembershipInvoked_ThenReturnsFalse()
        {
            _mockProviderService.Given("The userId1 is not a member")
                .UponReceiving("A GET request with userId1")
                .With(new ProviderServiceRequest
                {
                    Method = HttpVerb.Get,
                    Path = "/users/userId1/memberships"
                })
                .WillRespondWith(new ProviderServiceResponse
                {
                    Status = 404
                });

            var request = new HttpRequestMessage(new HttpMethod("GET"), "/users/userId1/memberships/fellow");

            var response = await Client.SendAsync(request);

            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            var content = await response.Content.ReadAsStringAsync();
            Assert.Equal("{\"member\":false}", content);
        }
        public async Task Consumer_Gets_Three_Cars_From_Cars_Api()
        {
            _mockProviderService
            .Given("There are 3 cars")
            .UponReceiving("A GET request to retrieve car dtos")
            .With(new ProviderServiceRequest
            {
                Method = HttpVerb.Get,
                Path   = "/api/cars"
            })
            .WillRespondWith(new ProviderServiceResponse {
                Status  = 200,
                Headers = new Dictionary <string, object>
                {
                    { "Content-Type", "application/json; charset=utf-8" }
                },
                Body = new List <CarDto>
                {
                    new CarDto
                    {
                        Id    = 1,
                        Brand = "Volkswagen",
                        Model = "Golf",
                        Color = "Black"
                    },
                    new CarDto
                    {
                        Id    = 2,
                        Brand = "Mercedes-Benz",
                        Model = "A200",
                        Color = "Grey"
                    },
                    new CarDto
                    {
                        Id    = 3,
                        Brand = "Audi",
                        Model = "Q5",
                        Color = "Black"
                    }
                }
            });

            var httpClient = new HttpClient();
            var response   = await httpClient.GetAsync($"{_mockProviderServiceBaseUri}/api/cars");

            var json = await response.Content.ReadAsStringAsync();

            var cars = JsonConvert.DeserializeObject <List <CarDto> >(json);

            Assert.Equal(cars.Count, 3);
        }
Esempio n. 29
0
        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);
        }
Esempio n. 31
0
        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();
        }
Esempio n. 32
0
        public void GetAllEvents_WithNoAuthorizationToken_ShouldFail()
        {
            ContextInfo.SetTestContextName(GetType().Name);

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