public void DiscoverPytestSearchPath()
{
// test_search_path.py has an import at global scope that requires search path to resolve
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkPytest);
FileUtils.CopyDirectory(TestData.GetPath("TestData", "TestDiscoverer", "ImportFromSearchPath"), testEnv.SourceFolderPath);
// <SourceFolderPath>/TestFolder/
// <SourceFolderPath>/TestFolder/test_search_path.py
// <SourceFolderPath>/SearchPath/
// <SourceFolderPath>/SearchPath/searchpathmodule.py
var testFilePath = Path.Combine(testEnv.SourceFolderPath, "TestFolder", "test_search_path.py");
var searchPath = Path.Combine(testEnv.SourceFolderPath, "SearchPath");
var expectedTests = new[] {
new TestInfo("test_imported_module", "TestFolder\\test_search_path.py::SearchPathTests::test_imported_module", testFilePath, 5),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFile(testFilePath)
.WithSearchPath(searchPath)
.ToXml()
);
DiscoverTests(testEnv, new[] { testFilePath }, runSettings, expectedTests);
}
public void DiscoverPytestNotInstalled()
{
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkPytest, installFramework: false);
var testFilePath = Path.Combine(testEnv.SourceFolderPath, "test_pt.py");
File.Copy(TestData.GetPath("TestData", "TestDiscoverer", "BasicPytest", "test_pt.py"), testFilePath);
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFilesFromFolder(testEnv.SourceFolderPath)
.ToXml()
);
var discoveryContext = new MockDiscoveryContext(runSettings);
var discoverySink = new MockTestCaseDiscoverySink();
var logger = new MockMessageLogger();
var discoverer = new PytestTestDiscoverer();
discoverer.DiscoverTests(new[] { testFilePath }, discoveryContext, logger, discoverySink);
Assert.AreEqual(0, discoverySink.Tests.Count);
var errors = string.Join(Environment.NewLine, logger.GetErrors());
AssertUtil.Contains(errors, string.Format(ImportErrorFormat, "pytest"));
}
private MockMessageLogger NewMethod()
{
TestEnvironment testEnv = TestEnvironment.GetOrCreate(Version, FrameworkUnittest);
FileUtils.CopyDirectory(TestData.GetPath("TestData", "TestDiscoverer", "SyntaxErrorUnittest"), testEnv.SourceFolderPath);
var testFilePath1 = Path.Combine(testEnv.SourceFolderPath, "test_basic_ut.py");
var testFilePath2 = Path.Combine(testEnv.SourceFolderPath, "test_syntax_error_ut.py");
TestInfo[] expectedTests = new[] {
new TestInfo("test_ut_fail", "test_basic_ut.py::TestClassUT::test_ut_fail", testFilePath1, 4),
new TestInfo("test_ut_pass", "test_basic_ut.py::TestClassUT::test_ut_pass", testFilePath1, 7),
};
MockRunSettings runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFile(testFilePath1)
.WithTestFile(testFilePath2)
.ToXml()
);
MockDiscoveryContext discoveryContext = new MockDiscoveryContext(runSettings);
MockTestCaseDiscoverySink discoverySink = new MockTestCaseDiscoverySink();
MockMessageLogger logger = new MockMessageLogger();
var discoverer = new UnittestTestDiscoverer();
discoverer.DiscoverTests(new[] { testFilePath1, testFilePath2 }, discoveryContext, logger, discoverySink);
return(logger);
}
public void DiscoverPytestSyntaxErrorLogErrors()
{
// one file has a valid passing test,
// the other has a test with a syntax error in it
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkPytest);
FileUtils.CopyDirectory(TestData.GetPath("TestData", "TestDiscoverer", "SyntaxErrorPytest"), testEnv.SourceFolderPath);
var testFilePath1 = Path.Combine(testEnv.SourceFolderPath, "test_basic.py");
var testFilePath2 = Path.Combine(testEnv.SourceFolderPath, "test_syntax_error.py");
var expectedTests = new[] {
new TestInfo("test_success", "test_basic.py::test_basic::test_success", testFilePath1, 1),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFile(testFilePath1)
.WithTestFile(testFilePath2)
.ToXml()
);
var discoveryContext = new MockDiscoveryContext(runSettings);
var discoverySink = new MockTestCaseDiscoverySink();
var logger = new MockMessageLogger();
var discoverer = new PytestTestDiscoverer();
discoverer.DiscoverTests(new[] { testFilePath1, testFilePath2 }, discoveryContext, logger, discoverySink);
var errors = string.Join(Environment.NewLine, logger.GetErrors());
AssertUtil.Contains(errors,
"SyntaxError: invalid syntax"
);
}
public void DiscoverUnittestRelativeImport()
{
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkUnittest);
FileUtils.CopyDirectory(TestData.GetPath("TestData", "TestDiscoverer", "RelativeImport"), testEnv.SourceFolderPath);
var testFilePath = Path.Combine(testEnv.SourceFolderPath, "relativeimportpackage\\test_relative_import.py");
var expectedTests = new[] {
new TestInfo(
"test_relative_import",
"relativeimportpackage\\test_relative_import.py::RelativeImportTests::test_relative_import",
testFilePath,
5
),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFile(testFilePath)
.ToXml()
);
DiscoverTests(testEnv, new[] { testFilePath }, runSettings, expectedTests);
}
public void DiscoverUnittest()
{
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkUnittest);
var testFile1Path = Path.Combine(testEnv.SourceFolderPath, "test_ut.py");
File.Copy(TestData.GetPath("TestData", "TestDiscoverer", "BasicUnittest", "test_ut.py"), testFile1Path);
var testFile2Path = Path.Combine(testEnv.SourceFolderPath, "test_runtest.py");
File.Copy(TestData.GetPath("TestData", "TestDiscoverer", "BasicUnittest", "test_runtest.py"), testFile2Path);
var expectedTests = new[] {
new TestInfo("test_ut_fail", "test_ut.py::TestClassUT::test_ut_fail", testFile1Path, 4),
new TestInfo("test_ut_pass", "test_ut.py::TestClassUT::test_ut_pass", testFile1Path, 7),
new TestInfo("runTest", "test_runtest.py::TestClassRunTest::runTest", testFile2Path, 4),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFilesFromFolder(testEnv.SourceFolderPath)
.ToXml()
);
DiscoverTests(testEnv, new[] { testFile1Path }, runSettings, expectedTests);
}
public void DiscoverPytestConfigPythonFiles()
{
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkPytest);
FileUtils.CopyDirectory(TestData.GetPath("TestData", "TestDiscoverer", "ConfigPythonFiles"), testEnv.SourceFolderPath);
var testFilePath = Path.Combine(testEnv.SourceFolderPath, "test_pt.py");
var checkFilePath = Path.Combine(testEnv.SourceFolderPath, "check_pt.py");
var exampleFilePath = Path.Combine(testEnv.SourceFolderPath, "example_pt.py");
// pytest.ini declares that tests are only files named check_*.py and test_*.py
// so the test defined in example_pt.py should not be discovered
var expectedTests = new[] {
new TestInfo("test_1", "test_pt.py::test_pt::test_1", testFilePath, 1),
new TestInfo("test_2", "check_pt.py::check_pt::test_2", checkFilePath, 1),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFile(checkFilePath)
.WithTestFile(testFilePath)
.WithTestFile(exampleFilePath)
.ToXml()
);
DiscoverTests(testEnv, new[] { checkFilePath, testFilePath, exampleFilePath }, runSettings, expectedTests);
}
public void DiscoverUnittestInheritance()
{
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkUnittest);
FileUtils.CopyDirectory(TestData.GetPath("TestData", "TestDiscoverer", "Inheritance"), testEnv.SourceFolderPath);
var baseTestFilePath = Path.Combine(testEnv.SourceFolderPath, "test_base.py");
var derivedTestFilePath = Path.Combine(testEnv.SourceFolderPath, "test_derived.py");
var expectedTests = new[] {
new TestInfo("test_base_pass", "test_base.py::BaseClassTests::test_base_pass", baseTestFilePath, 4),
new TestInfo("test_base_fail", "test_base.py::BaseClassTests::test_base_fail", baseTestFilePath, 7),
// TODO: investigate potential bug in product code,
// file name incorrect for these two, should be in baseTestFilePath
new TestInfo("test_base_pass", "test_derived.py::DerivedClassTests::test_base_pass", derivedTestFilePath, 4),
new TestInfo("test_base_fail", "test_derived.py::DerivedClassTests::test_base_fail", derivedTestFilePath, 7),
new TestInfo("test_derived_pass", "test_derived.py::DerivedClassTests::test_derived_pass", derivedTestFilePath, 5),
new TestInfo("test_derived_fail", "test_derived.py::DerivedClassTests::test_derived_fail", derivedTestFilePath, 8),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFilesFromFolder(testEnv.SourceFolderPath)
.ToXml()
);
DiscoverTests(testEnv, new[] { baseTestFilePath, derivedTestFilePath }, runSettings, expectedTests);
}
public void DiscoverUnitTestSyntaxErrorPartialResults()
{
// one file has a valid passing test,
// the other has an unknown module import at global scope
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkUnittest);
FileUtils.CopyDirectory(TestData.GetPath("TestData", "TestDiscoverer", "SyntaxErrorUnittest"), testEnv.SourceFolderPath);
var testFilePath1 = Path.Combine(testEnv.SourceFolderPath, "test_basic_ut.py");
var testFilePath2 = Path.Combine(testEnv.SourceFolderPath, "test_syntax_error_ut.py");
var expectedTests = new[] {
new TestInfo("test_ut_fail", "test_basic_ut.py::TestClassUT::test_ut_fail", testFilePath1, 4),
new TestInfo("test_ut_pass", "test_basic_ut.py::TestClassUT::test_ut_pass", testFilePath1, 7),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFile(testFilePath1)
.WithTestFile(testFilePath2)
.ToXml()
);
var discoveryContext = new MockDiscoveryContext(runSettings);
var discoverySink = new MockTestCaseDiscoverySink();
var logger = new MockMessageLogger();
var discoverer = new UnittestTestDiscoverer();
discoverer.DiscoverTests(new[] { testFilePath1, testFilePath2 }, discoveryContext, logger, discoverySink);
ValidateDiscoveredTests(testEnv.TestFramework, discoverySink.Tests, expectedTests);
}
private static void DiscoverTests(TestEnvironment testEnv, string[] sources, MockRunSettings runSettings, TestInfo[] expectedTests)
{
var discoveryContext = new MockDiscoveryContext(runSettings);
var discoverySink = new MockTestCaseDiscoverySink();
var logger = new MockMessageLogger();
ITestDiscoverer discoverer = null;
switch (testEnv.TestFramework)
{
case FrameworkPytest:
discoverer = new PytestTestDiscoverer();
break;
case FrameworkUnittest:
discoverer = new UnittestTestDiscoverer();
break;
default:
Assert.Fail($"unknown testframework: {testEnv.TestFramework.ToString()}");
break;
}
discoverer.DiscoverTests(sources, discoveryContext, logger, discoverySink);
ValidateDiscoveredTests(testEnv.TestFramework, discoverySink.Tests, expectedTests);
}
public void DiscoverUnittestTimeoutError()
{
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkUnittest);
var testFilePath = Path.Combine(testEnv.SourceFolderPath, "test_ut.py");
File.Copy(TestData.GetPath("TestData", "TestDiscoverer", "Timeout", "test_timeout_ut.py"), testFilePath);
int waitTimeInSeconds = 1;
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath, waitTimeInSeconds)
.WithTestFilesFromFolder(testEnv.SourceFolderPath)
.ToXml()
);
var discoveryContext = new MockDiscoveryContext(runSettings);
var discoverySink = new MockTestCaseDiscoverySink();
var logger = new MockMessageLogger();
var discoverer = new UnittestTestDiscoverer();
discoverer.DiscoverTests(new[] { testFilePath }, discoveryContext, logger, discoverySink);
Assert.AreEqual(0, discoverySink.Tests.Count);
var errors = string.Join(Environment.NewLine, logger.GetErrors());
AssertUtil.Contains(
errors,
Strings.PythonTestDiscovererTimeoutErrorMessage
);
}
public void DiscoverUnittestConfiguration()
{
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkUnittest);
FileUtils.CopyDirectory(TestData.GetPath("TestData", "TestDiscoverer", "ConfigUnittest"), testEnv.SourceFolderPath);
// We have 3 files
// product/prefix_not_included.py (should not be found, outside test folder)
// test/test_not_included.py (should not be found, incorrect filename pattern)
// test/prefix_included.py (should be found)
var testFilePath = Path.Combine(testEnv.SourceFolderPath, "test", "prefix_included.py");
var expectedTests = new[] {
new TestInfo("test_included", "test\\prefix_included.py::PrefixIncluded::test_included", testFilePath, 4),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFilesFromFolder(Path.Combine(testEnv.SourceFolderPath, "product"))
.WithTestFilesFromFolder(Path.Combine(testEnv.SourceFolderPath, "test"))
.WithUnitTestConfiguration("test", "prefix_*.py")
.ToXml()
);
DiscoverTests(testEnv, new[] { testFilePath }, runSettings, expectedTests);
}
public void DiscoverUnitTestSyntaxErrorLogErrors()
{
// one file has a valid passing test,
// the other has an unknown module import at global scope
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkUnittest);
FileUtils.CopyDirectory(TestData.GetPath("TestData", "TestDiscoverer", "SyntaxErrorUnittest"), testEnv.SourceFolderPath);
var testFilePath1 = Path.Combine(testEnv.SourceFolderPath, "test_basic_ut.py");
var testFilePath2 = Path.Combine(testEnv.SourceFolderPath, "test_syntax_error_ut.py");
var expectedTests = new[] {
new TestInfo("test_ut_fail", "test_basic_ut.py::TestClassUT::test_ut_fail", testFilePath1, 4),
new TestInfo("test_ut_pass", "test_basic_ut.py::TestClassUT::test_ut_pass", testFilePath1, 7),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFile(testFilePath1)
.WithTestFile(testFilePath2)
.ToXml()
);
var discoveryContext = new MockDiscoveryContext(runSettings);
var discoverySink = new MockTestCaseDiscoverySink();
var logger = new MockMessageLogger();
var discoverer = new UnittestTestDiscoverer();
discoverer.DiscoverTests(new[] { testFilePath1, testFilePath2 }, discoveryContext, logger, discoverySink);
var errors = string.Join(Environment.NewLine, logger.GetErrors());
if (Version.Version > PythonLanguageVersion.V27)
{
AssertUtil.Contains(errors,
"SyntaxError: invalid syntax"
);
}
else
{
Assert.Inconclusive("Python 2.7 unittest errors are not currently being printed to error logs");
}
}
public void DiscoverPytestUppercaseFileName()
{
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkPytest);
var testFilePath = Path.Combine(testEnv.SourceFolderPath, "test_Uppercase.py");
File.Copy(TestData.GetPath("TestData", "TestDiscoverer", "Uppercase", "test_Uppercase.py"), testFilePath);
var expectedTests = new[] {
new TestInfo("test_A", "test_Uppercase.py::Test_UppercaseClass::test_A", testFilePath, 4),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFilesFromFolder(testEnv.SourceFolderPath)
.ToXml()
);
DiscoverTests(testEnv, new[] { testFilePath }, runSettings, expectedTests);
}
public void DiscoverPytestWarnings()
{
// one file has a valid passing test,
// the other has an unknown module import at global scope
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkPytest);
FileUtils.CopyDirectory(TestData.GetPath("TestData", "TestDiscoverer", "Warnings"), testEnv.SourceFolderPath);
var testFilePath = Path.Combine(testEnv.SourceFolderPath, "test_warnings.py");
var expectedTests = new[] {
new TestInfo("test_A", "test_warnings.py::Test_WarnClass::test_A", testFilePath, 6),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFile(testFilePath)
.ToXml()
);
DiscoverTests(testEnv, new[] { testFilePath }, runSettings, expectedTests);
}
public void DiscoverPytest()
{
TestEnvironment testEnv = TestEnvironment.GetOrCreate(Version, FrameworkPytest);
var testFilePath = Path.Combine(testEnv.SourceFolderPath, "test_pt.py");
File.Copy(TestData.GetPath("TestData", "TestDiscoverer", "BasicPytest", "test_pt.py"), testFilePath);
TestInfo[] expectedTests = new[] {
new TestInfo("test_pt_pass", "test_pt.py::test_pt::test_pt_pass", testFilePath, 1),
new TestInfo("test_pt_fail", "test_pt.py::test_pt::test_pt_fail", testFilePath, 4),
new TestInfo("test_method_pass", "test_pt.py::TestClassPT::test_method_pass", testFilePath, 8),
};
MockRunSettings runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFilesFromFolder(testEnv.SourceFolderPath)
.ToXml()
);
DiscoverTests(testEnv, new[] { testFilePath }, runSettings, expectedTests);
}
public void DiscoverUnittestDecoratorsCorrectLineNumbers()
{
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkUnittest);
var testFilePath = Path.Combine(testEnv.SourceFolderPath, "test_decorators_ut.py");
File.Copy(TestData.GetPath("TestData", "TestDiscoverer", "Decorators", "test_decorators_ut.py"), testFilePath);
var expectedTests = new[] {
new TestInfo("test_ut_fail", "test_decorators_ut.py::TestClassDecoratorsUT::test_ut_fail", testFilePath, 5),
//bschnurr note: currently unittest/_discovery.py is returning decorators line number
new TestInfo("test_ut_pass", "test_decorators_ut.py::TestClassDecoratorsUT::test_ut_pass", testFilePath, 9),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFilesFromFolder(testEnv.SourceFolderPath)
.ToXml()
);
DiscoverTests(testEnv, new[] { testFilePath }, runSettings, expectedTests);
}
public void DiscoverUnittestDecoratorsIgnoreLineNumbers()
{
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkUnittest);
var testFilePath = Path.Combine(testEnv.SourceFolderPath, "test_decorators_ut.py");
File.Copy(TestData.GetPath("TestData", "TestDiscoverer", "Decorators", "test_decorators_ut.py"), testFilePath);
// disable line checking until we fix https://github.com/microsoft/PTVS/issues/5497
var expectedTests = new[] {
new TestInfo("test_ut_fail", "test_decorators_ut.py::TestClassDecoratorsUT::test_ut_fail", testFilePath, -1),
new TestInfo("test_ut_pass", "test_decorators_ut.py::TestClassDecoratorsUT::test_ut_pass", testFilePath, -1),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFilesFromFolder(testEnv.SourceFolderPath)
.ToXml()
);
DiscoverTests(testEnv, new[] { testFilePath }, runSettings, expectedTests);
}
public void DiscoverPytestConfigPythonFunctions()
{
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkPytest);
FileUtils.CopyDirectory(TestData.GetPath("TestData", "TestDiscoverer", "ConfigPythonFunctions"), testEnv.SourceFolderPath);
var testFilePath = Path.Combine(testEnv.SourceFolderPath, "test_misc_prefixes.py");
// pytest.ini declares that tests are only functions named check_* and verify_*
// so the test named test_* and example_* should not be discovered
var expectedTests = new[] {
new TestInfo("check_func", "test_misc_prefixes.py::test_misc_prefixes::check_func", testFilePath, 4),
new TestInfo("verify_func", "test_misc_prefixes.py::test_misc_prefixes::verify_func", testFilePath, 10),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFile(testFilePath)
.ToXml()
);
DiscoverTests(testEnv, new[] { testFilePath }, runSettings, expectedTests);
}
public void DiscoverPytestSyntaxErrorPartialResults()
{
// one file has a valid passing test,
// the other has a test with a syntax error in it
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkPytest);
FileUtils.CopyDirectory(TestData.GetPath("TestData", "TestDiscoverer", "SyntaxErrorPytest"), testEnv.SourceFolderPath);
var testFilePath1 = Path.Combine(testEnv.SourceFolderPath, "test_basic.py");
var testFilePath2 = Path.Combine(testEnv.SourceFolderPath, "test_syntax_error.py");
var expectedTests = new[] {
new TestInfo("test_success", "test_basic.py::test_basic::test_success", testFilePath1, 1),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFile(testFilePath1)
.WithTestFile(testFilePath2)
.ToXml()
);
DiscoverTests(testEnv, new[] { testFilePath1, testFilePath2 }, runSettings, expectedTests);
}
public void DiscoverUnitTestImportError()
{
// one file has a valid passing test,
// the other has an unknown module import at global scope
var testEnv = TestEnvironment.GetOrCreate(Version, FrameworkUnittest);
FileUtils.CopyDirectory(TestData.GetPath("TestData", "TestDiscoverer", "ImportErrorUnittest"), testEnv.SourceFolderPath);
var testFilePath1 = Path.Combine(testEnv.SourceFolderPath, "test_no_error.py");
var testFilePath2 = Path.Combine(testEnv.SourceFolderPath, "test_import_error.py");
var expectedTests = new[] {
new TestInfo("test_no_error", "test_no_error.py::NoErrorTests::test_no_error", testFilePath1, 4),
};
var runSettings = new MockRunSettings(
new MockRunSettingsXmlBuilder(testEnv.TestFramework, testEnv.InterpreterPath, testEnv.ResultsFolderPath, testEnv.SourceFolderPath)
.WithTestFile(testFilePath1)
.WithTestFile(testFilePath2)
.ToXml()
);
DiscoverTests(testEnv, new[] { testFilePath1, testFilePath2 }, runSettings, expectedTests);
}