public async Task ItShouldProcessAllTasksSuccessfully()
{
var taskA = new Mock <IPipelineTask>();
taskA.Setup(x => x.Process(It.IsAny <IPipelineContext>())).ReturnsAsync(PipelineProcessingResult.Success());
var taskB = new Mock <IPipelineTask>();
taskB.Setup(x => x.Process(It.IsAny <IPipelineContext>())).ReturnsAsync(PipelineProcessingResult.Success());
var pipelineContext = Mock.Of <IPipelineContext>();
var pipelineAnnouncer = new Mock <IPipelineAnnouncer>();
var pipeline = new TaskPipeline(pipelineContext, pipelineAnnouncer.Object, taskA.Object, taskB.Object);
var result = await pipeline.Process();
Assert.True(result);
// Ensure both tasks have been run
taskA.Verify(x => x.Process(It.IsAny <IPipelineContext>()));
taskB.Verify(x => x.Process(It.IsAny <IPipelineContext>()));
// Ensure no announcements are made for succeeding tasks
pipelineAnnouncer.Verify(x => x.Announce(It.IsAny <IPipelineContext>(), It.IsAny <string>()), Times.Never());
}
public Task <PipelineProcessingResult> Process(IPipelineContext context)
{
var localImagePath = context.Data["ImageLocalPath"] as string;
if (string.IsNullOrEmpty(localImagePath))
{
return(Task.FromResult(PipelineProcessingResult.Failure("Unable to find local copy of merchant image.")));
}
var compressedImagePath = Path.GetTempFileName();
using (var image = Image.Load(localImagePath)) {
image.Mutate(x => x.Resize(TargetWidth, TargetHeight));
var encoder = new PngEncoder();
encoder.CompressionLevel = 9; // Max compression!
using (var compressedImageStream = new FileStream(compressedImagePath, FileMode.Create)) {
image.SaveAsPng(compressedImageStream, encoder);
}
}
context.Data.Add("CompressedImagePath", compressedImagePath);
return(Task.FromResult(PipelineProcessingResult.Success()));
}
public void ItShouldCreateASuccessfulProcessingResult()
{
var result = PipelineProcessingResult.Success();
Assert.True(result.IsSuccess);
Assert.Null(result.Details);
}
public void ItShouldCreateAFailingProcessingResult()
{
var details = "There was an error";
var result = PipelineProcessingResult.Failure(details);
Assert.False(result.IsSuccess);
Assert.Equal(details, result.Details);
}
public async Task <PipelineProcessingResult> Process(IPipelineContext context)
{
await MutateToSecureUrl(context.MerchantDetails);
MutateFacebookLink(context.MerchantDetails);
MutateTwitterLink(context.MerchantDetails);
return(PipelineProcessingResult.Success());
}
public Task <PipelineProcessingResult> Process(IPipelineContext context)
{
if (context.MerchantDetails.ShouldStopExecuting)
{
return(Task.FromResult(PipelineProcessingResult.SoftExit()));
}
return(Task.FromResult(PipelineProcessingResult.Success()));
}
public async Task <PipelineProcessingResult> Process(IPipelineContext context)
{
var branchName = $"issue-{context.TaskIdentifier}";
await context.RepositoryContext.CreateBranch(branchName);
await context.RepositoryContext.Checkout(branchName);
return(PipelineProcessingResult.Success());
}
public async Task <PipelineProcessingResult> Process(IPipelineContext context)
{
var branchName = $"issue-{context.TaskIdentifier}";
var title = $"[Bot] Closes #{context.TaskIdentifier}";
var body = "*This pull request was generated automatically.*";
await gitHubService.CreatePullRequest(title, branchName, "master", body);
return(PipelineProcessingResult.Success());
}
public async Task <PipelineProcessingResult> Process(IPipelineContext context)
{
var branchName = $"issue-{context.TaskIdentifier}";
await context.RepositoryContext.StageChanges();
await context.RepositoryContext.Commit($"closes #{context.TaskIdentifier}");
await context.RepositoryContext.Push(branchName);
return(PipelineProcessingResult.Success());
}
public async Task <PipelineProcessingResult> Process(IPipelineContext context)
{
var missingFields = new List <string>();
var baseSchemaItem = (((context.Schema as MappingSchemaItem).Mapping["websites"] as SequenceSchemaItem).Items[0] as MappingSchemaItem);
foreach (var kvp in baseSchemaItem.Mapping)
{
switch (kvp.Value)
{
case KeyValueSchemaItem keyValueItem:
if (!context.MerchantDetails.Values.ContainsKey(kvp.Key) || string.IsNullOrEmpty(context.MerchantDetails.Values[kvp.Key].Value))
{
await TryResolveMissingKey(context.MerchantDetails, kvp.Key);
}
// Special exception for the img tag. The bot needs it to run the pipeline.
if (keyValueItem.Required || kvp.Key == "img")
{
if (!context.MerchantDetails.Values.ContainsKey(kvp.Key) || string.IsNullOrEmpty(context.MerchantDetails.Values[kvp.Key].Value))
{
missingFields.Add(kvp.Key);
}
}
break;
}
}
// Check categories
if (!context.MerchantDetails.Values.ContainsKey("category") || !context.RepositoryContext.EnumerateCategories().Contains(context.MerchantDetails.Values["category"].Value, StringComparer.OrdinalIgnoreCase))
{
missingFields.Add("category");
}
if (missingFields.Count == 0)
{
return(PipelineProcessingResult.Success());
}
else
{
var messageBuilder = new StringBuilder();
messageBuilder.AppendLine("The following fields are missing:");
foreach (var field in missingFields)
{
messageBuilder.Append("- ");
messageBuilder.AppendLine(field);
}
return(PipelineProcessingResult.Failure(messageBuilder.ToString()));
}
}
public Task <PipelineProcessingResult> Process(IPipelineContext context)
{
var categoryFileName = $"{context.MerchantDetails.Values["category"].Value.ToLower()}.yml";
var categoryFilePath = Path.Combine(context.RepositoryContext.RepositoryDirectory, "_data", categoryFileName);
var deserializer = new DeserializerBuilder()
.WithNamingConvention(new CamelCaseNamingConvention())
.Build();
Dictionary <string, List <Dictionary <string, object> > > document;
using (var fileStream = new FileStream(categoryFilePath, FileMode.Open)) {
using (var streamReader = new StreamReader(fileStream)) {
document = deserializer.Deserialize <Dictionary <string, List <Dictionary <string, object> > > >(streamReader);
}
}
var websitesCollection = document["websites"];
var merchantEntry = context.MerchantDetails.Export();
var existingEntry = websitesCollection.Where(x => ((string)x["url"]).ToLower().TrimEnd('/') == context.MerchantDetails.Values["url"].Value.ToLower().TrimEnd('/')).FirstOrDefault();
if (existingEntry != null)
{
websitesCollection.Remove(existingEntry);
// Copy fields from the original entry to the new one
// Only copy fields that aren't already on the new one - new fields take priority
foreach (var key in existingEntry.Keys)
{
if (!merchantEntry.ContainsKey(key))
{
merchantEntry.Add(key, existingEntry[key]);
}
}
}
websitesCollection.Add(merchantEntry);
document["websites"] = websitesCollection.OrderBy(x => (string)x["name"], StringComparer.OrdinalIgnoreCase).ToList();
var serializer = new SerializerBuilder()
.Build();
var yml = serializer.Serialize(document);
yml = AddSpacesBetweenListItems(yml);
File.WriteAllText(categoryFilePath, yml);
return(Task.FromResult(PipelineProcessingResult.Success()));
}
public async Task <PipelineProcessingResult> Process(IPipelineContext context)
{
var imageLocalPath = diskService.GetTempFilePath();
try {
await networkService.DownloadFile(context.MerchantDetails.Values["img"].Value, imageLocalPath);
} catch (WebException) {
return(PipelineProcessingResult.Failure($"Unable to download image at `{context.MerchantDetails.Values["img"].Value}`."));
}
context.Data.Add("ImageLocalPath", imageLocalPath);
return(PipelineProcessingResult.Success());
}
public Task <PipelineProcessingResult> Process(IPipelineContext context)
{
var compressedImagePath = context.Data["CompressedImagePath"] as string;
if (string.IsNullOrEmpty(compressedImagePath))
{
return(Task.FromResult(PipelineProcessingResult.Failure("Unable to find local copy of compressed merchant image.")));
}
var targetImageName = context.MerchantDetails.Values["name"].Value.Sanitize();
var targetImagePath = Path.Combine(context.RepositoryContext.RepositoryDirectory, "img", context.MerchantDetails.Values["category"].Value, $"{targetImageName}.png").ToLower();
File.Copy(compressedImagePath, targetImagePath, true);
context.MerchantDetails.PlacedImageName = $"{targetImageName}.png";
return(Task.FromResult(PipelineProcessingResult.Success()));
}
public Task <PipelineProcessingResult> Process(IPipelineContext context)
{
var localImagePath = context.Data["ImageLocalPath"] as string;
if (!string.IsNullOrEmpty(localImagePath))
{
File.Delete(localImagePath);
}
var compressedImagePath = context.Data["CompressedImagePath"] as string;
if (!string.IsNullOrEmpty(compressedImagePath))
{
File.Delete(compressedImagePath);
}
return(Task.FromResult(PipelineProcessingResult.Success()));
}
public async Task ItShouldProcessASoftExitTask()
{
var taskA = new Mock <IPipelineTask>();
taskA.Setup(x => x.Process(It.IsAny <IPipelineContext>())).ReturnsAsync(PipelineProcessingResult.SoftExit());
var pipelineContext = Mock.Of <IPipelineContext>();
var pipelineAnnouncer = new Mock <IPipelineAnnouncer>();
var pipeline = new TaskPipeline(pipelineContext, pipelineAnnouncer.Object, taskA.Object);
var result = await pipeline.Process();
Assert.False(result);
// Ensure the task has been run
taskA.Verify(x => x.Process(It.IsAny <IPipelineContext>()));
// Ensure that an announcement is made upon failure
pipelineAnnouncer.Verify(x => x.Announce(It.IsAny <IPipelineContext>(), It.IsAny <string>()), Times.Never());
}
public async Task ItShouldProcessAFailingTaskAndAnnounce()
{
var failingMessage = "Something went wrong!";
var taskA = new Mock <IPipelineTask>();
taskA.Setup(x => x.Process(It.IsAny <IPipelineContext>())).ReturnsAsync(PipelineProcessingResult.Failure(failingMessage));
var pipelineContext = Mock.Of <IPipelineContext>();
var pipelineAnnouncer = new Mock <IPipelineAnnouncer>();
var pipeline = new TaskPipeline(pipelineContext, pipelineAnnouncer.Object, taskA.Object);
var result = await pipeline.Process();
Assert.False(result);
// Ensure the task has been run
taskA.Verify(x => x.Process(It.IsAny <IPipelineContext>()));
// Ensure that an announcement is made upon failure
pipelineAnnouncer.Verify(x => x.Announce(It.IsAny <IPipelineContext>(), It.Is <string>(y => y == failingMessage)), Times.Once());
}
