Esempio n. 1
0
        public void should_post_to_boas_api()
        {
            InstrumentServer();

            SendMessage();

            Assert.That(() => _server.FindLogEntries(Request.Create().UsingPost()).Count() == 1, constraint);
        }
        public async Task should_post_to_boas_api()
        {
            InstrumentServer();

            var sut = new DisciplineSelectedHandler();
            await sut.Handles(string.Empty, _message);

            Assert.AreEqual(1, _server.FindLogEntries(Request.Create().UsingPost()).Count());
        }
        public void ItDefaultsToGetForShortQueries()
        {
            RegisterSelectQueryGetHandler();
            var endpoint = GetQueryEndpoint();
            var results  = endpoint.QueryWithResultSet("SELECT * WHERE {?s ?p ?o}");

            results.Should().NotBeNull().And.HaveCount(1);
            var sparqlLogEntries = _server.FindLogEntries(new RequestMessagePathMatcher(MatchBehaviour.AcceptOnMatch, "/sparql")).ToList();

            sparqlLogEntries.Should().HaveCount(1);
            sparqlLogEntries[0].RequestMessage.Method.Should().BeEquivalentTo("get");
        }
Esempio n. 4
0
        public async void AddReservationTest()
        {
            // Arrange
            var trainerId             = (await context.Reservations.FirstOrDefaultAsync()).TrainerId;
            var classId               = 3;
            var beginningReservations = await context.Reservations.Where(x => x.TrainerId == trainerId).ToListAsync();

            var addReservationRequest = new AddReservationRequest()
            {
                trainerId = trainerId,
                ClassId   = classId
            };
            var requestBodyContent = new StringContent(
                JsonConvert.SerializeObject(addReservationRequest),
                Encoding.UTF8,
                "application/json"
                );

            fluentMockServer
            .Given(
                Request.Create().WithPath($"/trainers/{trainerId}").UsingGet()
                )
            .RespondWith(
                Response.Create()
                .WithStatusCode(200)
                .WithHeader("Content-Type", "application/json")
                .WithBody("[\"Joto\", \"Indigo\"]")
                );

            // Act
            var response = await client.PostAsync(RouteConstants.RESERVATIONS_ROUTE, requestBodyContent);

            // Assert
            Assert.Equal(StatusCodes.Status204NoContent, (int)response.StatusCode);

            var updatedReservations = await context.Reservations.Where(x => x.TrainerId == trainerId).ToListAsync();

            Assert.Equal(beginningReservations.Count + 1, updatedReservations.Count);

            var newReservation = await context.Reservations.Where(x => x.TrainerId == trainerId && x.ClassId == classId).ToListAsync();

            Assert.Single(newReservation);

            Assert.Single(fluentMockServer.FindLogEntries(Request.Create().WithPath($"/trainers/{trainerId}").UsingGet()));
            Assert.Single(fluentMockServer.LogEntries);
        }
        public async Task FluentMockServer_Should_find_a_request_satisfying_a_request_spec()
        {
            // given
            _server = FluentMockServer.Start();

            // when
            await new HttpClient().GetAsync("http://localhost:" + _server.Ports[0] + "/foo");
            await new HttpClient().GetAsync("http://localhost:" + _server.Ports[0] + "/bar");

            // then
            var result = _server.FindLogEntries(Request.Create().WithPath(new RegexMatcher("^/b.*"))).ToList();

            Check.That(result).HasSize(1);

            var requestLogged = result.First();

            Check.That(requestLogged.RequestMessage.Path).IsEqualTo("/bar");
            Check.That(requestLogged.RequestMessage.Url).IsEqualTo("http://localhost:" + _server.Ports[0] + "/bar");
        }