private static bool TryLoadLibuv(string folder)
{
var path = Path.Combine(folder, Environment.Is64BitProcess ? "x64" : "x86", "libuv.dll");
bool ok = File.Exists(path) && NativeImports.LoadLibrary(path) != IntPtr.Zero;
return(ok);
}
public IEnumerable <PathInfo> FindScriptFiles(ChutzpahTestSettingsFile chutzpahTestSettings)
{
if (chutzpahTestSettings == null)
{
yield break;
}
foreach (var pathSettings in chutzpahTestSettings.Tests.Where(x => x != null))
{
var includePattern = NormalizeFilePath(pathSettings.Include);
var excludePattern = NormalizeFilePath(pathSettings.Exclude);
// The path we assume default to the chuzpah.json directory if the Path property is not set
var testPath = string.IsNullOrEmpty(pathSettings.Path) ? chutzpahTestSettings.SettingsFileDirectory : pathSettings.Path;
testPath = NormalizeFilePath(testPath);
testPath = testPath != null?Path.Combine(chutzpahTestSettings.SettingsFileDirectory, testPath) : null;
// If a file path is given just return that file
var filePath = FindFilePath(testPath);
if (filePath != null)
{
ChutzpahTracer.TraceInformation("Found file {0} from chutzpah.json", filePath);
yield return(GetPathInfo(filePath));
}
// If a folder path is given enumerate that folder (recursively) with the optional include/exclude paths
var folderPath = NormalizeFilePath(FindFolderPath(testPath));
if (folderPath != null)
{
var childFiles = fileSystem.GetFiles(folderPath, "*.*", SearchOption.AllDirectories);
var validFiles = from file in childFiles
let normlizedFile = NormalizeFilePath(file)
where !IsTemporaryChutzpahFile(normlizedFile) &&
(includePattern == null || NativeImports.PathMatchSpec(normlizedFile, includePattern)) &&
(excludePattern == null || !NativeImports.PathMatchSpec(normlizedFile, excludePattern))
select file;
foreach (var item in validFiles)
{
yield return(GetPathInfo(item));
}
}
}
}
/// <summary>
/// Matches the current test path against the Tests settings. The first setting to accept a file wins.
/// </summary>
private bool IsTestPathIncluded(string testFilePath, ChutzpahTestSettingsFile chutzpahTestSettings, out SettingsFileTestPath matchingTestPath)
{
matchingTestPath = null;
// If those test filters are given then accept the test path
if (!chutzpahTestSettings.Tests.Any())
{
return(true);
}
testFilePath = UrlBuilder.NormalizeFilePath(testFilePath);
foreach (var pathSettings in chutzpahTestSettings.Tests.Where(x => x != null))
{
var includePatterns = pathSettings.Includes.Select(x => UrlBuilder.NormalizeFilePath(x)).ToList();
var excludePatterns = pathSettings.Excludes.Select(x => UrlBuilder.NormalizeFilePath(x)).ToList();
// The path we assume default to the chuzpah.json directory if the Path property is not set
var testPath = string.IsNullOrEmpty(pathSettings.Path) ? pathSettings.SettingsFileDirectory : pathSettings.Path;
testPath = UrlBuilder.NormalizeFilePath(testPath);
testPath = testPath != null?Path.Combine(pathSettings.SettingsFileDirectory, testPath) : null;
// If a file path is given just match the test file against it to see if we should urn
var filePath = fileProbe.FindFilePath(testPath);
if (filePath != null)
{
if (filePath.Equals(testFilePath, StringComparison.OrdinalIgnoreCase))
{
matchingTestPath = pathSettings;
ChutzpahTracer.TraceInformation("Test file {0} matched test file path from settings file", testFilePath);
return(true);
}
}
// If a folder path is given then match the test file path that is in that folder with the optional include/exclude paths
var folderPath = UrlBuilder.NormalizeFilePath(fileProbe.FindFolderPath(testPath));
if (folderPath != null)
{
if (testFilePath.Contains(folderPath))
{
var shouldIncludeFile = (!includePatterns.Any() || includePatterns.Any(pat => NativeImports.PathMatchSpec(testFilePath, pat))) &&
(!excludePatterns.Any() || !excludePatterns.Any(pat => NativeImports.PathMatchSpec(testFilePath, pat)));
if (shouldIncludeFile)
{
ChutzpahTracer.TraceInformation(
"Test file {0} matched folder {1} with includes {2} and excludes {3} patterns from settings file",
testFilePath,
folderPath,
string.Join(",", includePatterns),
string.Join(",", excludePatterns));
matchingTestPath = pathSettings;
return(true);
}
else
{
ChutzpahTracer.TraceInformation(
"Test file {0} did not match folder {1} with includes {2} and excludes {3} patterns from settings file",
testFilePath,
folderPath,
string.Join(",", includePatterns),
string.Join(",", excludePatterns));
}
}
}
}
return(false);
}
private void ProcessFilePathAsReference(
HashSet <string> discoveredPaths,
IFrameworkDefinition definition,
string relativeProcessingPath,
ChutzpahTestSettingsFile chutzpahTestSettings,
string referencePath,
List <ReferencedFile> referencedFiles,
ReferencePathSettings pathSettings)
{
ChutzpahTracer.TraceInformation("Investigating reference file path '{0}'", referencePath);
// Check test settings and adjust the path if it is rooted (e.g. /some/path)
referencePath = AdjustPathIfRooted(chutzpahTestSettings, referencePath);
var referenceUri = new Uri(referencePath, UriKind.RelativeOrAbsolute);
string referenceFileName = Path.GetFileName(referencePath);
// Ignore test runner, since we use our own.
if (definition.ReferenceIsDependency(referenceFileName, chutzpahTestSettings))
{
ChutzpahTracer.TraceInformation(
"Ignoring reference file '{0}' as a duplicate reference to {1}",
referenceFileName,
definition.FrameworkKey);
return;
}
var isRelativeUri = !referenceUri.IsAbsoluteUri;
// If this either a relative uri or a file uri
if (isRelativeUri || referenceUri.IsFile)
{
var relativeProcessingPathFolder = fileSystem.FolderExists(relativeProcessingPath)
? relativeProcessingPath
: Path.GetDirectoryName(relativeProcessingPath);
string relativeReferencePath = Path.Combine(relativeProcessingPathFolder, referencePath);
// Check if reference is a file
string absoluteFilePath = fileProbe.FindFilePath(relativeReferencePath);
if (absoluteFilePath != null)
{
VisitReferencedFile(absoluteFilePath, definition, discoveredPaths, referencedFiles, chutzpahTestSettings, pathSettings);
return;
}
// Check if reference is a folder
string absoluteFolderPath = fileProbe.FindFolderPath(relativeReferencePath);
if (absoluteFolderPath != null)
{
var includePatterns = pathSettings.Includes.Select(x => UrlBuilder.NormalizeFilePath(x)).ToList();
var excludePatterns = pathSettings.Excludes.Select(x => UrlBuilder.NormalizeFilePath(x)).ToList();
// Find all files in this folder including sub-folders. This can be ALOT of files.
// Only a subset of these files Chutzpah might understand so many of these will be ignored.
var childFiles = fileSystem.GetFiles(absoluteFolderPath, "*.*", SearchOption.AllDirectories);
var validFiles = from file in childFiles
let normalizedFile = UrlBuilder.NormalizeFilePath(file)
where !fileProbe.IsTemporaryChutzpahFile(file) &&
(!includePatterns.Any() || includePatterns.Any(pat => NativeImports.PathMatchSpec(normalizedFile, pat))) &&
(!excludePatterns.Any() || !excludePatterns.Any(pat => NativeImports.PathMatchSpec(normalizedFile, pat)))
select file;
validFiles.ForEach(file => VisitReferencedFile(file, definition, discoveredPaths, referencedFiles, chutzpahTestSettings, pathSettings));
return;
}
// At this point we know that this file/folder does not exist!
ChutzpahTracer.TraceWarning("Referenced file '{0}' which was resolved to '{1}' does not exist", referencePath, relativeReferencePath);
}
else if (referenceUri.IsAbsoluteUri)
{
var referencedFile = new ReferencedFile
{
Path = referencePath,
IsLocal = false,
IncludeInTestHarness = true,
IsTestFrameworkFile = pathSettings.IsTestFrameworkFile,
TemplateOptions = pathSettings.TemplateOptions
};
ChutzpahTracer.TraceInformation(
"Added file '{0}' to referenced files. Local: {1}, IncludeInTestHarness: {2}",
referencedFile.Path,
referencedFile.IsLocal,
referencedFile.IncludeInTestHarness);
referencedFiles.Add(referencedFile);
}
}