public void ReturnOrThrow(ISetupSequentialResult<byte[]> setup)
{
if (_exception != null)
setup.Throws(_exception);
else
setup.Returns(_response);
}
/// <summary>
/// Throws a sequence of exceptions, once per call.
/// </summary>
public static ISetupSequentialResult <ValueTask> ThrowsAsync(this ISetupSequentialResult <ValueTask> setup, Exception exception)
{
return(setup.Returns(() =>
{
var tcs = new TaskCompletionSource <object>();
tcs.SetException(exception);
return new ValueTask(tcs.Task);
}));
}
public static ISetupSequentialResult <Task <T> > ReturnsIndefinitely <T>(this ISetupSequentialResult <Task <T> > setup, Func <Task <T> > valueFunction)
{
for (var i = 0; i < 100; i++)
{
setup.Returns(valueFunction);
}
return(setup);
}
private ISetupSequentialResult <Task <HttpResponseMessage> > AdddReturnPart(ISetupSequentialResult <Task <HttpResponseMessage> > handlerPart,
HttpStatusCode statusCode, HttpContent content)
{
return(handlerPart.ReturnsAsync(new HttpResponseMessage()
{
StatusCode = statusCode,
Content = content
}));
}
/// <summary>
/// Throws a sequence of exceptions, once per call.
/// </summary>
public static ISetupSequentialResult <Task <TResult> > ThrowsAsync <TResult>(this ISetupSequentialResult <Task <TResult> > setup, Exception exception)
{
return(setup.Returns(() =>
{
var tcs = new TaskCompletionSource <TResult>();
tcs.SetException(exception);
return tcs.Task;
}));
}
public static ISetupSequentialResult <Task <T> > ReturnsSequenceAsync <T>(this ISetupSequentialResult <Task <T> > setup, IEnumerable <T> results)
{
foreach (var item in results)
{
setup.ReturnsAsync(item);
}
return(setup);
}
private void SetupAppGeneratorWithApps(App[] apps)
{
ISetupSequentialResult <App> sequenceSetup = _repositoryToAppGeneratorServiceMock.SetupSequence(appGenerator => appGenerator.GenerateApp(It.IsAny <IGitHubRepositoryDataProvider>()));
foreach (App app in apps)
{
sequenceSetup.Returns(app);
}
}
public void ReturnOrThrow(ISetupSequentialResult <byte[]> setup)
{
if (_exception != null)
{
setup.Throws(_exception);
}
else
{
setup.Returns(_response);
}
}
private static ISetupSequentialResult <TResult> SetupFailures <TResult>(this ISetupSequentialResult <TResult> setup, int failures, StatusCode statusCode, string exceptionMessage, TimeSpan?exceptionRetryDelay)
{
var exception = BuildRpcException(exceptionRetryDelay, statusCode, exceptionMessage);
for (int i = 0; i < failures; i++)
{
setup = setup.Throws(exception);
}
return(setup);
}
/// <summary>
/// Specifies the response to return in sequence, as <see cref="ByteArrayContent" />.
/// </summary>
/// <param name="setup">The setup.</param>
/// <param name="statusCode">The status code.</param>
/// <param name="content">The response body.</param>
/// <param name="mediaType">The media type.</param>
/// <param name="configure">An action to further configure the response such as setting headers.</param>
/// <exception cref="ArgumentNullException"><paramref name="content" /> is null.</exception>
public static ISetupSequentialResult <Task <HttpResponseMessage> > ReturnsResponse(
this ISetupSequentialResult <Task <HttpResponseMessage> > setup,
HttpStatusCode statusCode, byte[] content, string mediaType = null, Action <HttpResponseMessage> configure = null)
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
return(setup.ReturnsAsync(CreateResponse(statusCode, configure, new ByteArrayContent(content), mediaType)));
}
/// <summary>
/// Specifies the response to return in sequence.
/// </summary>
/// <param name="setup">The setup.</param>
/// <param name="statusCode">The status code.</param>
/// <param name="content">The response content.</param>
/// <param name="configure">An action to further configure the response such as setting headers.</param>
/// <exception cref="ArgumentNullException"><paramref name="content" /> is null.</exception>
public static ISetupSequentialResult <Task <HttpResponseMessage> > ReturnsResponse(
this ISetupSequentialResult <Task <HttpResponseMessage> > setup,
HttpStatusCode statusCode, HttpContent content, Action <HttpResponseMessage> configure = null)
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
return(setup.ReturnsAsync(CreateResponse(statusCode, configure, content)));
}
private void AndThePagesOfPublishedProviders(params IEnumerable <PublishedProvider>[] pages)
{
ISetupSequentialResult <Task <IEnumerable <PublishedProvider> > > reads = _cosmosFeed.SetupSequence(_ =>
_.ReadNext(It.IsAny <CancellationToken>()));
ISetupSequentialResult <bool> hasRecords = _cosmosFeed.SetupSequence(_ => _.HasMoreResults);
foreach (IEnumerable <PublishedProvider> page in pages)
{
reads.ReturnsAsync(page);
hasRecords.Returns(true);
}
}
/// <summary>
/// Allows to specify a sequence of exceptions thrown by an asynchronous method, once per call.
/// </summary>
public static ISetupSequentialResult <Task <TResult> > ThrowsAsync <TResult>(this ISetupSequentialResult <Task <TResult> > sequence, Exception exception)
{
if (sequence == null)
{
throw new ArgumentNullException(nameof(sequence));
}
var taskCompletionSource = new TaskCompletionSource <TResult>();
taskCompletionSource.SetException(exception);
return(sequence.Returns(taskCompletionSource.Task));
}
/// <summary>
/// Returns given result in sequence of the setup.
/// </summary>
/// <param name="setup"></param>
/// <param name="resultObject"></param>
/// <typeparam name="TResult"></typeparam>
/// <returns></returns>
public static ISetupSequentialResult <IResult <TResult> > ReturnsGivenSequentialResult <TResult>(
this ISetupSequentialResult <IResult <TResult> > setup,
TResult resultObject = default(TResult)
)
{
return(setup
.Returns(new Result <TResult>
{
Errors = new List <IError>(),
ResultObject = resultObject
}));
}
private static void SetupBlobMock(ISetupSequentialResult <Task <Response <BlobProperties> > > mock, int?offset, int?sequencenumber)
{
var metadata = new Dictionary <string, string>();
if (offset != null)
{
metadata.Add("offset", offset.ToString());
}
if (sequencenumber != null)
{
metadata.Add("sequencenumber", sequencenumber.ToString());
}
var response = Response.FromValue(BlobsModelFactory.BlobProperties(default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, default, metadata, default, default, default, default), Mock.Of <Response>());
/// <summary>
/// Returns basic error sequential result.
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <returns></returns>
public static ISetupSequentialResult <IResult <TResult> > ReturnsBasicErrorSequentialResult <TResult>(
this ISetupSequentialResult <IResult <TResult> > setup,
TResult resultObject = default(TResult)
)
{
return(setup
.Returns(new Result <TResult>
{
Errors = new List <IError>
{
ErrorConstants.BasicError
},
ResultObject = resultObject
}));
}
public static ISetupSequentialResult <Task <ExecuteResult> > SetupExecution(this ISetupSequentialResult <Task <ExecuteResult> > current)
{
return(current.ReturnsAsync(new ExecuteResult {
RowsModified = 1, Succeeded = true
})
.ReturnsAsync(new ExecuteResult {
RowsModified = 2, Succeeded = true
})
.ReturnsAsync(new ExecuteResult {
RowsModified = 0, Succeeded = true
})
.ReturnsAsync(new ExecuteResult {
Succeeded = false
}));;
}
public ZMachineFeatureTester(Mock <IUserIo> zMachineIo)
{
_inputSequence = zMachineIo
.SetupSequence(io => io.Read(It.IsAny <int>(), It.IsAny <IZMemory>()));
zMachineIo.Setup(m => m.Print(It.IsAny <string>()))
.Callback <string>(s =>
{
_outputBetweenCommands.Append(s);
});
_outputStrings = new List <string>();
_commandStrings = new List <string>();
_outputBetweenCommands = new StringBuilder();
}
public void MockRequest(
string url,
HttpMethod method,
Action <ISetupSequentialResult <Task <HttpResponseMessage> > > setupReturns)
{
ISetupSequentialResult <Task <HttpResponseMessage> > setupSequence =
handlerMock.Protected()
.SetupSequence <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.Is <HttpRequestMessage>(httpRequest =>
httpRequest.Method == method &&
httpRequest.RequestUri.ToString().Equals(url)),
ItExpr.IsAny <CancellationToken>());
setupReturns(setupSequence);
}
public static ISetupSequentialResult <IResult <IQueryable <T> > > ReturnsGivenSequentialResult <T>(
this ISetupSequentialResult <IResult <IQueryable <T> > > setupSequence,
bool success,
IEnumerable <T> entityCollection
) where T : Entity
{
return(setupSequence.Returns(new Result <IQueryable <T> >
{
Errors = success ? null : new List <IError> {
new Error {
Key = "ERROR_KEY"
}
},
ResultObject = success ? entityCollection.AsQueryable() : null
}));
}
/// <summary>
/// Specifies the response to return in sequence, as <see cref="StreamContent" /> with <see
/// cref="HttpStatusCode.OK" />. If the stream is seekable, it will be wrapped to allow for reuse across
/// multiple requests (each request maintains an independent stream position).
/// </summary>
/// <param name="setup">The setup.</param>
/// <param name="content">The response body.</param>
/// <param name="mediaType">The media type.</param>
/// <param name="configure">An action to further configure the response such as setting headers.</param>
/// <exception cref="ArgumentNullException"><paramref name="content" /> is null.</exception>
public static ISetupSequentialResult <Task <HttpResponseMessage> > ReturnsResponse(
this ISetupSequentialResult <Task <HttpResponseMessage> > setup,
Stream content,
string mediaType = null,
Action <HttpResponseMessage> configure = null)
{
if (content is null)
{
throw new ArgumentNullException(nameof(content));
}
return(setup.ReturnsAsync(CreateResponse(
content: CreateStreamContent(content),
mediaType: mediaType,
configure: configure)));
}
private void GivenThePagesOfUkprns(string blobName,
params string[][] pages)
{
_batchUploadReader.Setup(_ => _.LoadBatchUpload(blobName))
.Returns(Task.CompletedTask)
.Verifiable();
ISetupSequentialResult <IEnumerable <string> > pageSequence = _batchUploadReader.SetupSequence(_ => _.NextPage());
ISetupSequentialResult <bool> hasPagesSequence = _batchUploadReader.SetupSequence(_ => _.HasPages);
foreach (string[] page in pages)
{
pageSequence = pageSequence.Returns(page);
hasPagesSequence = hasPagesSequence.Returns(true);
}
}
private void GivenThePagesOfRequests(params BatchProfilingRequestModel[] requests)
{
ISetupSequentialResult <bool> hasPages = _context
.SetupSequence(_ => _.HasPages);
ISetupSequentialResult <BatchProfilingRequestModel[]> nextPage = _context
.SetupSequence(_ => _.NextPage());
foreach (BatchProfilingRequestModel request in requests)
{
hasPages = hasPages.Returns(true);
nextPage = nextPage.Returns(new[]
{
request
});
}
}
/// <summary>
/// Specifies the response to return in sequence, as <see cref="StringContent" />.
/// </summary>
/// <param name="setup">The setup.</param>
/// <param name="statusCode">The status code.</param>
/// <param name="content">The response body.</param>
/// <param name="mediaType">The media type. Defaults to text/plain.</param>
/// <param name="encoding">The character encoding. Defaults to <see cref="Encoding.UTF8" />.</param>
/// <param name="configure">An action to further configure the response such as setting headers.</param>
/// <exception cref="ArgumentNullException"><paramref name="content" /> is null.</exception>
public static ISetupSequentialResult <Task <HttpResponseMessage> > ReturnsResponse(
this ISetupSequentialResult <Task <HttpResponseMessage> > setup,
HttpStatusCode statusCode,
string content,
string mediaType = null,
Encoding encoding = null,
Action <HttpResponseMessage> configure = null)
{
if (content is null)
{
throw new ArgumentNullException(nameof(content));
}
return(setup.ReturnsAsync(CreateResponse(
statusCode: statusCode,
content: new StringContent(content, encoding, mediaType),
configure: configure)));
}
protected ICosmosDbFeedIterator <TDocument> NewFeedIterator <TDocument>(params IEnumerable <TDocument>[] pages)
where TDocument : IIdentifiable
{
Mock <ICosmosDbFeedIterator <TDocument> > feedIterator = new Mock <ICosmosDbFeedIterator <TDocument> >();
ISetupSequentialResult <bool> hasResultsSequence = feedIterator.SetupSequence(_ => _.HasMoreResults);
ISetupSequentialResult <Task <IEnumerable <TDocument> > > pagesSequence = feedIterator.SetupSequence(_ =>
_.ReadNext(It.IsAny <CancellationToken>()));
foreach (IEnumerable <TDocument> page in pages)
{
hasResultsSequence.Returns(true);
pagesSequence.ReturnsAsync(page);
}
hasResultsSequence.Returns(false);
return(feedIterator.Object);
}
public void Setup()
{
var configurationsVariables = new Dictionary <string, string>
{
{ "HttpUserAgent", "API Client" },
{ "TopStoriesNumber", "1" },
{ "HackerNewsAPI:BestStoriesUrl", "http://127.0.0.1/" },
{ "HackerNewsAPI:ItemDetailUrl", "http://127.0.0.1/" }
};
_configuration = new ConfigurationBuilder()
.AddInMemoryCollection(configurationsVariables)
.Build();
_mockFactory = new Mock <IHttpClientFactory>();
_mockHttpMessageHandler = new Mock <HttpMessageHandler>();
_sequentialSetup = _mockHttpMessageHandler.Protected()
.SetupSequence <Task <HttpResponseMessage> >("SendAsync",
ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>());
_mockLogger = new Mock <ILogger <HackerNewsApiRepository> >();
}
public void MockRequest(
string url,
HttpMethod method,
params HttpResponseMessage[] httpResponses)
{
if (httpResponses.Length == 0)
{
throw new ArgumentException("At least one HTTP response must be provided.");
}
ISetupSequentialResult <Task <HttpResponseMessage> > setupSequence =
handlerMock.Protected()
.SetupSequence <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.Is <HttpRequestMessage>(httpRequest =>
httpRequest.Method == method &&
httpRequest.RequestUri.ToString().Equals(url)),
ItExpr.IsAny <CancellationToken>());
foreach (var httpResponse in httpResponses)
{
setupSequence.ReturnsAsync(httpResponse);
}
}
/// <summary>
/// Return a sequence of tasks, once per call.
/// </summary>
public static ISetupSequentialResult <Task <TResult> > ReturnsAsync <TResult>(this ISetupSequentialResult <Task <TResult> > setup, TResult value)
{
return(setup.Returns(() => Task.FromResult(value)));
}
/// <summary>
/// Specifies the response to return in sequence.
/// </summary>
/// <param name="setup">The setup.</param>
/// <param name="statusCode">The status code.</param>
/// <param name="configure">An action to further configure the response such as setting headers.</param>
public static ISetupSequentialResult <Task <HttpResponseMessage> > ReturnsResponse(
this ISetupSequentialResult <Task <HttpResponseMessage> > setup,
HttpStatusCode statusCode, Action <HttpResponseMessage> configure = null)
=> setup.ReturnsAsync(CreateResponse(statusCode, configure));
/// <summary>
/// Specifies the response to return in sequence, as <see cref="StreamContent" /> with <see cref="HttpStatusCode.OK" />.
/// </summary>
/// <param name="setup">The setup.</param>
/// <param name="content">The response body.</param>
/// <param name="mediaType">The media type.</param>
/// <param name="configure">An action to further configure the response such as setting headers.</param>
/// <exception cref="ArgumentNullException"><paramref name="content" /> is null.</exception>
public static ISetupSequentialResult <Task <HttpResponseMessage> > ReturnsResponse(
this ISetupSequentialResult <Task <HttpResponseMessage> > setup,
Stream content, string mediaType = null, Action <HttpResponseMessage> configure = null)
=> setup.ReturnsResponse(HttpStatusCode.OK, content, mediaType, configure);
/// <summary>
/// Return a sequence of tasks, once per call.
/// </summary>
public static ISetupSequentialResult <ValueTask <TResult> > ReturnsAsync <TResult>(this ISetupSequentialResult <ValueTask <TResult> > setup, TResult value)
{
return(setup.Returns(() => new ValueTask <TResult>(value)));
}
