Esempio n. 1
0
        public async Task FlattenAsync(PagedResource pagedResource, int pageSize)
        {
            var server  = new FakeServer(pagedResource);
            var request = new PageStreamingRequest {
                PageSize = pageSize
            };
            var paged = server.PagedAsync(null, null, request);

            Assert.Equal(pagedResource.All, await paged.ToArray());
        }
Esempio n. 2
0
        public void Flatten(PagedResource pagedResource, int pageSize)
        {
            var server  = new FakeServer(pagedResource);
            var request = new PageStreamingRequest {
                PageSize = pageSize
            };
            var paged = server.PagedSync(null, null, request);

            Assert.Equal(pagedResource.All, paged);
        }
Esempio n. 3
0
        public async Task NaturalPagesAsync(PagedResource pagedResource)
        {
            var server  = new FakeServer(pagedResource);
            var request = new PageStreamingRequest {
                PageSize = 0
            };
            var paged = server.PagedAsync(null, null, request);

            Assert.Equal(pagedResource.Resource, await paged.AsRawResponses().Select(x => x.ToArray()).ToArray());
        }
Esempio n. 4
0
        public void NaturalPages(PagedResource pagedResource)
        {
            var server  = new FakeServer(pagedResource);
            var request = new PageStreamingRequest(server)
            {
                PageSize = 0
            };
            var paged = server.PagedSync(request);

            Assert.Equal(pagedResource.Resource, paged.AsRawResponses().Select(x => x.Items.ToArray()).ToArray());
        }
Esempio n. 5
0
        public async Task NoDataAsync()
        {
            var noDataResource = new PagedResource();
            var server         = new FakeServer(noDataResource);
            var request        = new PageStreamingRequest {
                PageSize = 0
            };
            var paged = server.PagedAsync(null, null, request);

            // Natural pages
            Assert.Equal(1, await paged.AsRawResponses().Count());
            var page1 = await paged.AsRawResponses().First();

            Assert.Empty(page1);
            Assert.Equal("", page1.NextPageToken);
            // Unnatural things
            Assert.Empty(await paged.ToArray());
            Assert.Empty(await paged.ReadPageAsync(1));
        }
Esempio n. 6
0
        public void NoData()
        {
            var noDataResource = new PagedResource();
            var server         = new FakeServer(noDataResource);
            var request        = new PageStreamingRequest {
                PageSize = 0
            };
            var paged = server.PagedSync(null, null, request);

            // Natural pages
            Assert.Equal(1, paged.AsRawResponses().Count());
            var page1 = paged.AsRawResponses().First();

            Assert.Empty(page1);
            Assert.Equal("", page1.NextPageToken);
            // Unnatural things
            Assert.Empty(paged);
            Assert.Empty(paged.ReadPage(1));
        }
Esempio n. 7
0
        public async Task ReadPageAsync(PagedResource pagedResource, int pageSize)
        {
            var    server      = new FakeServer(pagedResource);
            string pageToken   = "";
            var    actualPages = new List <Page <int> >();

            do
            {
                var request = new PageStreamingRequest {
                    PageSize = pageSize, PageToken = pageToken
                };
                var paged = server.PagedAsync(null, null, request);
                actualPages.Add(await paged.ReadPageAsync(pageSize));
            } while ((pageToken = actualPages.Last().NextPageToken) != "");
            var expectedPages = pagedResource.Fixed(pageSize);

            // Ignore trailing empty pages; we could change the fake server to avoid returning a page
            // token when we've reached (but not gone past) the end.
            Assert.Equal(expectedPages, actualPages.TakeWhile(p => p.Any()).Select(p => p.ToArray()).ToArray());
        }
            public async Task ShouldReturnCorrectlyFormattedResults()
            {
                // Arrange
                var viagogoService  = new Mock <IViagogoClient>();
                var serviceResponse = new PagedResource <SearchResult>
                {
                    TotalItems = 20,
                    Items      = new List <SearchResult>
                    {
                        new SearchResult
                        {
                            CategoryLink = new Link
                            {
                                HRef = "https://api.viagogo.net/v2/categories/20746"
                            },
                            Title = "Beyonce"
                        }
                    }
                };

                viagogoService
                .Setup(client => client.Search.GetAsync("Bey", It.IsAny <SearchResultRequest>()))
                .ReturnsAsync(serviceResponse);

                var expected = serviceResponse
                               .Items
                               .Select(TicketsSuggestion.FromSearchResult)
                               .ToArray();

                var controller = new SearchController(viagogoService.Object);

                // Act
                var result = await controller.GetAsync("Bey");

                // Assert
                Assert.IsInstanceOfType(result, typeof(JsonResult));

                var actual = (TicketsSuggestion[])((JsonResult)result).Value;

                CollectionAssert.AreEqual(expected, actual);
            }
Esempio n. 9
0
 internal FakeServer(PagedResource pagedResource, int brokenBy = 0)
 {
     _pagedItems = pagedResource.Resource;
     _brokenBy   = brokenBy;
 }