public async Task OutputPrefixSuffix(string output)
{
// Arrange
var prefix = $"preprefix-{output.Replace("\\", "-")}-";
var suffix = $"-{output.Replace("\\", "-")}-suffixfix";
// Act
var options = new CombineOptions()
{
Prefix = prefix,
Suffix = suffix,
Output = output,
OverWrite = true,
Input = InputDir
};
var exitCode = await new Combiner(options).Run();
// Assert
Assert.Equal(0, exitCode);
var path = string.IsNullOrEmpty(Path.GetDirectoryName(output))
? InputDir
: Path.GetDirectoryName(output) !;
var existingFiles = Directory.GetFiles(path);
var csGeneratedFiles = existingFiles.Where(f =>
Path.GetFileNameWithoutExtension(f).StartsWith(prefix) &&
Path.GetFileNameWithoutExtension(f).EndsWith(suffix) &&
Path.GetExtension(f) == Combiner.OutputExtension);
Assert.Single(csGeneratedFiles);
}
public async Task NoOutputAndInputFile()
{
// Arrange
var options = new CombineOptions()
{
Input = $"{InputDir}/ParsingException.cs",
Suffix = CombinerTestsFixture.DefaultSuffix,
Prefix = nameof(NoOutputAndInputFile),
OverWrite = true,
};
// Act
var exitCode = await new Combiner(options).Run();
// Assert
Assert.Equal(0, exitCode);
var existingFiles = Directory.GetFiles(InputDir);
var zipFiles = existingFiles.Where(f => Path.GetExtension(f) == Combiner.OutputExtension &&
Path.GetFileNameWithoutExtension(f).Contains(options.Suffix) &&
Path.GetFileNameWithoutExtension(f).Contains(options.Prefix));
Assert.NotEmpty(zipFiles);
}
public async Task ExcludeFileAndDir()
{
// Arrange
var expectedOutputFile = Path.Combine(DefaultOutputDir, nameof(ExcludeFileAndDir), nameof(ExcludeFileAndDir)) + Combiner.OutputExtension;
var excludes = new[] { "TConverter.cs", "Interfaces/" };
// Act
var options = new CombineOptions()
{
ExcludedItems = excludes,
Output = expectedOutputFile,
OverWrite = true,
Input = InputDir,
};
var exitCode = await new Combiner(options).Run();
// Assert - excluded file is not included in the zip
Assert.Equal(0, exitCode);
Assert.True(File.Exists(expectedOutputFile));
var fileContent = await File.ReadAllTextAsync(expectedOutputFile);
Assert.Contains("ParsingException", fileContent);
Assert.DoesNotContain("class TConverter", fileContent);
Assert.DoesNotContain("interface IParsedFile", fileContent);
Assert.DoesNotContain("interface IParsedLine", fileContent);
}
public async Task NoOutputFileName_GeneratesUniqueFileName(string outputDir)
{
// Arrange
var timeBefore = ParseDateTimeFromFileName(UniqueIdGenerator.UniqueId());
// Act
var options = new CombineOptions()
{
Output = outputDir,
OverWrite = true,
Input = InputDir,
Suffix = CombinerTestsFixture.DefaultSuffix
};
var exitCode = await new Combiner(options).Run();
// Assert
Assert.Equal(0, exitCode);
var existingFiles = Directory.GetFiles(outputDir);
var timeAfter = ParseDateTimeFromFileName(UniqueIdGenerator.UniqueId());
var csGeneratedFiles = existingFiles.Where(f =>
{
if (Path.GetExtension(f) == Combiner.OutputExtension)
{
var fileDate = ParseDateTimeFromFileName(Path.GetFileNameWithoutExtension(f).Replace(options.Suffix, string.Empty));
return(fileDate is not null && fileDate >= timeBefore && fileDate <= timeAfter);
}
return(false);
});
Assert.Single(csGeneratedFiles);
}
public async Task NoInput_ShouldFail()
{
// Arrange
var options = new CombineOptions();
// Act and assert
Assert.Equal(1, await new Combiner(options).Run());
}
public async Task NonExistingFileInput_ShouldFail()
{
// Arrange
var options = new CombineOptions()
{
Input = "./___non_existing_file___"
};
// Act and assert
Assert.Equal(1, await new Combiner(options).Run());
}
bool GetCombine(XmlNode itemNode, XmlNode valueNode, out string separator, out CombineOptions options, out bool isCombineValue)
{
separator = itemNode.GetAttributeValue <string>("combine", null);
options = itemNode.GetAttributeValue <CombineOptions>("combineOptions", CombineOptions.None);
isCombineValue = IsCombineValue(valueNode);
if (itemNode.HasAttribute("combine"))
{
return(true);
}
return(false);
}
public async Task Parse(CombineOptions options)
{
var syntaxTree = CSharpSyntaxTree.ParseText(await File.ReadAllTextAsync(Filepath));
CheckDiagnostics(syntaxTree.GetDiagnostics());
var originalRoot = syntaxTree.GetCompilationUnitRoot();
var pathToTrim = Directory.Exists(options.Input)
? options.Input.ReplaceEndingDirectorySeparatorWithProperEndingDirectorySeparator()
: string.Empty;
var syntaxNode = new AnnotateNamespacesRewriter(Filepath[pathToTrim.Length..]).Visit(originalRoot);
public async Task NoOutputDir_UsesInputDirAndOutputFileName(string fileName, string extension)
{
// Act
var options = new CombineOptions()
{
Output = fileName + extension,
OverWrite = true,
Input = InputDir,
Suffix = CombinerTestsFixture.DefaultSuffix
};
var exitCode = await new Combiner(options).Run();
// Assert
Assert.Equal(0, exitCode);
var existingFiles = Directory.GetFiles(InputDir);
var csGeneratedFiles = existingFiles.Where(f => Path.GetFileNameWithoutExtension(f) == fileName + options.Suffix && Path.GetExtension(f) == Combiner.OutputExtension);
Assert.Single(csGeneratedFiles);
}
public async Task OutputFileCompilation()
{
// Arrange
const string input = "TestsInput/Combiner/ComplexScenario/";
_outputPath = Path.Combine("ComplexScenarioTestsOutput", nameof(OutputFileCompilation) + Combiner.OutputExtension);
var options = new CombineOptions
{
Input = input,
Output = _outputPath,
OverWrite = true
};
// Act
var exitCode = await new Combiner(options).Run();
// Assert
Assert.Equal(0, exitCode);
Assert.True(File.Exists(_outputPath));
await CheckCompilationResults(_outputPath);
}
public async Task OverWrite_CreatesANewFile()
{
// Arrange - create a pre-existing 'output' file
var initialCsFile = Path.Combine(DefaultOutputDir, nameof(OverWrite_CreatesANewFile)) + Combiner.OutputExtension;
CreateFile(initialCsFile);
Assert.True(File.Exists(initialCsFile));
// Act
var options = new CombineOptions()
{
OverWrite = true,
Input = InputDir,
Output = initialCsFile
};
var exitCode = await new Combiner(options).Run();
// Assert - final file isn't initial file
Assert.Equal(0, exitCode);
Assert.True(File.Exists(initialCsFile));
Assert.NotEmpty(File.ReadAllLines(initialCsFile));
}
public async Task OutPut(string output)
{
// Act
var options = new CombineOptions()
{
Output = output,
OverWrite = true,
Input = InputDir,
Suffix = CombinerTestsFixture.DefaultSuffix
};
var exitCode = await new Combiner(options).Run();
// Assert
Assert.Equal(0, exitCode);
var path = string.IsNullOrEmpty(Path.GetDirectoryName(output))
? InputDir
: Path.GetDirectoryName(output) !;
var existingFiles = Directory.GetFiles(path);
var zipFiles = existingFiles.Where(f => Path.GetFileNameWithoutExtension(f) == $"OutPutfilename{options.Suffix}" && Path.GetExtension(f) == Combiner.OutputExtension);
Assert.Single(zipFiles);
}
public async Task NoOverwrite_ThrowsAnException()
{
// Arrange - create a pre-existing 'output' file
var initialCsFile = Path.Combine(DefaultOutputDir, nameof(NoOverwrite_ThrowsAnException)) + Combiner.OutputExtension;
CreateFile(initialCsFile);
Assert.True(File.Exists(initialCsFile));
// Act
var options = new CombineOptions()
{
OverWrite = false,
Input = InputDir,
Output = initialCsFile
};
var exitCode = await new Combiner(options).Run();
// Assert - final file is initial file
Assert.Equal(1, exitCode);
Assert.True(File.Exists(initialCsFile));
Assert.Empty(File.ReadAllLines(initialCsFile));
}
public FilterExpression(string filter, CombineOptions options)
{
this.Filter = filter;
this.Options = options;
}
void SetCombine(XmlNode itemNode, XmlNode valueNode, string separator, CombineOptions options)
{
itemNode.SetOrAddAttributeValue("combine", separator);
itemNode.SetOrAddAttributeValue("combineOptions", options.ToString());
valueNode.SetOrAddAttributeValue("combineValue", true.ToString());
}
public Combiner(CombineOptions options)
{
_options = options;
}
public static bool HasFlagNonAlloc(this CombineOptions self, CombineOptions flag)
{
return((self & flag) == flag);
}
