internal GrpcPagedEnumerable <PageStreamingRequest, PageStreamingResponse, int> PagedSync(
CallSettings baseCallSettings, CallSettings perCallCallSettings, PageStreamingRequest request)
{
var apiCall = new ApiCall <PageStreamingRequest, PageStreamingResponse>(
MethodAsync, MethodSync, baseCallSettings);
return(new GrpcPagedEnumerable <PageStreamingRequest, PageStreamingResponse, int>(
apiCall, request, perCallCallSettings));
}
public async Task BrokenServerFixedSizePagedAsync()
{
var server = new FakeServer(s_resourceA, 1);
var request = new PageStreamingRequest {
PageSize = 0
};
var paged = server.PagedAsync(null, null, request);
await Assert.ThrowsAsync <NotSupportedException>(() => paged.ReadPageAsync(1));
}
public void BrokenServerFixedSizePaged()
{
var server = new FakeServer(s_resourceA, 1);
var request = new PageStreamingRequest {
PageSize = 0
};
var paged = server.PagedSync(null, null, request);
Assert.Throws <NotSupportedException>(() => paged.ReadPage(1));
}
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());
}
public async Task SpecifyPageTokenAtStartAsync()
{
var server = new FakeServer(s_resourceA, 1);
var request = new PageStreamingRequest {
PageSize = 0, PageToken = "1:0"
};
var paged = server.PagedAsync(null, null, request);
Assert.Equal(s_resourceA.Resource.Skip(1), await paged.AsRawResponses().Select(x => x.ToArray()).ToArray());
}
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);
}
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());
}
public void SpecifyPageTokenAtStart()
{
var server = new FakeServer(s_resourceA, 1);
var request = new PageStreamingRequest(server)
{
PageSize = 0, PageToken = "1:0"
};
var paged = server.PagedSync(request);
Assert.Equal(s_resourceA.Resource.Skip(1), paged.AsRawResponses().Select(x => x.Items.ToArray()));
}
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());
}
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));
}
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));
}
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());
}
internal PageStreamingResponse MethodSync(
PageStreamingRequest request, CallSettings callSettings)
{
int page = 0;
int pageOffset = 0;
if (request.PageToken != "")
{
var pageToken = request.PageToken.Split(':').Select(i => int.Parse(i)).ToArray();
page = pageToken[0];
pageOffset = pageToken[1];
}
var pageItems = _pagedItems.Skip(page).FirstOrDefault();
if (pageItems == null)
{
return(new PageStreamingResponse
{
Items = { },
NextPageToken = ""
});
}
var items = pageItems.Skip(pageOffset).ToArray();
int itemCount = request.PageSize == 0 ?
items.Length : Math.Min(items.Length, request.PageSize + _brokenBy);
int nextPage = page;
int nextPageOffset = pageOffset + itemCount;
if (nextPageOffset >= pageItems.Length)
{
nextPage += 1;
nextPageOffset = 0;
}
return(new PageStreamingResponse
{
Items = { items.Take(itemCount) },
NextPageToken = nextPage >= _pagedItems.Count() ? "" : $"{nextPage}:{nextPageOffset}"
});
}
// We can't just return request each time, as otherwise if a PagedEnumerable is used twice,
// we'll end up reusing the page token.
private Func <PageStreamingRequest> CreateRequestProvider(PageStreamingRequest request)
=> () => new PageStreamingRequest(request.Server)
{
PageToken = request.PageToken, PageSize = request.PageSize
};
internal Task <PageStreamingResponse> MethodAsync(PageStreamingRequest request) => Task.FromResult(MethodSync(request));
internal RestPagedEnumerable <PageStreamingRequest, PageStreamingResponse, int> PagedSync(PageStreamingRequest request) => new RestPagedEnumerable <PageStreamingRequest, PageStreamingResponse, int>(CreateRequestProvider(request), new PageManager());
internal Task <PageStreamingResponse> MethodAsync(
PageStreamingRequest request, CallSettings callSettings) =>
Task.FromResult(MethodSync(request, callSettings));
