private Mock <IResourceGraph> CreateMockResourceGraph(string resourceName, bool includeRelationship = false)
{
var mockGraph = new Mock <IResourceGraph>();
var resourceContext = new ResourceContext
{
PublicName = resourceName,
IdentityType = typeof(string)
};
ISetupSequentialResult <ResourceContext> seq = mockGraph.SetupSequence(resourceGraph => resourceGraph.GetResourceContext(It.IsAny <Type>()))
.Returns(resourceContext);
if (includeRelationship)
{
var relResourceContext = new ResourceContext
{
PublicName = "todoItems",
IdentityType = typeof(string)
};
seq.Returns(relResourceContext);
}
return(mockGraph);
}
/// <summary>
/// Return a sequence of tasks, once per call.
/// </summary>
public static ISetupSequentialResult <ValueTask <TResult> > ReturnsAsync <TResult>(
this ISetupSequentialResult <ValueTask <TResult> > setup,
Func <TResult> valueFunction
)
{
return(setup.Returns(() => new ValueTask <TResult>(valueFunction())));
}
private Mock <IClient> CreateClient(List <Helper.Maybe <ForecastResponse> > responses = null)
{
var client = new Mock <IClient>();
if (responses is null)
{
client.Setup(cli => cli.GetForecastAsync(It.IsAny <string>()))
.Returns(() => Task.FromResult(new Helper.Maybe <ForecastResponse>()));
return(client);
}
var setup = client.SetupSequence(cli => cli.GetForecastAsync(It.IsAny <string>()));
ISetupSequentialResult <Task <Helper.Maybe <ForecastResponse> > > flow = null;
foreach (var response in responses)
{
if (flow is null)
{
flow = setup.Returns(() => Task.FromResult(response));
}
else
{
flow = flow.Returns(() => Task.FromResult(response));
}
}
return(client);
}
public void ReturnOrThrow(ISetupSequentialResult<byte[]> setup)
{
if (_exception != null)
setup.Throws(_exception);
else
setup.Returns(_response);
}
/// <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>
/// Throws a sequence of exceptions, once per call.
/// </summary>
public static ISetupSequentialResult <Task <TResult> > ThrowsAsync <TResult>(this ISetupSequentialResult <Task <TResult> > setup, Exception exception)
{
var tcs = new TaskCompletionSource <TResult>();
tcs.SetException(exception);
return(setup.Returns(tcs.Task));
}
public static ISetupSequentialResult <Task <T> > ReturnsAsync <T>(this ISetupSequentialResult <Task <T> > setup, T value)
{
var tcs = new TaskCompletionSource <T>();
tcs.SetResult(value);
return(setup.Returns(tcs.Task));
}
/// <summary>
/// Throws a sequence of exceptions, once per call.
/// </summary>
public static ISetupSequentialResult <Task> ThrowsAsync(this ISetupSequentialResult <Task> setup, Exception exception)
{
return(setup.Returns(() =>
{
var tcs = new TaskCompletionSource <object>();
tcs.SetException(exception);
return tcs.Task;
}));
}
public static ISetupSequentialResult <T> ReturnsSequence <T>(this ISetupSequentialResult <T> setup, IEnumerable <T> results)
{
foreach (var item in results)
{
setup.Returns(item);
}
return(setup);
}
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 void SetupAppGeneratorWithApps(App[] apps)
{
ISetupSequentialResult <App> sequenceSetup = _repositoryToAppGeneratorServiceMock.SetupSequence(appGenerator => appGenerator.GenerateApp(It.IsAny <IGitHubRepositoryDataProvider>()));
foreach (App app in apps)
{
sequenceSetup.Returns(app);
}
}
public ZMachineFeatureTester Execute(string command, string outputContains = "")
{
_commandStrings.Add(command);
_outputStrings.Add(outputContains);
_inputSequence.Returns(HandleNextInputOutputPass);
return(this);
}
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
}));
}
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 ReturnOrThrow(ISetupSequentialResult <byte[]> setup)
{
if (_exception != null)
{
setup.Throws(_exception);
}
else
{
setup.Returns(_response);
}
}
/// <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));
}
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);
}
}
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
}));
}
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
});
}
}
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);
}
}
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>
/// Return a sequence of tasks, once per call.
/// </summary>
public static ISetupSequentialResult <ValueTask> PassAsync(
this ISetupSequentialResult <ValueTask> setup
)
{
return(setup.Returns(() => new ValueTask()));
}
/// <summary>
/// Return a sequence of tasks, once per call.
/// </summary>
public static ISetupSequentialResult <Task> PassAsync(
this ISetupSequentialResult <Task> setup
)
{
return(setup.Returns(() => Task.FromResult(0)));
}
