private string GetSearchPaths(IEnumerable <TestCase> tests, PythonProjectSettings settings)
{
var paths = settings.SearchPath.ToList();
HashSet <string> knownModulePaths = new HashSet <string>();
foreach (var test in tests)
{
string testFilePath = PathUtils.GetAbsoluteFilePath(settings.ProjectHome, test.CodeFilePath);
var modulePath = ModulePath.FromFullPath(testFilePath);
if (knownModulePaths.Add(modulePath.LibraryPath))
{
paths.Insert(0, modulePath.LibraryPath);
}
}
paths.Insert(0, settings.WorkingDirectory);
if (_debugMode == PythonDebugMode.PythonOnly)
{
paths.Insert(0, PtvsdSearchPath);
}
string searchPaths = string.Join(
";",
paths.Where(Directory.Exists).Distinct(StringComparer.OrdinalIgnoreCase)
);
return(searchPaths);
}
internal static string DoSubstitutions(LaunchConfiguration original, IPythonProject project, string str)
{
if (string.IsNullOrEmpty(str))
{
return(str);
}
return(SubstitutionPattern.Replace(
str,
m => {
switch (m.Groups[1].Value.ToLowerInvariant())
{
case "startupfile":
return original.ScriptName;
case "startupmodule":
try {
return ModulePath.FromFullPath(original.ScriptName, project.ProjectHome).ModuleName;
} catch (ArgumentException) {
}
break;
}
return m.Value;
}
));
}
private IEnumerable <KeyValuePair <string, TestCase> > GetTestCases()
{
var moduleCache = new Dictionary <string, ModulePath>();
foreach (var test in _tests)
{
string testFile, testClass, testMethod;
TestReader.ParseFullyQualifiedTestName(
test.FullyQualifiedName,
out testFile,
out testClass,
out testMethod
);
ModulePath module;
if (!moduleCache.TryGetValue(testFile, out module))
{
string testFilePath = PathUtils.GetAbsoluteFilePath(_settings.ProjectHome, testFile);
moduleCache[testFile] = module = ModulePath.FromFullPath(testFilePath);
}
yield return(new KeyValuePair <string, TestCase>("{0}.{1}.{2}".FormatInvariant(
module.ModuleName,
testClass,
testMethod
), test));
}
}
public void ModulePathFromFullPath()
{
var basePath = @"C:\Not\A\Real\Path\";
// Replace the usual File.Exists(p + '__init__.py') check so we can
// test without real files.
var packagePaths = new HashSet <string>(PathEqualityComparer.Instance)
{
basePath + @"A\",
basePath + @"A\B\"
};
Func <string, bool> isPackage = p => {
Console.WriteLine("isPackage({0})", p);
return(packagePaths.Contains(p));
};
// __init__ files appear in the full name but not the module name.
var mp = ModulePath.FromFullPath(Path.Combine(basePath, "A", "B", "__init__.py"), isPackage: isPackage);
Assert.AreEqual("A.B", mp.ModuleName);
Assert.AreEqual("A.B.__init__", mp.FullName);
Assert.AreEqual("__init__", mp.Name);
mp = ModulePath.FromFullPath(Path.Combine(basePath, "A", "B", "Module.py"), isPackage: isPackage);
Assert.AreEqual("A.B.Module", mp.ModuleName);
// Ensure we don't go back past the top-level directory if specified
mp = ModulePath.FromFullPath(
Path.Combine(basePath, "A", "B", "Module.py"),
Path.Combine(basePath, "A"),
isPackage
);
Assert.AreEqual("B.Module", mp.ModuleName);
}
public void Export()
{
_writer.WriteStartElement("CoverageDSPriv");
_writer.WriteRaw(_schema);
foreach (var keyValue in _covInfo)
{
var file = keyValue.Key;
var collector = keyValue.Value;
_writer.WriteStartElement("Module");
WriteElement("ModuleName", collector.ModuleName);
WriteElement("ImageSize", new FileInfo(file.Filename).Length);
WriteElement("ImageLinkTime", "0");
int linesCovered = 0, linesNotCovered = 0, blocksCovered = 0, blocksNotCovered = 0;
AggregateStats(collector.GlobalScope, ref linesCovered, ref linesNotCovered, ref blocksCovered, ref blocksNotCovered);
foreach (var klass in collector.Classes)
{
AggregateStats(klass, ref linesCovered, ref linesNotCovered, ref blocksCovered, ref blocksNotCovered);
}
WriteCoverageData(linesCovered, linesNotCovered, blocksCovered, blocksNotCovered);
_writer.WriteStartElement("NamespaceTable");
WriteCoverageData(linesCovered, linesNotCovered, blocksCovered, blocksNotCovered);
WriteElement("ModuleName", ModulePath.FromFullPath(file.Filename).ModuleName);
WriteElement("NamespaceKeyName", file.Filename);
WriteElement("NamespaceName", "");
// Write top-level class
WriteClass(file.Filename, collector.GlobalScope, "<global>");
foreach (var klass in collector.Classes)
{
WriteClass(file.Filename, klass, GetQualifiedName(klass.Statement));
}
_writer.WriteEndElement(); // NamespaceTable
_writer.WriteEndElement(); // Module
_curFile++;
}
int curFile = 0;
foreach (var file in _covInfo.Keys)
{
_writer.WriteStartElement("SourceFileNames");
WriteElement("SourceFileID", curFile + 1);
WriteElement("SourceFileName", file.Filename);
_writer.WriteEndElement();
curFile++;
}
_writer.WriteEndElement();
_writer.Flush();
}
public static IPythonModule FromStream(
IPythonInterpreter interpreter,
Stream sourceFile,
string fileName,
PythonLanguageVersion langVersion,
string moduleFullName
)
{
PythonAst ast;
var sink = KeepParseErrors ? new CollectingErrorSink() : ErrorSink.Null;
var parser = Parser.CreateParser(sourceFile, langVersion, new ParserOptions {
StubFile = fileName.EndsWithOrdinal(".pyi", ignoreCase: true),
ErrorSink = sink
});
ast = parser.ParseFile();
return(new AstPythonModule(
moduleFullName ?? ModulePath.FromFullPath(fileName, isPackage: IsPackageCheck).FullName,
interpreter,
ast,
fileName,
(sink as CollectingErrorSink)?.Errors.Select(e => "{0} ({1}): {2}".FormatUI(fileName ?? "(builtins)", e.Span, e.Message))
));
}
private static IEnumerable <ModulePath> GetModules(string args)
{
var m = Regex.Match(args, "(\\*|[\\w\\.]+)\\s+(.+)");
var modName = m.Groups[1].Value;
var fileName = m.Groups[2].Value;
if (modName != "*")
{
fileName = Path.GetFullPath(fileName);
yield return(new ModulePath(modName, fileName, null));
yield break;
}
if (!fileName.Contains("*"))
{
yield return(ModulePath.FromFullPath(Path.GetFullPath(fileName)));
yield break;
}
var opt = SearchOption.TopDirectoryOnly;
var dir = PathUtils.TrimEndSeparator(PathUtils.GetParent(fileName));
var filter = GetFileOrDirectoryName(fileName);
if (dir.EndsWith("**"))
{
opt = SearchOption.AllDirectories;
dir = dir.Substring(0, dir.Length - 2);
}
if (!Path.IsPathRooted(dir))
{
dir = Path.Combine(Environment.CurrentDirectory, dir);
}
if (!Directory.Exists(dir))
{
Console.WriteLine("Invalid directory: {0}", dir);
yield break;
}
Console.WriteLine("Adding modules from {0}:{1}", dir, filter);
foreach (var file in Directory.EnumerateFiles(dir, filter, opt))
{
ModulePath mp;
try {
mp = ModulePath.FromFullPath(file, PathUtils.GetParent(dir));
} catch (ArgumentException) {
Console.WriteLine("Failed to get module name for {0}", file);
continue;
}
yield return(mp);
}
}
private static string GetCoveragePath(IEnumerable<TestCase> tests) {
string bestFile = null, bestClass = null, bestMethod = null;
// Try and generate a friendly name for the coverage report. We use
// the filename, class, and method. We include each one if we're
// running from a single filename/class/method. When we have multiple
// we drop the identifying names. If we have multiple files we
// go to the top level directory... If all else fails we do "pycov".
foreach (var test in tests) {
string testFile, testClass, testMethod;
TestReader.ParseFullyQualifiedTestName(
test.FullyQualifiedName,
out testFile,
out testClass,
out testMethod
);
bestFile = UpdateBestFile(bestFile, test.CodeFilePath);
if (bestFile != test.CodeFilePath) {
// Different files, don't include class/methods even
// if they happen to be the same.
bestClass = bestMethod = "";
}
bestClass = UpdateBest(bestClass, testClass);
bestMethod = UpdateBest(bestMethod, testMethod);
}
string filename = "";
if (!String.IsNullOrWhiteSpace(bestFile)) {
if (ModulePath.IsPythonSourceFile(bestFile)) {
filename = ModulePath.FromFullPath(bestFile).ModuleName;
} else {
filename = Path.GetFileName(bestFile);
}
} else {
filename = "pycov";
}
if (!String.IsNullOrWhiteSpace(bestClass)) {
filename += "_" + bestClass;
}
if (!String.IsNullOrWhiteSpace(bestMethod)) {
filename += "_" + bestMethod;
}
filename += "_" + DateTime.Now.ToString("s").Replace(':', '_');
return Path.Combine(Path.GetTempPath(), filename);
}
internal static async Task <ModulePath> FindModuleAsync(IPythonInterpreterFactory factory, string filePath, CancellationToken cancellationToken)
{
try {
var apif = factory as AstPythonInterpreterFactory;
if (apif != null)
{
return(await apif.ModuleResolution.FindModuleAsync(filePath, cancellationToken));
}
return(ModulePath.FromFullPath(filePath));
} catch (ArgumentException) {
return(default(ModulePath));
}
}
public static ModulePath FindModule(IPythonInterpreterFactory factory, string filePath)
{
try {
var apif = factory as AstPythonInterpreterFactory;
if (apif != null)
{
return(apif.FindModule(filePath));
}
return(ModulePath.FromFullPath(filePath));
} catch (ArgumentException) {
return(default(ModulePath));
}
}
private string[] GetArguments()
{
var arguments = new List <string>();
arguments.Add(TestLauncherPath);
foreach (var test in _tests)
{
arguments.Add("-t");
string testFile, testClass, testMethod;
TestDiscoverer.ParseFullyQualifiedTestName(
test.FullyQualifiedName,
out testFile,
out testClass,
out testMethod
);
string testFilePath = CommonUtils.GetAbsoluteFilePath(_settings.ProjectHome, testFile);
var module = ModulePath.FromFullPath(testFilePath);
arguments.Add(
string.Format("{0}.{1}.{2}",
module.ModuleName,
testClass,
testMethod
)
);
}
if (_codeCoverageFile != null)
{
arguments.Add("--coverage");
arguments.Add(_codeCoverageFile);
}
if (_debugMode == PythonDebugMode.PythonOnly)
{
arguments.AddRange(new[] {
"-s", _debugSecret,
"-p", _debugPort.ToString()
});
}
else if (_debugMode == PythonDebugMode.PythonAndNative)
{
arguments.Add("-x");
}
arguments.Add("-r");
arguments.Add(((IPEndPoint)_socket.LocalEndPoint).Port.ToString());
return(arguments.ToArray());
}
public override bool Execute()
{
var modules = new List <ITaskItem>();
foreach (var path in Paths)
{
try {
modules.Add(new TaskItem(ModulePath.FromFullPath(path.ItemSpec, PathLimit).ModuleName));
} catch (ArgumentException ex) {
Log.LogErrorFromException(ex);
}
}
ModuleNames = modules.ToArray();
return(!Log.HasLoggedErrors);
}
public ModulePath FindModule(string filePath)
{
var bestLibraryPath = string.Empty;
foreach (var p in InterpreterPaths.Concat(UserPaths))
{
if (PathEqualityComparer.Instance.StartsWith(filePath, p))
{
if (p.Length > bestLibraryPath.Length)
{
bestLibraryPath = p;
}
}
}
return(ModulePath.FromFullPath(filePath, bestLibraryPath));
}
public ModulePath FindModule(string filePath)
{
var bestLibraryPath = string.Empty;
foreach (var p in Configuration.SearchPaths)
{
if (PathEqualityComparer.Instance.StartsWith(filePath, p))
{
if (p.Length > bestLibraryPath.Length)
{
bestLibraryPath = p;
}
}
}
return(ModulePath.FromFullPath(filePath, bestLibraryPath));
}
private DjangoAnalyzer AnalyzerTest(string path)
{
string djangoDbPath = TestData.GetPath("TestData\\DjangoDB");
Assert.IsTrue(
PythonTypeDatabase.IsDatabaseVersionCurrent(djangoDbPath),
"TestData\\DjangoDB needs updating."
);
var testFact = PythonInterpreterFactoryWithDatabase.CreateFromDatabase(
new Version(2, 7),
TestData.GetPath("CompletionDB"),
djangoDbPath
);
var serviceProvider = PythonToolsTestUtilities.CreateMockServiceProvider();
PythonAnalyzer analyzer = PythonAnalyzer.CreateAsync(testFact).WaitAndUnwrapExceptions();
DjangoAnalyzer djangoAnalyzer = new DjangoAnalyzer();
djangoAnalyzer.Register(analyzer);
analyzer.SetSearchPaths(new[] { path });
List <IPythonProjectEntry> entries = new List <IPythonProjectEntry>();
foreach (string file in Directory.EnumerateFiles(path, "*.py", SearchOption.AllDirectories))
{
var entry = analyzer.AddModule(ModulePath.FromFullPath(file).ModuleName, file);
var parser = Parser.CreateParser(
new FileStream(file, FileMode.Open, FileAccess.Read),
PythonLanguageVersion.V27
);
using (var p = entry.BeginParse()) {
p.Tree = parser.ParseFile();
p.Complete();
}
entries.Add(entry);
}
foreach (var entry in entries)
{
entry.Analyze(CancellationToken.None, false);
}
return(djangoAnalyzer);
}
private DjangoAnalyzer AnalyzerTest(string path)
{
string djangoDbPath = TestData.GetPath("TestData\\DjangoDB");
Assert.IsTrue(
PythonTypeDatabase.IsDatabaseVersionCurrent(djangoDbPath),
"TestData\\DjangoDB needs updating."
);
var testFact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(
new Version(2, 7),
"Django Test Interpreter",
TestData.GetPath("CompletionDB"),
djangoDbPath
);
var serviceProvider = PythonToolsTestUtilities.CreateMockServiceProvider();
PythonAnalyzer analyzer = new PythonAnalyzer(testFact);
DjangoAnalyzer djangoAnalyzer = new DjangoAnalyzer(serviceProvider);
djangoAnalyzer.OnNewAnalyzer(analyzer);
analyzer.AddAnalysisDirectory(path);
List <IPythonProjectEntry> entries = new List <IPythonProjectEntry>();
foreach (string file in Directory.EnumerateFiles(path, "*.py", SearchOption.AllDirectories))
{
var entry = analyzer.AddModule(ModulePath.FromFullPath(file).ModuleName, file);
var parser = Parser.CreateParser(
new FileStream(file, FileMode.Open, FileAccess.Read),
PythonLanguageVersion.V27
);
entry.UpdateTree(parser.ParseFile(), null);
entries.Add(entry);
}
foreach (var entry in entries)
{
entry.Analyze(CancellationToken.None, false);
}
return(djangoAnalyzer);
}
// TODO: Pylance
// Replacement for ModulePath.GetModulesInLib which disappeared, this is an approximation
private static IEnumerable <ModulePath> GetModulesInLib(
string libraryPath,
string sitePackagesPath,
bool requiresInitPyFiles
)
{
var folderPaths = Directory
.EnumerateDirectories(libraryPath, "*", SearchOption.AllDirectories)
.Where(folderPath => !PathUtils.IsSameDirectory(folderPath, sitePackagesPath))
.Where(folderPath => !requiresInitPyFiles || File.Exists(Path.Combine(folderPath, "__init__.py")))
.Prepend(libraryPath);
foreach (var filePath in folderPaths.SelectMany(
folderPath => Directory.EnumerateFiles(folderPath, "*.py").Where(ModulePath.IsPythonFile))
)
{
yield return(ModulePath.FromFullPath(filePath, libraryPath));
}
}
private DjangoAnalyzer AnalyzerTest(string path)
{
var version = new Version(2, 7);
var testFact = new AstPythonInterpreterFactory(
new InterpreterConfiguration($"AnalysisOnly|{version}", $"Analysis Only {version}", version: version, uiMode: InterpreterUIMode.Normal),
new InterpreterFactoryCreationOptions {
WatchFileSystem = false
}
);
var serviceProvider = PythonToolsTestUtilities.CreateMockServiceProvider();
PythonAnalyzer analyzer = PythonAnalyzer.CreateAsync(testFact).WaitAndUnwrapExceptions();
DjangoAnalyzer djangoAnalyzer = new DjangoAnalyzer();
djangoAnalyzer.Register(analyzer);
analyzer.SetSearchPaths(new[] { path });
List <IPythonProjectEntry> entries = new List <IPythonProjectEntry>();
foreach (string file in Directory.EnumerateFiles(path, "*.py", SearchOption.AllDirectories))
{
var entry = analyzer.AddModule(ModulePath.FromFullPath(file).ModuleName, file);
var parser = Parser.CreateParser(
new FileStream(file, FileMode.Open, FileAccess.Read),
PythonLanguageVersion.V27
);
using (var p = entry.BeginParse()) {
p.Tree = parser.ParseFile();
p.Complete();
}
entries.Add(entry);
}
foreach (var entry in entries)
{
entry.Analyze(CancellationToken.None, false);
}
return(djangoAnalyzer);
}
public static IPythonModule FromStream(
IPythonInterpreter interpreter,
Stream sourceFile,
string fileName,
PythonLanguageVersion langVersion,
string moduleFullName
)
{
PythonAst ast;
using (var parser = Parser.CreateParser(sourceFile, langVersion)) {
ast = parser.ParseFile();
}
return(new AstPythonModule(
moduleFullName ?? ModulePath.FromFullPath(fileName, isPackage: IsPackageCheck).FullName,
interpreter,
ast,
fileName
));
}
private ModulePath FindModule(string filePath)
{
var sp = GetSearchPaths();
string bestLibraryPath = "";
foreach (var p in sp)
{
if (PathUtils.IsSubpathOf(p.Path, filePath))
{
if (p.Path.Length > bestLibraryPath.Length)
{
bestLibraryPath = p.Path;
}
}
}
var mp = ModulePath.FromFullPath(filePath, bestLibraryPath);
return(mp);
}
private async Task <ModulePath> FindModuleAsync(string filePath)
{
var sp = await GetSearchPathsAsync();
string bestLibraryPath = "";
foreach (var p in sp)
{
if (PathEqualityComparer.Instance.StartsWith(filePath, p))
{
if (p.Length > bestLibraryPath.Length)
{
bestLibraryPath = p;
}
}
}
var mp = ModulePath.FromFullPath(filePath, bestLibraryPath);
return(mp);
}
private static IEnumerable <ModulePath> GetModules(string args)
{
var m = Regex.Match(args, "(\\*|[\\w\\.]+)\\s+(.+)");
var modName = m.Groups[1].Value;
var fileName = m.Groups[2].Value;
if (modName != "*")
{
fileName = Path.GetFullPath(fileName);
yield return(new ModulePath(modName, fileName, null));
yield break;
}
if (!fileName.Contains("*"))
{
yield return(ModulePath.FromFullPath(Path.GetFullPath(fileName)));
yield break;
}
var opt = SearchOption.TopDirectoryOnly;
if (fileName.StartsWith("**\\"))
{
opt = SearchOption.AllDirectories;
fileName = fileName.Substring(3);
}
if (!Path.IsPathRooted(fileName))
{
fileName = Path.Combine(Environment.CurrentDirectory, fileName);
}
Console.WriteLine("Adding modules from {0}", fileName);
foreach (var file in Directory.EnumerateFiles(Path.GetDirectoryName(fileName), Path.GetFileName(fileName), opt))
{
yield return(ModulePath.FromFullPath(file));
}
}
public static IPythonModule FromStream(
IPythonInterpreter interpreter,
Stream sourceFile,
string fileName,
PythonLanguageVersion langVersion,
string moduleFullName
)
{
PythonAst ast;
var parser = Parser.CreateParser(sourceFile, langVersion, new ParserOptions {
StubFile = fileName.EndsWithOrdinal(".pyi", ignoreCase: true)
});
ast = parser.ParseFile();
return(new AstPythonModule(
moduleFullName ?? ModulePath.FromFullPath(fileName, isPackage: IsPackageCheck).FullName,
interpreter,
ast,
fileName
));
}
public static IPythonModule FromStream(
IPythonInterpreter interpreter,
Stream sourceFile,
string fileName,
PythonLanguageVersion langVersion,
string moduleFullName
)
{
PythonAst ast;
using (var parser = Parser.CreateParser(sourceFile, langVersion, new ParserOptions {
StubFile = fileName?.EndsWith(".pyi", StringComparison.OrdinalIgnoreCase) ?? false,
Verbatim = true
})) {
ast = parser.ParseFile();
}
return(new AstPythonModule(
moduleFullName ?? ModulePath.FromFullPath(fileName, isPackage: IsPackageCheck).FullName,
interpreter,
ast,
fileName
));
}
internal PythonAnalyzer AnalyzeDir(string dir, PythonLanguageVersion version = PythonLanguageVersion.V27, IEnumerable <string> excludeDirectories = null, CancellationToken?cancel = null)
{
List <string> files = new List <string>();
try {
ISet <string> excluded = null;
if (excludeDirectories != null)
{
excluded = new HashSet <string>(excludeDirectories, StringComparer.InvariantCultureIgnoreCase);
}
CollectFiles(dir, files, excluded);
} catch (DirectoryNotFoundException) {
return(null);
}
List <FileStreamReader> sourceUnits = new List <FileStreamReader>();
foreach (string file in files)
{
sourceUnits.Add(
new FileStreamReader(file)
);
}
Stopwatch sw = new Stopwatch();
sw.Start();
long start0 = sw.ElapsedMilliseconds;
// Explicitly specify the builtins name because we are using a 2.7
// interpreter for all versions.
var fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
var projectState = new PythonAnalyzer(fact, fact.CreateInterpreter(), "__builtin__");
projectState.Limits = AnalysisLimits.GetStandardLibraryLimits();
var modules = new List <IPythonProjectEntry>();
foreach (var sourceUnit in sourceUnits)
{
try {
modules.Add(projectState.AddModule(
ModulePath.FromFullPath(sourceUnit.Path).ModuleName,
sourceUnit.Path,
null
));
} catch (ArgumentException) {
// Invalid module name, so skip the module
}
}
long start1 = sw.ElapsedMilliseconds;
Trace.TraceInformation("AddSourceUnit: {0} ms", start1 - start0);
var nodes = new List <Microsoft.PythonTools.Parsing.Ast.PythonAst>();
for (int i = 0; i < modules.Count; i++)
{
PythonAst ast = null;
try {
var sourceUnit = sourceUnits[i];
ast = Parser.CreateParser(sourceUnit, version).ParseFile();
} catch (Exception) {
}
nodes.Add(ast);
}
long start2 = sw.ElapsedMilliseconds;
Trace.TraceInformation("Parse: {0} ms", start2 - start1);
for (int i = 0; i < modules.Count; i++)
{
var ast = nodes[i];
if (ast != null)
{
modules[i].UpdateTree(ast, null);
}
}
long start3 = sw.ElapsedMilliseconds;
for (int i = 0; i < modules.Count; i++)
{
Trace.TraceInformation("Analyzing {1}: {0} ms", sw.ElapsedMilliseconds - start3, sourceUnits[i].Path);
var ast = nodes[i];
if (ast != null)
{
modules[i].Analyze(cancel ?? CancellationToken.None, true);
}
}
if (modules.Count > 0)
{
Trace.TraceInformation("Analyzing queue");
modules[0].AnalysisGroup.AnalyzeQueuedEntries(cancel ?? CancellationToken.None);
}
long start4 = sw.ElapsedMilliseconds;
Trace.TraceInformation("Analyze: {0} ms", start4 - start3);
return(projectState);
}
private async Task CompiledBuiltinScrapeAsync(InterpreterConfiguration configuration)
{
configuration.AssertInstalled();
var moduleUri = TestData.GetDefaultModuleUri();
var moduleDirectory = Path.GetDirectoryName(moduleUri.LocalPath);
var services = await CreateServicesAsync(moduleDirectory, configuration);
var interpreter = services.GetService <IPythonInterpreter>();
var fs = services.GetService <IFileSystem>();
// TODO: this is Windows only
var dllsDir = Path.Combine(Path.GetDirectoryName(interpreter.Configuration.LibraryPath), "DLLs");
if (!Directory.Exists(dllsDir))
{
Assert.Inconclusive("Configuration does not have DLLs");
}
var report = new List <string>();
var permittedImports = interpreter.LanguageVersion.Is2x() ?
new[] { interpreter.ModuleResolution.BuiltinModuleName, "exceptions" } :
new[] { interpreter.ModuleResolution.BuiltinModuleName };
var modules = new List <IPythonModule>();
foreach (var pyd in PathUtils.EnumerateFiles(fs, dllsDir, "*", recurse: false).Select(f => f.FullName).Where(ModulePath.IsPythonFile))
{
var mp = ModulePath.FromFullPath(pyd);
if (mp.IsDebug)
{
continue;
}
Console.WriteLine(@"Importing {0} from {1}", mp.ModuleName, mp.SourceFile);
modules.Add(interpreter.ModuleResolution.GetOrLoadModule(mp.ModuleName));
}
foreach (var mod in modules)
{
Assert.IsInstanceOfType(mod, typeof(CompiledPythonModule));
await((StubCache)interpreter.ModuleResolution.StubCache).CacheWritingTask;
var modPath = interpreter.ModuleResolution.StubCache.GetCacheFilePath(mod.FilePath);
Assert.IsTrue(File.Exists(modPath), "No cache file created");
var doc = (IDocument)mod;
var ast = await doc.GetAstAsync();
var errors = doc.GetParseErrors().ToArray();
foreach (var err in errors)
{
Console.WriteLine(err);
}
Assert.AreEqual(0, errors.Length, "Parse errors occurred");
var imports = ((SuiteStatement)ast.Body).Statements
.OfType <ImportStatement>()
.SelectMany(s => s.Names)
.Select(n => n.MakeString())
.Except(permittedImports)
.ToArray();
// We expect no imports (after excluding builtins)
report.AddRange(imports.Select(n => $"{mod.Name} imported {n}"));
}
report.Should().BeEmpty();
}
public void DiscoverTests(IEnumerable <string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
ValidateArg.NotNull(sources, "sources");
ValidateArg.NotNull(discoverySink, "discoverySink");
var buildEngine = new MSBuild.ProjectCollection();
try {
// Load all the test containers passed in (.pyproj msbuild files)
foreach (string source in sources)
{
buildEngine.LoadProject(source);
}
foreach (var proj in buildEngine.LoadedProjects)
{
using (var provider = new MSBuildProjectInterpreterFactoryProvider(_interpreterService, proj)) {
try {
provider.DiscoverInterpreters();
} catch (InvalidDataException) {
// This exception can be safely ignored here.
}
var factory = provider.ActiveInterpreter;
if (factory == _interpreterService.NoInterpretersValue)
{
if (logger != null)
{
logger.SendMessage(TestMessageLevel.Warning, "No interpreters available for project " + proj.FullPath);
}
continue;
}
var projectHome = Path.GetFullPath(Path.Combine(proj.DirectoryPath, proj.GetPropertyValue(PythonConstants.ProjectHomeSetting) ?? "."));
// Do the analysis even if the database is not up to date. At
// worst, we'll get no results.
using (var analyzer = new TestAnalyzer(
factory,
proj.FullPath,
projectHome,
TestExecutor.ExecutorUri
)) {
// Provide all files to the test analyzer
foreach (var item in proj.GetItems("Compile"))
{
string fileAbsolutePath = CommonUtils.GetAbsoluteFilePath(projectHome, item.EvaluatedInclude);
string fullName;
try {
fullName = ModulePath.FromFullPath(fileAbsolutePath).ModuleName;
} catch (ArgumentException) {
if (logger != null)
{
logger.SendMessage(TestMessageLevel.Warning, "File has an invalid module name: " + fileAbsolutePath);
}
continue;
}
try {
using (var reader = new StreamReader(fileAbsolutePath)) {
analyzer.AddModule(fullName, fileAbsolutePath, reader);
}
} catch (FileNotFoundException) {
// user deleted file, we send the test update, but the project
// isn't saved.
#if DEBUG
} catch (Exception ex) {
if (logger != null)
{
logger.SendMessage(TestMessageLevel.Warning, "Failed to discover tests in " + fileAbsolutePath);
logger.SendMessage(TestMessageLevel.Informational, ex.ToString());
}
}
#else
} catch (Exception) {
if (logger != null)
{
logger.SendMessage(TestMessageLevel.Warning, "Failed to discover tests in " + fileAbsolutePath);
}
}
#endif
}
private void AstNativeBuiltinScrape(PythonVersion version) {
AstScrapedPythonModule.KeepAst = true;
version.AssertInstalled();
using (var analysis = CreateAnalysis(version)) {
try {
var fact = (AstPythonInterpreterFactory)analysis.Analyzer.InterpreterFactory;
var interp = (AstPythonInterpreter)analysis.Analyzer.Interpreter;
var ctxt = interp.CreateModuleContext();
var dllsDir = PathUtils.GetAbsoluteDirectoryPath(fact.Configuration.PrefixPath, "DLLs");
if (!Directory.Exists(dllsDir)) {
Assert.Inconclusive("Configuration does not have DLLs");
}
var report = new List<string>();
var permittedImports = fact.GetLanguageVersion().Is2x() ?
new[] { interp.BuiltinModuleName, "exceptions" } :
new[] { interp.BuiltinModuleName };
foreach (var pyd in PathUtils.EnumerateFiles(dllsDir, "*", recurse: false).Where(ModulePath.IsPythonFile)) {
var mp = ModulePath.FromFullPath(pyd);
if (mp.IsDebug) {
continue;
}
Console.WriteLine("Importing {0} from {1}", mp.ModuleName, mp.SourceFile);
var mod = interp.ImportModule(mp.ModuleName);
Assert.IsInstanceOfType(mod, typeof(AstScrapedPythonModule));
mod.Imported(ctxt);
var modPath = fact.GetCacheFilePath(pyd);
Assert.IsTrue(File.Exists(modPath), "No cache file created");
_moduleCache = File.ReadAllText(modPath);
var errors = ((AstScrapedPythonModule)mod).ParseErrors ?? Enumerable.Empty<string>();
foreach (var err in errors) {
Console.WriteLine(err);
}
Assert.AreEqual(0, errors.Count(), "Parse errors occurred");
var ast = ((AstScrapedPythonModule)mod).Ast;
var imports = ((Ast.SuiteStatement)ast.Body).Statements
.OfType<Ast.ImportStatement>()
.SelectMany(s => s.Names)
.Select(n => n.MakeString())
.Except(permittedImports)
.ToArray();
// We expect no imports (after excluding builtins)
report.AddRange(imports.Select(n => $"{mp.ModuleName} imported {n}"));
_moduleCache = null;
}
AssertUtil.ContainsExactly(report);
} finally {
_analysisLog = analysis.GetLogContent(CultureInfo.InvariantCulture);
}
}
}
private void ConectionReceivedEvent(object sender, EventReceivedEventArgs e)
{
switch (e.Name)
{
case TP.ResultEvent.Name:
var result = (TP.ResultEvent)e.Event;
TestOutcome outcome = TestOutcome.None;
switch (result.outcome)
{
case "passed": outcome = TestOutcome.Passed; break;
case "failed": outcome = TestOutcome.Failed; break;
case "skipped": outcome = TestOutcome.Skipped; break;
}
var testResult = new TestResult(_curTest);
RecordEnd(
_frameworkHandle,
_curTest,
testResult,
_stdOut.ToString(),
_stdErr.ToString(),
outcome,
result
);
_stdOut.Clear();
_stdErr.Clear();
break;
case TP.StartEvent.Name:
var start = (TP.StartEvent)e.Event;
_curTest = null;
foreach (var test in _tests)
{
string testFile, testClass, testMethod;
TestDiscoverer.ParseFullyQualifiedTestName(
test.FullyQualifiedName,
out testFile,
out testClass,
out testMethod
);
string testFilePath = CommonUtils.GetAbsoluteFilePath(_settings.ProjectHome, test.CodeFilePath);
var modulePath = ModulePath.FromFullPath(testFilePath);
if (start.test == modulePath.ModuleName + "." + testClass + "." + testMethod)
{
_curTest = test;
break;
}
}
if (_curTest != null)
{
_frameworkHandle.RecordStart(_curTest);
}
else
{
Warning(
string.Format(
"Unexpected test result: {0} {1} {2}",
start.classname,
start.method
)
);
}
break;
case TP.StdErrEvent.Name:
var err = (TP.StdErrEvent)e.Event;
_stdErr.Append(err.content);
break;
case TP.StdOutEvent.Name:
var outp = (TP.StdOutEvent)e.Event;
_stdOut.Append(outp.content);
break;
case TP.DoneEvent.Name:
_done.Set();
break;
}
}