From d64b5d6b09e82362dc181cfd815e2b3510410555 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 3 Jul 2012 21:35:14 +0200 Subject: [PATCH 001/183] Env tests moved to separate folder. --- .../jetbrains/env/PyEnvSufficiencyTest.java | 51 ++ .../jetbrains/env/PythonNoseTestingTest.java | 33 ++ .../jetbrains/env/PythonUnitTestingTest.java | 34 ++ .../env/django/DjangoEnvTestTask.java | 145 ++++++ .../jetbrains/env/django/DjangoPathTest.java | 124 +++++ .../django/DjangoTemplateBreakpointsTest.java | 64 +++ .../django/DjangoTemplateDebuggerTest.java | 345 +++++++++++++ .../env/python/IPythonConsoleTest.java | 65 +++ .../PyPackageRequirementsInspectionTest.java | 60 +++ .../jetbrains/env/python/PyPackagingTest.java | 220 ++++++++ .../env/python/PythonConsoleTest.java | 77 +++ .../env/python/PythonDebuggerTest.java | 474 ++++++++++++++++++ .../env/python/PythonDocTestingTest.java | 34 ++ .../env/python/PythonGeneratorTest.java | 24 + .../env/python/console/PyConsoleTask.java | 323 ++++++++++++ .../env/python/debug/PyBaseDebuggerTask.java | 292 +++++++++++ .../env/python/debug/PyDebuggerTask.java | 205 ++++++++ .../env/python/debug/PyEnvTestCase.java | 205 ++++++++ .../debug/PyExecutionFixtureTestTask.java | 137 +++++ .../python/debug/PyRemoteDebuggerTask.java | 242 +++++++++ .../env/python/debug/PyTestTask.java | 75 +++ .../com/jetbrains/env/ut/PyDocTestTask.java | 24 + .../com/jetbrains/env/ut/PyNoseTestTask.java | 32 ++ .../com/jetbrains/env/ut/PyUnitTestTask.java | 240 +++++++++ 24 files changed, 3525 insertions(+) create mode 100644 python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java create mode 100644 python/testSrc/com/jetbrains/env/PythonNoseTestingTest.java create mode 100644 python/testSrc/com/jetbrains/env/PythonUnitTestingTest.java create mode 100644 python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java create mode 100644 python/testSrc/com/jetbrains/env/django/DjangoPathTest.java create mode 100644 python/testSrc/com/jetbrains/env/django/DjangoTemplateBreakpointsTest.java create mode 100644 python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java create mode 100644 python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java create mode 100644 python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java create mode 100644 python/testSrc/com/jetbrains/env/python/PyPackagingTest.java create mode 100644 python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java create mode 100644 python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java create mode 100644 python/testSrc/com/jetbrains/env/python/PythonDocTestingTest.java create mode 100644 python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java create mode 100644 python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java create mode 100644 python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java create mode 100644 python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java create mode 100644 python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java create mode 100644 python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java create mode 100644 python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java create mode 100644 python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java create mode 100644 python/testSrc/com/jetbrains/env/ut/PyDocTestTask.java create mode 100644 python/testSrc/com/jetbrains/env/ut/PyNoseTestTask.java create mode 100644 python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java diff --git a/python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java b/python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java new file mode 100644 index 000000000000..741d5399d53b --- /dev/null +++ b/python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java @@ -0,0 +1,51 @@ +package com.jetbrains.env; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Lists; +import com.google.common.collect.Sets; +import com.intellij.openapi.util.SystemInfo; +import com.intellij.openapi.util.text.StringUtil; +import com.jetbrains.env.python.debug.PyEnvTestCase; + +import java.util.List; +import java.util.Set; + +/** + * @author traff + */ +public class PyEnvSufficiencyTest extends PyEnvTestCase { + private static final List BASE_TAGS = + ImmutableList.builder().add("python3", "django", "jython", "pypy", "ipython", "ipython011", "ipython012", "nose", "pytest").build(); + + public void testSufficiency() { + if (IS_UNDER_TEAMCITY && IS_ENV_CONFIGURATION) { + Set tags = Sets.newHashSet(); + List roots = getPythonRoots(); + if (roots.size() == 0) { + return; // not on env agent + } + for (String root : roots) { + tags.addAll(loadEnvTags(root)); + } + + List missing = Lists.newArrayList(); + for (String tag : necessaryTags()) { + if (!tags.contains(tag)) { + missing.add(tag); + } + } + + + assertEmpty("Agent is missing environments: " + StringUtil.join(missing, ", "), missing); + } + } + + private static List necessaryTags() { + if (SystemInfo.isWindows) { + return ImmutableList.builder().addAll(BASE_TAGS).add("iron").build(); + } + else { + return ImmutableList.builder().addAll(BASE_TAGS).add("packaging").build(); + } + } +} diff --git a/python/testSrc/com/jetbrains/env/PythonNoseTestingTest.java b/python/testSrc/com/jetbrains/env/PythonNoseTestingTest.java new file mode 100644 index 000000000000..7c90f7d7b11c --- /dev/null +++ b/python/testSrc/com/jetbrains/env/PythonNoseTestingTest.java @@ -0,0 +1,33 @@ +package com.jetbrains.env; + +import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.ut.PyNoseTestTask; + +/** + * User : catherine + */ +public class PythonNoseTestingTest extends PyEnvTestCase{ + public void testNoseRunner() { + runPythonTest(new PyNoseTestTask("/testRunner/env/nose", "test1.py") { + + @Override + public void after() { + assertEquals(3, allTestsCount()); + assertEquals(3, passedTestsCount()); + allTestsPassed(); + } + }); + } + + public void testNoseRunner2() { + runPythonTest(new PyNoseTestTask("/testRunner/env/nose", "test2.py") { + + @Override + public void after() { + assertEquals(8, allTestsCount()); + assertEquals(5, passedTestsCount()); + assertEquals(3, failedTestsCount()); + } + }); + } +} diff --git a/python/testSrc/com/jetbrains/env/PythonUnitTestingTest.java b/python/testSrc/com/jetbrains/env/PythonUnitTestingTest.java new file mode 100644 index 000000000000..528b3a848570 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/PythonUnitTestingTest.java @@ -0,0 +1,34 @@ +package com.jetbrains.env; + +import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.ut.PyUnitTestTask; +import junit.framework.Assert; + +/** + * @author traff + */ +public class PythonUnitTestingTest extends PyEnvTestCase{ + public void testUTRunner() { + runPythonTest(new PyUnitTestTask("/testRunner/env", "test1.py") { + + @Override + public void after() { + Assert.assertEquals(2, allTestsCount()); + Assert.assertEquals(2, passedTestsCount()); + allTestsPassed(); + } + }); + } + + public void testUTRunner2() { + runPythonTest(new PyUnitTestTask("/testRunner/env", "test2.py") { + + @Override + public void after() { + assertEquals(3, allTestsCount()); + assertEquals(1, passedTestsCount()); + assertEquals(2, failedTestsCount()); + } + }); + } +} diff --git a/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java new file mode 100644 index 000000000000..297f51d5d6ea --- /dev/null +++ b/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java @@ -0,0 +1,145 @@ +package com.jetbrains.env.django; + +import com.google.common.collect.ImmutableSet; +import com.intellij.openapi.module.Module; +import com.intellij.openapi.module.ModuleUtil; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.Ref; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.util.ui.UIUtil; +import com.jetbrains.django.facet.DjangoFacet; +import com.jetbrains.django.fixtures.DjangoTestCase; +import com.jetbrains.env.python.debug.PyDebuggerTask; +import com.jetbrains.python.PythonTestUtil; +import com.jetbrains.python.templateLanguages.TemplatesConfigurationsModel; +import com.jetbrains.python.templateLanguages.TemplatesService; +import org.junit.Assert; + +import java.net.URL; +import java.net.URLConnection; +import java.util.Scanner; +import java.util.Set; + +/** + * @author traff + */ +public class DjangoEnvTestTask extends PyDebuggerTask { + + protected final int myPort; + + protected String getTestDataPath() { + return PythonTestUtil.getTestDataPath() + "/django/debug"; + } + + public DjangoEnvTestTask(String workingFolder, String scriptName, String scriptParameters, int port) { + setWorkingFolder(getTestDataPath() + workingFolder); + setScriptName(scriptName); + setScriptParameters(scriptParameters + port); + myPort = port; + } + + @Override + public void setUp() throws Exception { + super.setUp(); + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + Module module = myFixture.getModule(); + if (module != null && !DjangoFacet.isPresent(module)) { + DjangoTestCase.addDjangoFacet(module); + TemplatesService.getInstance(module).setTemplateLanguage(TemplatesConfigurationsModel.DJANGO); + } + TemplatesService.getInstance(module).setTemplateLanguage(TemplatesConfigurationsModel.DJANGO); + } + }); + } + + @Override + public void tearDown() throws Exception { + TemplatesService.getInstance(myFixture.getModule()).setTemplateLanguage(TemplatesService.NONE); + super.tearDown(); + } + + public static void checkModuleForFile(Project project, VirtualFile vFile) { + Module module = ModuleUtil.findModuleForFile(vFile, project); + Assert.assertNotNull(module); //should be in our module for correct breakpoints setting + Assert.assertTrue(DjangoFacet.isPresent(module)); + } + + static class Response { + private final String content; + + + public Response(String content) { + this.content = content; + } + + public void contains(String string) { + Assert.assertTrue("Cant find '" + string + "' in content: \n" + content, content.contains(string)); + } + + public static Response load(String address) { + StringBuilder sb = new StringBuilder(); + try { + Thread.sleep(500); + // Send data + URL url = new URL(address); + URLConnection conn = url.openConnection(); + conn.setDoOutput(true); + conn.setConnectTimeout(0); + conn.setReadTimeout(0); + conn.setUseCaches(false); + + // Get the response + Scanner s = new Scanner(conn.getInputStream()); + + + while (s.hasNextLine()) { + String line = s.nextLine(); + sb.append(line + "\n"); + // Process line... + } + } + catch (Exception e) { + sb = new StringBuilder(e.getMessage()); + } + return new Response(sb.toString()); + } + } + + protected static LoadingPage loadPage(final String url) { + final Ref response = Ref.create(null); + + Thread thread = new Thread(new Runnable() { + @Override + public void run() { + response.set(Response.load("http://127.0.0.1:" + url)); + } + }); + thread.start(); + return new LoadingPage(thread, response); + } + + protected static class LoadingPage { + private Thread myThread; + private Ref myResponse; + + public LoadingPage(Thread thread, Ref response) { + myThread = thread; + myResponse = response; + } + + public void join() throws InterruptedException { + myThread.join(); + } + + public Response get() throws InterruptedException { + join(); + return myResponse.get(); + } + } + + @Override + public Set getTags() { + return ImmutableSet.of("django"); + } +} diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java new file mode 100644 index 000000000000..c4a681dbf9f5 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java @@ -0,0 +1,124 @@ +package com.jetbrains.env.django; + +import com.google.common.collect.Lists; +import com.intellij.execution.configurations.ConfigurationFactory; +import com.jetbrains.django.run.DjangoServerRunConfiguration; +import com.jetbrains.django.run.DjangoServerRunConfigurationType; +import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; +import com.jetbrains.django.testRunner.DjangoTestsRunConfiguration; +import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.python.PythonHelpersLocator; +import com.jetbrains.python.run.AbstractPythonRunConfiguration; +import org.jetbrains.annotations.Nullable; + +import java.io.IOException; +import java.util.ArrayList; + +/** + * User : catherine + */ +public class DjangoPathTest extends PyEnvTestCase { + + public void testRunserverPath() throws IOException { + runPythonTest(new DjangoPathTestTask() { + + @Override + protected void configure(AbstractPythonRunConfiguration config) throws IOException { + final int[] ports = DjangoTemplateDebuggerTest.findFreePorts(2); + ((DjangoServerRunConfiguration)config).setPort(ports[1]); + } + + @Override + public ConfigurationFactory getFactory() { + return DjangoServerRunConfigurationType.getInstance().getConfigurationFactories()[0]; + } + + + public void testing() throws Exception { + waitForOutput("Development server is running"); + + final String[] splittedOutput = output().split("\\n"); + final ArrayList outputList = Lists.newArrayList(); + for (String s : splittedOutput) { + if (s.equals("The end of sys.path")) + break; + outputList.add(s); + } + + assertEquals(getTestDataPath(), outputList.get(1)); + assertTrue(outputList.contains(PythonHelpersLocator.getHelpersRoot().getPath())); + assertEquals(outputList.indexOf(PythonHelpersLocator.getHelpersRoot().getPath()), + outputList.lastIndexOf(PythonHelpersLocator.getHelpersRoot().getPath())); + assertEquals(outputList.indexOf(getTestDataPath()), + outputList.lastIndexOf(getTestDataPath())); + } + + }); + + } + + public void testTestPath() throws IOException { + runPythonTest(new DjangoPathTestTask() { + + @Override + public ConfigurationFactory getFactory() { + return DjangoTestsConfigurationType.getInstance().getConfigurationFactories()[0]; + } + + @Override + protected void configure(AbstractPythonRunConfiguration config) { + ((DjangoTestsRunConfiguration)config).setTarget("site.SimpleTest"); + } + + public void testing() throws Exception { + waitForOutput("The end of sys.path"); + final String[] splittedOutput = output().split("\\n"); + final ArrayList outputList = Lists.newArrayList(); + for (String s : splittedOutput) { + if (s.equals("The end of sys.path")) + break; + outputList.add(s); + } + + assertEquals(getTestDataPath(), outputList.get(1)); + assertTrue(outputList.contains(PythonHelpersLocator.getHelpersRoot().getPath())); + assertEquals(outputList.indexOf(PythonHelpersLocator.getHelpersRoot().getPath()), + outputList.lastIndexOf(PythonHelpersLocator.getHelpersRoot().getPath())); + assertEquals(outputList.indexOf(getTestDataPath()), + outputList.lastIndexOf(getTestDataPath())); + } + }); + + } + + public void testManagePath() throws IOException { + runPythonTest(new DjangoPathTestTask() { + + @Nullable + @Override + public ConfigurationFactory getFactory() { + return null; + } + + public void testing() throws Exception { + waitForOutput("The end of sys.path"); + + final String[] splittedOutput = output().split("\\n"); + final ArrayList outputList = Lists.newArrayList(); + for (String s : splittedOutput) { + if (s.equals("The end of sys.path")) + break; + outputList.add(s); + } + + assertEquals(getTestDataPath(), outputList.get(1)); + assertTrue(outputList.contains(PythonHelpersLocator.getHelperPath("pycharm/"))); + assertEquals(outputList.indexOf(PythonHelpersLocator.getHelperPath("pycharm/")), + outputList.lastIndexOf(PythonHelpersLocator.getHelperPath("pycharm/"))); + assertEquals(outputList.indexOf(getTestDataPath()), + outputList.lastIndexOf(getTestDataPath())); + } + }); + + } +} diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTemplateBreakpointsTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTemplateBreakpointsTest.java new file mode 100644 index 000000000000..db7e75668733 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/django/DjangoTemplateBreakpointsTest.java @@ -0,0 +1,64 @@ +package com.jetbrains.env.django; + +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.testFramework.fixtures.CodeInsightTestFixture; +import com.intellij.xdebugger.XDebuggerUtil; +import com.jetbrains.django.fixtures.DjangoTestCase; +import com.jetbrains.python.PythonTestUtil; +import junit.framework.Assert; + +/** + * @author traff + */ +public class DjangoTemplateBreakpointsTest extends DjangoTestCase { + @Override + protected String getTestDataPath() { + return PythonTestUtil.getTestDataPath() + "/django/debug/"; + } + + public void testCanSetBreakpoints() { + prepareProject("djangoDebug"); + inFile("djangoDebug/templates/test1.html") + .notCan(0) + .notCan(1) + .notCan(2) + .can(3) + .notCan(4) + .can(5) + .can(6) + .notCan(7) + .can(8) + .can(9) + .notCan(10) + .notCan(11) + .notCan(12); + } + + private OpenedTemplate inFile(String fileName) { + return new OpenedTemplate(fileName, myFixture); + } + + private static class OpenedTemplate { + private String myFile; + private CodeInsightTestFixture myFixture; + + private OpenedTemplate(String file, CodeInsightTestFixture fixture) { + myFile = file; + myFixture = fixture; + } + + private OpenedTemplate can(int line) { + Assert.assertTrue("at line " + line, XDebuggerUtil.getInstance().canPutBreakpointAt(myFixture.getProject(), findFile(), line)); + return this; + } + + private VirtualFile findFile() { + return myFixture.findFileInTempDir(myFile); + } + + private OpenedTemplate notCan(int line) { + Assert.assertFalse("at line " + line, XDebuggerUtil.getInstance().canPutBreakpointAt(myFixture.getProject(), findFile(), line)); + return this; + } + } +} diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java new file mode 100644 index 000000000000..d238026a3f53 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java @@ -0,0 +1,345 @@ +package com.jetbrains.env.django; + +import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; +import com.intellij.xdebugger.XDebuggerTestUtil; +import com.jetbrains.django.util.VirtualFileUtil; +import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.python.debugger.django.DjangoExceptionBreakpointProperties; +import com.jetbrains.python.debugger.django.DjangoExceptionBreakpointType; + +import java.io.IOException; +import java.net.ServerSocket; + +/** + * @author traff + */ +public class DjangoTemplateDebuggerTest extends PyEnvTestCase { + + public void testBreakpointStopAndEval() throws IOException { + final int[] ports = findFreePorts(2); + runPythonTest(new BreakpointStopAndEvalTask("/djangoDebug", "manage.py", "runserver --noreload ", ports[1])); + } + + private static class BreakpointStopAndEvalTask extends DjangoEnvTestTask { + public BreakpointStopAndEvalTask(String workingFolder, String scriptName, String scriptParameters, int port) { + super(workingFolder, scriptName, scriptParameters, port); + } + + @Override + public void before() throws Exception { + //setShouldPrintOutput(true); + String file = getFilePath("/templates/test1.html"); + checkModuleForFile(getProject(), VirtualFileUtil.findFile(file)); + + toggleBreakpoint(file, 6); + } + + @Override + public void testing() throws Exception { + waitForOutput("Development server is running"); + + DjangoEnvTestTask.LoadingPage page = loadPage(myPort + "/test1"); + + waitForPause(); + + eval("x").hasValue("1"); + + resume(); + + waitForPause(); + + eval("x").hasValue("2"); + + resume(); + + waitForPause(); + + eval("x").hasValue("3"); + + resume(); + + page.get().contains("TemplateDebugging"); + } + } + + public void testSetVal() throws IOException { +//setShouldPrintOutput(true); + final int[] ports = findFreePorts(2); + runPythonTest(new DjangoEnvTestTask("/djangoDebug", "manage.py", "runserver --noreload ", ports[1]) { + @Override + public void before() throws Exception { + String file = getFilePath("/templates/test1.html"); + checkModuleForFile(getProject(), VirtualFileUtil.findFile(file)); + + toggleBreakpoint(file, 6); + } + + @Override + public void testing() throws Exception { + waitForOutput("Development server is running"); + + LoadingPage page = loadPage(myPort + "/test1"); + + waitForPause(); + + eval("x").hasValue("1"); + eval("name").hasValue("'TemplateDebugging'"); + + setVal("name", "'TemplateDjangoDebugging'"); + + resume(); + + waitForPause(); + + eval("x").hasValue("2"); + eval("name").hasValue("'TemplateDjangoDebugging'"); + + resume(); + + waitForPause(); + + eval("x").hasValue("3"); + eval("name").hasValue("'TemplateDjangoDebugging'"); + + resume(); + + page.get().contains("templatedjangodebugging"); + } + }); + } + + public void testVariableDoesNotExistExceptionBreak() throws IOException { +//setShouldPrintOutput(true); + final int[] ports = findFreePorts(2); + runPythonTest(new DjangoEnvTestTask("/djangoDebug", "manage.py", "runserver --noreload ", ports[1]) { + @Override + public void before() throws Exception { + addDjangoExceptionBreakpoint(myFixture); + } + + @Override + public void testing() throws Exception { + waitForOutput("Development server is running"); + + LoadingPage page = loadPage(myPort + "/test2"); + + waitForPause(); + + eval("x").hasValue("1"); + eval("name").hasValue("'TemplateDebugging'"); + + setVal("name", "'TemplateDjangoDebugging'"); + + resume(); + + waitForPause(); + + eval("x").hasValue("2"); + eval("name").hasValue("'TemplateDjangoDebugging'"); + + resume(); + + waitForPause(); + + eval("x").hasValue("3"); + eval("name").hasValue("'TemplateDjangoDebugging'"); + + resume(); + + page.get().contains("templatedjangodebugging"); + } + }); + } + + public void testTemplateDoseNotExistsExceptionBreak() throws IOException { +//setShouldPrintOutput(true); + final int[] ports = findFreePorts(2); + runPythonTest(new DjangoEnvTestTask("/djangoDebug", "manage.py", "runserver --noreload ", ports[1]) { + @Override + public void before() throws Exception { + addDjangoExceptionBreakpoint(myFixture); + } + + @Override + public void testing() throws Exception { + waitForOutput("Development server is running"); + + LoadingPage page = loadPage(myPort + "/test3"); + + waitForPause(); + + resume(); + + page.get().contains("Server returned HTTP response code: 500"); + } + }); + } + + public void testConditionalBreakpointStop() throws IOException { + + final int[] ports = findFreePorts(2); + runPythonTest(new DjangoEnvTestTask("/djangoDebug", "manage.py", "runserver --noreload ", ports[1]) { + @Override + public void before() throws Exception { + //setShouldPrintOutput(true); + String file = getFilePath("/templates/test1.html"); + checkModuleForFile(getProject(), VirtualFileUtil.findFile(file)); + + toggleBreakpoint(file, 6); + XDebuggerTestUtil.setBreakpointCondition(getProject(), 6, "x == 1 or x == 3"); + } + + @Override + public void testing() throws Exception { + waitForOutput("Development server is running"); + + LoadingPage page = loadPage(myPort + "/test1"); + + waitForPause(); + + eval("x").hasValue("1"); + + resume(); + + waitForPause(); + + eval("x").hasValue("3"); + + resume(); + + page.get().contains("TemplateDebugging"); + } + }); + } + + public void testBreakpointStopAndStepOver() throws IOException { + + final int[] ports = findFreePorts(2); + runPythonTest(new DjangoEnvTestTask("/djangoDebug", "manage.py", "runserver --noreload ", ports[1]) { + @Override + public void before() throws Exception { + //setShouldPrintOutput(true); + String file = getFilePath("/templates/test4.html"); + checkModuleForFile(getProject(), VirtualFileUtil.findFile(file)); + + toggleBreakpoint(file, 6); + } + + @Override + public void testing() throws Exception { + waitForOutput("Development server is running"); + + loadPage(ports[1] + "/test4"); + + waitForPause(); + + eval("x").hasValue("1"); + + stepOver(); + + waitForPause(); + + stepOver(); + + waitForPause(); + + eval("y").hasValue("1"); + + resume(); + } + }); + } + + public void testBreakpointLogExpression() throws IOException { + + final int[] ports = findFreePorts(2); + runPythonTest(new DjangoEnvTestTask("/djangoDebug", "manage.py", "runserver --noreload ", ports[1]) { + @Override + public void before() throws Exception { + //setShouldPrintOutput(true); + String file = getFilePath("/templates/test1.html"); + checkModuleForFile(getProject(), VirtualFileUtil.findFile(file)); + + toggleBreakpoint(file, 6); + XDebuggerTestUtil.setBreakpointLogExpression(getProject(), 6, "'x = %d'%x"); + } + + @Override + public void testing() throws Exception { + waitForOutput("Development server is running"); + + loadPage(ports[1] + "/test1"); + + waitForPause(); + resume(); + waitForOutput("x = 2"); + } + }); + } + + + public void testStepInto() throws IOException { + + final int[] ports = findFreePorts(2); + runPythonTest(new DjangoEnvTestTask("/djangoDebug", "manage.py", "runserver --noreload ", ports[1]) { + @Override + public void before() throws Exception { + //setShouldPrintOutput(true); + String file = getFilePath("/templates/test5.html"); + checkModuleForFile(getProject(), VirtualFileUtil.findFile(file)); + + toggleBreakpoint(file, 5); + } + + @Override + public void testing() throws Exception { + waitForOutput("Development server is running"); + + loadPage(ports[1] + "/test5"); + + waitForPause(); + stepInto(); + waitForPause(); + stepOver(); + waitForPause(); + + eval("res").hasValue("'Result'"); + stepOver(); + waitForPause(); + eval("name").hasValue("'TemplateDebugging5'"); + } + }); + } + + private static void addDjangoExceptionBreakpoint(IdeaProjectTestFixture fixture) { + XDebuggerTestUtil.addBreakpoint(fixture.getProject(), DjangoExceptionBreakpointType.class, new DjangoExceptionBreakpointProperties()); + } + + public static int[] findFreePorts(int count) + throws IOException { + ServerSocket[] servers = new ServerSocket[count]; + int[] port = new int[count]; + + for (int i = 0; i < count; i++) { + servers[i] = new ServerSocket(0); + port[i] = servers[i].getLocalPort(); + } + + for (int i = 0; i < count; i++) { + servers[i].close(); + } + + return port; + } + + + public void testBreakpointStopAndEvalInAutoReloadMode() throws IOException { + final int[] ports = findFreePorts(4); + BreakpointStopAndEvalTask testTask = new BreakpointStopAndEvalTask("/djangoDebug", "manage.py", "runserver ", ports[3]); + //testTask.setShouldPrintOutput(true); + testTask.setMultiprocessDebug(true); + runPythonTest(testTask); + } +} + + diff --git a/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java new file mode 100644 index 000000000000..14346bc90dbf --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java @@ -0,0 +1,65 @@ +package com.jetbrains.env.python; + +import com.google.common.collect.ImmutableSet; +import com.intellij.psi.PsiDocumentManager; +import com.intellij.psi.PsiFile; +import com.intellij.psi.util.PsiTreeUtil; +import com.jetbrains.env.python.console.PyConsoleTask; +import com.jetbrains.env.python.debug.PyEnvTestCase; + +import java.util.Set; + +/** + * @author traff + */ +public class IPythonConsoleTest extends PyEnvTestCase { + public void testQuestion() throws Exception { + runPythonTest(new IPythonTask() { + @Override + public void testing() throws Exception { + exec("import multiprocessing"); + exec("multiprocessing?"); + waitForOutput("Base Class: "); + } + }); + } + + public void testParsing() throws Exception { + runPythonTest(new IPythonTask() { + @Override + public void testing() throws Exception { + waitForReady(); + addTextToEditor("sys?"); + PsiFile psi = + PsiDocumentManager.getInstance(getProject()).getPsiFile(getConsoleView().getLanguageConsole().getConsoleEditor().getDocument()); + assertFalse(PsiTreeUtil.hasErrorElements(psi)); + } + }); + } + + public void testParsingNoIPython() throws Exception { + runPythonTest(new IPythonTask() { + @Override + public void testing() throws Exception { + waitForReady(); + addTextToEditor("sys?"); + PsiFile psi = + PsiDocumentManager.getInstance(getProject()).getPsiFile(getConsoleView().getLanguageConsole().getConsoleEditor().getDocument()); + //TreeUtil.ensureParsed(psi.getNode()); + assertTrue(PsiTreeUtil.hasErrorElements(psi)); + } + + @Override + public Set getTags() { + return ImmutableSet.of("-ipython"); + } + }); + } + + private static class IPythonTask extends PyConsoleTask { + @Override + public Set getTags() { + return ImmutableSet.of("ipython"); + } + } +} diff --git a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java new file mode 100644 index 000000000000..5285968e4ec5 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java @@ -0,0 +1,60 @@ +package com.jetbrains.env.python; + +import com.intellij.openapi.module.Module; +import com.intellij.openapi.module.ModuleManager; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.roots.ModuleRootModificationUtil; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.testFramework.PsiTestUtil; +import com.intellij.util.Processor; +import com.jetbrains.python.fixtures.PyTestCase; +import com.jetbrains.python.inspections.PyPackageRequirementsInspection; +import org.jetbrains.annotations.NotNull; + +import java.io.File; + +/** + * @author vlan + */ +public class PyPackageRequirementsInspectionTest extends PyTestCase { + public void testPartiallySatisfiedRequirementsTxt() { + doTest("test1.py"); + } + + public void testPartiallySatisfiedSetupPy() { + doTest("test1.py"); + } + + public void testImportsNotInRequirementsTxt() { + doTest("test1.py"); + } + + private void doTest(@NotNull final String filename) { + final String dir = String.format("inspections/PyPackageRequirementsInspection/%s", getTestName(false)); + myFixture.enableInspections(PyPackageRequirementsInspection.class); + PyPackagingTest.forAllPythonEnvs(getTestName(false), new Processor() { + @Override + public boolean process(Sdk sdk) { + final String perSdkDir = Integer.toHexString(System.identityHashCode(sdk)); + final VirtualFile root = myFixture.copyDirectoryToProject(dir, perSdkDir); + assertNotNull(root); + setupModuleSdk(getSingleModule(myFixture.getProject()), sdk, root); + myFixture.testHighlighting(true, true, true, perSdkDir + File.separator + filename); + return true; + } + }); + } + + @NotNull + private static Module getSingleModule(@NotNull Project project) { + Module[] modules = ModuleManager.getInstance(project).getModules(); + assertEquals(1, modules.length); + return modules[0]; + } + + private static void setupModuleSdk(@NotNull Module module, @NotNull Sdk sdk, @NotNull VirtualFile root) { + ModuleRootModificationUtil.setModuleSdk(module, sdk); + PsiTestUtil.addContentRoot(module, root); + } +} diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java new file mode 100644 index 000000000000..b1528ea5ec7f --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -0,0 +1,220 @@ +package com.jetbrains.env.python; + +import com.google.common.collect.Sets; +import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil; +import com.intellij.openapi.util.SystemInfo; +import com.intellij.openapi.util.io.FileUtil; +import com.intellij.openapi.vfs.LocalFileSystem; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.util.Processor; +import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.python.fixtures.PyTestCase; +import com.jetbrains.python.packaging.PyExternalProcessException; +import com.jetbrains.python.packaging.PyPackage; +import com.jetbrains.python.packaging.PyPackageManager; +import com.jetbrains.python.packaging.PyRequirement; +import com.jetbrains.python.sdk.PythonSdkType; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.io.File; +import java.io.IOException; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +/** + * @author vlan + */ +public class PyPackagingTest extends PyTestCase { + private static final Logger LOG = Logger.getInstance(PyEnvTestCase.class.getName()); + + public void testGetPackages() { + forAllPythonEnvs(getTestName(false), new Processor() { + @Override + public boolean process(Sdk sdk) { + List packages = null; + try { + packages = PyPackageManager.getInstance(sdk).getPackages(); + } + catch (PyExternalProcessException e) { + final int retcode = e.getRetcode(); + if (retcode != PyPackageManager.ERROR_NO_PIP && retcode != PyPackageManager.ERROR_NO_DISTRIBUTE) { + fail(String.format("Error for interpreter '%s': %s", sdk.getHomePath(), e.getMessage())); + } + } + if (packages != null) { + assertTrue(packages.size() > 0); + for (PyPackage pkg : packages) { + assertTrue(pkg.getName().length() > 0); + } + } + return true; + } + }); + } + + public void testCreateVirtualEnv() { + forAllPythonEnvs(getTestName(false), new Processor() { + @Override + public boolean process(Sdk sdk) { + try { + final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); + final String venvSdkHome = PyPackageManager.getInstance(sdk).createVirtualEnv(tempDir.toString(), false); + final Sdk venvSdk = createTempSdk(venvSdkHome); + assertNotNull(venvSdk); + assertTrue(PythonSdkType.isVirtualEnv(venvSdk)); + final List packages = PyPackageManager.getInstance(venvSdk).getPackages(); + final PyPackage distribute = findPackage("distribute", packages); + assertNotNull(distribute); + assertEquals("distribute", distribute.getName()); + assertEquals("0.6.24", distribute.getVersion()); + final PyPackage pip = findPackage("pip", packages); + assertNotNull(pip); + assertEquals("pip", pip.getName()); + assertEquals("1.0.2", pip.getVersion()); + } + catch (IOException e) { + throw new RuntimeException(e); + } + catch (PyExternalProcessException e) { + fail(String.format("Error for interpreter '%s': %s", sdk.getHomePath(), e.getMessage())); + } + return true; + } + }); + } + + public void testInstallPackage() { + forAllPythonEnvs(getTestName(false), new Processor() { + @Override + public boolean process(final Sdk sdk) { + try { + final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); + final String venvSdkHome = PyPackageManager.getInstance(sdk).createVirtualEnv(tempDir.getPath(), false); + final Sdk venvSdk = createTempSdk(venvSdkHome); + assertNotNull(venvSdk); + final PyPackageManager manager = PyPackageManager.getInstance(venvSdk); + final List packages1 = manager.getPackages(); + // TODO: Install Markdown from a local file + manager.install(list(PyRequirement.fromString("Markdown<2.2"), + new PyRequirement("httplib2")), Collections.emptyList()); + final List packages2 = manager.getPackages(); + final PyPackage markdown2 = findPackage("Markdown", packages2); + assertNotNull(markdown2); + assertTrue(markdown2.isInstalled()); + final PyPackage pip1 = findPackage("pip", packages1); + assertNotNull(pip1); + assertEquals("pip", pip1.getName()); + assertEquals("1.0.2", pip1.getVersion()); + manager.uninstall(list(pip1)); + final List packages3 = manager.getPackages(); + final PyPackage pip2 = findPackage("pip", packages3); + assertNull(pip2); + } + catch (PyExternalProcessException e) { + fail(String.format("Error for interpreter '%s': %s", sdk.getHomePath(), e.getMessage())); + } + catch (IOException e) { + throw new RuntimeException(e); + } + return true; + } + }); + } + + public void testParseRequirement() { + assertEquals(new PyRequirement("Django"), PyRequirement.fromString("Django")); + assertEquals(new PyRequirement("django"), PyRequirement.fromString("django")); + assertEquals(new PyRequirement("Django", "1.3.1"), PyRequirement.fromString("Django==1.3.1")); + assertEquals(new PyRequirement("Django", list(new PyRequirement.VersionSpec(PyRequirement.Relation.LT, "1.4"))), + PyRequirement.fromString(" Django < 1.4 ")); + assertEquals(new PyRequirement("Django", list(new PyRequirement.VersionSpec(PyRequirement.Relation.LT, "1.4"), + new PyRequirement.VersionSpec(PyRequirement.Relation.GTE, "1.3.1"))), + PyRequirement.fromString(" Django < 1.4 , >= 1.3.1 ")); + assertEquals(null, PyRequirement.fromString("-e lib/django")); + assertEquals(new PyRequirement("django", null, "svn+http://code.djangoproject.com/svn/django/trunk@17672", true), + PyRequirement.fromString("-e svn+http://code.djangoproject.com/svn/django/trunk@17672#egg=django")); + assertEquals(new PyRequirement("django-haystack", "dev", "git://github.com/toastdriven/django-haystack.git@4fb267623b58", true), + PyRequirement.fromString("-e git://github.com/toastdriven/django-haystack.git@4fb267623b58#egg=django_haystack-dev")); + assertEquals(list(new PyRequirement("django", "1.3"), new PyRequirement("foo")), + PyRequirement.parse("# This is a comment\n" + + "django==1.3\n" + + "--index-url http://example.com/\n" + + "foo\n")); + // PY-6328 + assertEquals(new PyRequirement("django-haystack", "dev", "git://github.com/toastdriven/django-haystack.git@4fb267623b58", false), + PyRequirement.fromString("git://github.com/toastdriven/django-haystack.git@4fb267623b58#egg=django_haystack-dev")); + } + + // PY-6355 + public void testTrailingZeroesInVersion() { + final PyRequirement req080 = PyRequirement.fromString("foo==0.8.0"); + final PyPackage pack08 = new PyPackage("foo", "0.8", null, Collections.emptyList()); + assertNotNull(req080); + assertTrue(req080.match(list(pack08)) != null); + } + + // PY-6438 + public void testUnderscoreMatchesDash() { + final PyRequirement req = PyRequirement.fromString("pyramid_zcml"); + final PyPackage pkg = new PyPackage("pyramid-zcml", "0.1", null, Collections.emptyList()); + assertNotNull(req); + assertTrue(req.match(list(pkg)) != null); + } + + @Nullable + private static PyPackage findPackage(String name, List packages) { + for (PyPackage pkg : packages) { + if (name.equals(pkg.getName())) { + return pkg; + } + } + return null; + } + + public static void forAllPythonEnvs(@NotNull String testName, @NotNull Processor processor) { + final List roots = PyEnvTestCase.getPythonRoots(); + + if (PyEnvTestCase.notEnvConfiguration()) { + LOG.info("Running under teamcity but not by Env configuration. Skipping."); + return; + } + + if (PyEnvTestCase.IS_UNDER_TEAMCITY && SystemInfo.isWindows) { + return; //Don't run under Windows as after deleting from created virtualenvs original interpreter got spoiled + } + + if (roots.size() == 0) { + String msg = testName + ": environments are not defined. Skipping."; + LOG.warn(msg); + System.out.println(msg); + return; + } + for (String root : roots) { + if (!PyEnvTestCase.isSuitableForTags(PyEnvTestCase.loadEnvTags(root), Sets.newHashSet("packaging"))) { + continue; // Run only on special test-envs as because of downloading packages on every run is is too heavy to run it on all envs + } + final String sdkHome = PythonSdkType.getPythonExecutable(root); + assertNotNull(sdkHome); + final Sdk sdk = createTempSdk(sdkHome); + assertNotNull(sdk); + processor.process(sdk); + } + } + + @Nullable + private static Sdk createTempSdk(@NotNull String sdkHome) { + final VirtualFile binary = LocalFileSystem.getInstance().findFileByPath(sdkHome); + if (binary != null) { + return SdkConfigurationUtil.setupSdk(new Sdk[0], binary, PythonSdkType.getInstance(), true, null, null); + } + return null; + } + + private static List list(T... xs) { + return Arrays.asList(xs); + } +} diff --git a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java new file mode 100644 index 000000000000..f9fcf52220df --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java @@ -0,0 +1,77 @@ +package com.jetbrains.env.python; + +import com.google.common.collect.ImmutableSet; +import com.jetbrains.env.python.console.PyConsoleTask; +import com.jetbrains.env.python.debug.PyEnvTestCase; +import org.junit.Assert; + +import java.util.Set; + +/** + * @author traff + */ +public class PythonConsoleTest extends PyEnvTestCase { + public void testConsolePrint() throws Exception { + runPythonTest(new PyConsoleTask() { + @Override + public void testing() throws Exception { + exec("x = 96"); + exec("x += 1"); + exec("print(1)"); + exec("print(x)"); + waitForOutput("97"); + } + }); + } + + public void testExecuteMultiline() throws Exception { //PY-4329 + runPythonTest(new PyConsoleTask() { + @Override + public void testing() throws Exception { + exec("if True:\n" + + " x=1\n" + + "y=x+100\n" + + "for i in range(1):\n" + + " print(y)"); + waitForOutput("101"); + } + }); + } + + public void testInterruptAsync() throws Exception { + runPythonTest(new PyConsoleTask() { + @Override + public void testing() throws Exception { + exec("import time"); + execNoWait("for i in range(10000):\n" + + " print(i)\n" + + " time.sleep(0.1)"); + waitForOutput("3\n4\n5"); + Assert.assertFalse(canExecuteNow()); + interrupt(); + waitForFinish(); + waitForReady(); + } + + @Override + public Set getTags() { + return new ImmutableSet.Builder().addAll(super.getTags()).add("-iron").build(); + } + }); + } + + public void testLineByLineInput() throws Exception { + runPythonTest(new PyConsoleTask() { + @Override + public void testing() throws Exception { + exec("x = 96"); + exec("x +=1"); + exec("if True:"); + exec(""); + exec(" print(x)"); + exec(""); + waitForOutput("97"); + } + }); + } +} diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java new file mode 100644 index 000000000000..416b7cdca7e7 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -0,0 +1,474 @@ +package com.jetbrains.env.python; + +import com.google.common.collect.ImmutableSet; +import com.intellij.openapi.application.PathManager; +import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; +import com.intellij.xdebugger.XDebuggerTestUtil; +import com.jetbrains.env.python.debug.PyDebuggerTask; +import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.ut.PyUnitTestTask; +import com.jetbrains.python.console.pydev.PydevCompletionVariant; +import com.jetbrains.python.debugger.PyExceptionBreakpointProperties; +import com.jetbrains.python.debugger.PyExceptionBreakpointType; + +import java.util.List; +import java.util.Set; + +/** + * @author traff + */ +public class PythonDebuggerTest extends PyEnvTestCase { + public void testBreakpointStopAndEval() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test1.py") { + @Override + public void before() throws Exception { + toggleBreakpoint(getScriptPath(), 3); + } + + @Override + public void testing() throws Exception { + waitForPause(); + + eval("i").hasValue("0"); + + resume(); + + waitForPause(); + + eval("i").hasValue("1"); + + resume(); + + waitForPause(); + + eval("i").hasValue("2"); + } + }); + } + + public void testDebugger() { + runPythonTest(new PyUnitTestTask("", "test_debug.py") { + @Override + protected String getTestDataPath() { + return PathManager.getHomePath() + "/python/helpers/pydev"; + } + + @Override + public void after() { + allTestsPassed(); + } + }); + } + + public void testConditionalBreakpoint() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test1.py") { + @Override + public void before() throws Exception { + toggleBreakpoint(getScriptPath(), 3); + XDebuggerTestUtil.setBreakpointCondition(getProject(), 3, "i == 1 or i == 11 or i == 111"); + } + + @Override + public void testing() throws Exception { + waitForPause(); + + eval("i").hasValue("1"); + + resume(); + + waitForPause(); + + eval("i").hasValue("11"); + + resume(); + + waitForPause(); + + eval("i").hasValue("111"); + } + }); + } + + public void testDebugConsole() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test1.py") { + @Override + public void before() throws Exception { + toggleBreakpoint(getScriptPath(), 3); + } + + @Override + public void testing() throws Exception { + waitForPause(); + + eval("i").hasValue("0"); + + resume(); + + waitForPause(); + + myDebugProcess.consoleExec("'i=%d'%i"); + + waitForOutput("'i=1'"); + + myDebugProcess.consoleExec("x"); + + waitForOutput("name 'x' is not defined"); + + myDebugProcess.consoleExec("1-;"); + + waitForOutput("SyntaxError"); + + resume(); + } + }); + } + + public void testDebugCompletion() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test4.py") { + @Override + public void before() throws Exception { + toggleBreakpoint(getScriptPath(), 3); + } + + @Override + public void testing() throws Exception { + waitForPause(); + + List list = myDebugProcess.getCompletions("xvalu"); + assertEquals(2, list.size()); + } + }); + } + + public void testBreakpointLogExpression() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test1.py") { + @Override + public void before() throws Exception { + toggleBreakpoint(getScriptPath(), 3); + XDebuggerTestUtil.setBreakpointLogExpression(getProject(), 3, "'i = %d'%i"); + } + + @Override + public void testing() throws Exception { + waitForPause(); + resume(); + waitForOutput("i = 1"); + } + }); + } + + public void testStepOver() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test2.py") { + @Override + public void before() throws Exception { + toggleBreakpoint(getScriptPath(), 5); + } + + @Override + public void testing() throws Exception { + waitForPause(); + stepOver(); + waitForPause(); + stepOver(); + waitForPause(); + eval("z").hasValue("2"); + } + }); + } + + public void testStepInto() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test2.py") { + @Override + public void before() throws Exception { + toggleBreakpoint(getScriptPath(), 5); + } + + @Override + public void testing() throws Exception { + waitForPause(); + stepInto(); + waitForPause(); + eval("x").hasValue("1"); + stepOver(); + waitForPause(); + eval("y").hasValue("3"); + stepOver(); + waitForPause(); + eval("z").hasValue("1"); + } + }); + } + + public void testSmartStepInto() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test3.py") { + @Override + public void before() throws Exception { + toggleBreakpoint(getScriptPath(), 14); + } + + @Override + public void testing() throws Exception { + waitForPause(); + smartStepInto("foo"); + waitForPause(); + stepOver(); + waitForPause(); + eval("y").hasValue("4"); + } + }); + } + + public void testSmartStepInto2() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test3.py") { + @Override + public void before() throws Exception { + toggleBreakpoint(getScriptPath(), 18); + toggleBreakpoint(getScriptPath(), 25); + } + + @Override + public void testing() throws Exception { + waitForPause(); + toggleBreakpoint(getScriptPath(), 18); + smartStepInto("foo"); + waitForPause(); + eval("a.z").hasValue("1"); + } + }); + } + + public void testInput() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test_input.py") { + @Override + public void before() throws Exception { + } + + @Override + public void testing() throws Exception { + waitForOutput("print command >"); + input("GO!"); + waitForOutput("command was GO!"); + } + }); + } + + public void testRunToLine() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test_runtoline.py") { + @Override + public void before() throws Exception { + toggleBreakpoint(getScriptPath(), 1); + toggleBreakpoint(getScriptPath(), 7); + } + + @Override + public void testing() throws Exception { + waitForPause(); + eval("x").hasValue("0"); + runToLine(4); + eval("x").hasValue("1"); + resume(); + waitForPause(); + eval("x").hasValue("12"); + resume(); + + waitForOutput("x = 12"); + } + }); + } + + + private static void addExceptionBreakpoint(IdeaProjectTestFixture fixture, PyExceptionBreakpointProperties properties) { + XDebuggerTestUtil.addBreakpoint(fixture.getProject(), PyExceptionBreakpointType.class, properties); + } + + public void testExceptionBreakpointOnTerminate() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test_exceptbreak.py") { + @Override + public void before() throws Exception { + createExceptionBreak(myFixture, true, false, false); + } + + @Override + public void testing() throws Exception { + waitForPause(); + eval("__exception__[0].__name__").hasValue("'ZeroDivisionError'"); + resume(); + waitForTerminate(); + } + + @Override + public Set getTags() { + return ImmutableSet.of("-iron"); + } + }); + } + + private static void createExceptionBreak(IdeaProjectTestFixture fixture, + boolean notifyOnTerminate, + boolean notifyAlways, + boolean notifyOnFirst) { + PyExceptionBreakpointProperties properties = new PyExceptionBreakpointProperties("exceptions.ZeroDivisionError"); + properties.setNotifyOnTerminate(notifyOnTerminate); + properties.setNotifyAlways(notifyAlways); + properties.setNotifyOnlyOnFirst(notifyOnFirst); + addExceptionBreakpoint(fixture, properties); + properties = new PyExceptionBreakpointProperties("builtins.ZeroDivisionError"); //for python 3 + properties.setNotifyOnTerminate(notifyOnTerminate); + properties.setNotifyAlways(notifyAlways); + properties.setNotifyOnlyOnFirst(notifyOnFirst); + addExceptionBreakpoint(fixture, properties); + } + + public void testExceptionBreakpointAlways() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test_exceptbreak.py") { + @Override + public void before() throws Exception { + createExceptionBreak(myFixture, false, true, false); + } + + @Override + public void testing() throws Exception { + waitForPause(); + eval("__exception__[0].__name__").hasValue("'ZeroDivisionError'"); + resume(); + waitForPause(); + resume(); + waitForPause(); + resume(); + waitForTerminate(); + } + + @Override + public Set getTags() { + return ImmutableSet.of("-pypy"); //TODO: fix it for Pypy + } + }); + } + + public void testExceptionBreakpointOnFirstRaise() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test_exceptbreak.py") { + @Override + public void before() throws Exception { + createExceptionBreak(myFixture, false, false, true); + } + + @Override + public void testing() throws Exception { + waitForPause(); + eval("__exception__[0].__name__").hasValue("'ZeroDivisionError'"); + resume(); + waitForTerminate(); + } + + @Override + public Set getTags() { + return ImmutableSet.of("-iron"); + } + }); + } + + public void testMultithreading() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test_multithread.py") { + @Override + public void before() throws Exception { + toggleBreakpoint(getScriptPath(), 9); + toggleBreakpoint(getScriptPath(), 13); + } + + @Override + public void testing() throws Exception { + waitForPause(); + eval("y").hasValue("2"); + resume(); + waitForPause(); + eval("z").hasValue("102"); + resume(); + } + + @Override + public Set getTags() { + return ImmutableSet.of("-pypy"); //TODO: fix that for PyPy + } + }); + } + + + //TODO: fix me as I don't work properly sometimes (something connected with process termination on agent) + //public void testResume() throws Exception { + // runPythonTest(new PyDebuggerTask("/debug", "Test_Resume.py") { + // @Override + // public void before() throws Exception { + // toggleBreakpoint(getScriptPath(), 2); + // } + // + // @Override + // public void testing() throws Exception { + // waitForPause(); + // eval("x").hasValue("1"); + // resume(); + // waitForPause(); + // eval("x").hasValue("2"); + // resume(); + // } + // }); + //} + + + //TODO: first fix strange hanging of that test + //public void testRemoteDebug() throws Exception { + // runPythonTest(new PyRemoteDebuggerTask("/debug", "test_remote.py") { + // @Override + // public void before() throws Exception { + // } + // + // @Override + // public void testing() throws Exception { + // waitForPause(); + // eval("x").hasValue("0"); + // stepOver(); + // waitForPause(); + // eval("x").hasValue("1"); + // stepOver(); + // waitForPause(); + // eval("x").hasValue("2"); + // resume(); + // } + // + // @Override + // protected void checkOutput(ProcessOutput output) { + // assertEmpty(output.getStderr()); + // assertEquals("OK", output.getStdout().trim()); + // } + // + // @Override + // public void after() throws Exception { + // stopDebugServer(); + // } + // }); + //} + + //TODO: That doesn't work now: case from test_continuation.py and test_continuation2.py are treated differently by interpreter + // (first line is executed in first case and last line in second) + + //public void testBreakOnContinuationLine() throws Exception { + // runPythonTest(new PyDebuggerTask("/debug", "test_continuation.py") { + // @Override + // public void before() throws Exception { + // toggleBreakpoint(getScriptPath(), 13); + // } + // + // @Override + // public void testing() throws Exception { + // waitForPause(); + // eval("x").hasValue("0"); + // stepOver(); + // waitForPause(); + // eval("x").hasValue("1"); + // stepOver(); + // waitForPause(); + // eval("x").hasValue("2"); + // } + // }); + //} +} + diff --git a/python/testSrc/com/jetbrains/env/python/PythonDocTestingTest.java b/python/testSrc/com/jetbrains/env/python/PythonDocTestingTest.java new file mode 100644 index 000000000000..63b53216e0f5 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/PythonDocTestingTest.java @@ -0,0 +1,34 @@ +package com.jetbrains.env.python; + +import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.ut.PyDocTestTask; +import junit.framework.Assert; + +/** + * User : catherine + */ +public class PythonDocTestingTest extends PyEnvTestCase{ + public void testUTRunner() { + runPythonTest(new PyDocTestTask("/testRunner/env/doc", "test1.py") { + + @Override + public void after() { + Assert.assertEquals(3, allTestsCount()); + Assert.assertEquals(3, passedTestsCount()); + allTestsPassed(); + } + }); + } + + public void testUTRunner2() { + runPythonTest(new PyDocTestTask("/testRunner/env/doc", "test2.py") { + + @Override + public void after() { + assertEquals(3, allTestsCount()); + assertEquals(1, passedTestsCount()); + assertEquals(2, failedTestsCount()); + } + }); + } +} diff --git a/python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java b/python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java new file mode 100644 index 000000000000..16213984e919 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java @@ -0,0 +1,24 @@ +package com.jetbrains.env.python; + +import com.intellij.openapi.application.PathManager; +import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.ut.PyUnitTestTask; + +/** + * @author traff + */ +public class PythonGeneratorTest extends PyEnvTestCase{ + public void testGenerator() { + runPythonTest(new PyUnitTestTask("", "test_generator.py") { + @Override + protected String getTestDataPath() { + return PathManager.getHomePath() + "/python/helpers"; + } + + @Override + public void after() { + allTestsPassed(); + } + }); + } +} diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java new file mode 100644 index 000000000000..2d8818086d5f --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -0,0 +1,323 @@ +package com.jetbrains.env.python.console; + +import com.intellij.execution.console.LanguageConsoleViewImpl; +import com.intellij.execution.process.ProcessAdapter; +import com.intellij.execution.process.ProcessEvent; +import com.intellij.openapi.application.Result; +import com.intellij.openapi.application.WriteAction; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.projectRoots.SdkType; +import com.intellij.openapi.projectRoots.impl.ProjectJdkImpl; +import com.intellij.openapi.util.Disposer; +import com.intellij.psi.PsiDocumentManager; +import com.intellij.util.ui.UIUtil; +import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; +import com.jetbrains.python.console.*; +import com.jetbrains.python.console.pydev.ConsoleCommunicationListener; +import com.jetbrains.python.sdk.PythonSdkType; +import org.jetbrains.annotations.NotNull; +import org.junit.Assert; + +import java.util.concurrent.Semaphore; + +/** + * @author traff + */ +public class PyConsoleTask extends PyExecutionFixtureTestTask { + + + private boolean myProcessCanTerminate; + + protected PyConsoleProcessHandler myProcessHandler; + protected PydevConsoleCommunication myCommunication; + + private boolean shouldPrintOutput = false; + private PythonConsoleView myConsoleView; + private Semaphore mySemaphore; + private Semaphore mySemaphore0; + private PydevConsoleExecuteActionHandler myExecuteHandler; + + public PyConsoleTask() { + setWorkingFolder(getTestDataPath()); + } + + public PyConsoleTask(String workingFolder, String scriptName, String scriptParameters) { + setWorkingFolder(getTestDataPath() + workingFolder); + setScriptParameters(scriptParameters); + } + + public PyConsoleTask(String workingFolder) { + this(workingFolder, null, null); + } + + public PythonConsoleView getConsoleView() { + return myConsoleView; + } + + @Override + public void setUp() throws Exception { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + try { + if (myFixture == null) { + PyConsoleTask.super.setUp(); + } + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + }); + } + + @NotNull + protected String output() { + return myConsoleView.getConsole().getHistoryViewer().getDocument().getText(); + } + + private void outputContains(String substring) { + Assert.assertTrue(output().contains(substring)); + } + + public void setProcessCanTerminate(boolean processCanTerminate) { + myProcessCanTerminate = processCanTerminate; + } + + @Override + public void tearDown() throws Exception { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + try { + if (myConsoleView != null) { + disposeConsole(); + } + PyConsoleTask.super.tearDown(); + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + }); + } + + private void disposeConsole() throws InterruptedException { + disposeConsoleProcess(); + + if (myConsoleView != null) { + new WriteAction() { + protected void run(Result result) throws Throwable { + Disposer.dispose(myConsoleView); + myConsoleView = null; + myCommunication = null; + } + }.execute(); + } + } + + public void runTestOn(final String sdkHome) throws Exception { + final Project project = getProject(); + + SdkType sdkType = PythonSdkType.getInstance(); + + final Sdk sdk = new ProjectJdkImpl("Python Test Sdk " + sdkHome, sdkType) { + @Override + public String getHomePath() { + return sdkHome; + } + + @Override + public String getVersionString() { + return "Python 2 Mock SDK"; + } + }; + + setProcessCanTerminate(false); + + PydevConsoleRunner consoleRunner = PydevConsoleRunner.create(project, sdk, PyConsoleType.PYTHON, getWorkingFolder()); + + before(); + + mySemaphore0 = new Semaphore(0); + + consoleRunner.addConsoleListener(new PydevConsoleRunner.ConsoleListener() { + @Override + public void handleConsoleInitialized(LanguageConsoleViewImpl consoleView) { + mySemaphore0.release(); + } + }); + + consoleRunner.run(); + + waitFor(mySemaphore0); + + mySemaphore = new Semaphore(0); + + myConsoleView = consoleRunner.getConsoleView(); + myProcessHandler = (PyConsoleProcessHandler)consoleRunner.getProcessHandler(); + + myExecuteHandler = (PydevConsoleExecuteActionHandler)consoleRunner.getConsoleExecuteActionHandler(); + + myCommunication = consoleRunner.getPydevConsoleCommunication(); + + myCommunication.addCommunicationListener(new ConsoleCommunicationListener() { + @Override + public void executionFinished() { + mySemaphore.release(); + } + + @Override + public void inputRequested() { + } + }); + + myProcessHandler.addProcessListener(new ProcessAdapter() { + @Override + public void processTerminated(ProcessEvent event) { + if (event.getExitCode() != 0 && !myProcessCanTerminate) { + Assert.fail("Process terminated unexpectedly\n" + output()); + } + } + }); + + OutputPrinter myOutputPrinter = null; + if (shouldPrintOutput) { + myOutputPrinter = new OutputPrinter(); + myOutputPrinter.start(); + } + + waitForOutput("PyDev console"); + + testing(); + + after(); + + setProcessCanTerminate(true); + + if (myOutputPrinter != null) { + myOutputPrinter.stop(); + } + + disposeConsole(); + } + + private void disposeConsoleProcess() throws InterruptedException { + myProcessHandler.destroyProcess(); + if (!myProcessHandler.isProcessTerminated()) { + if (!waitFor(myProcessHandler)) { + if (!myProcessHandler.isProcessTerminated()) { + throw new RuntimeException("Cannot stop console process"); + } + } + } + myProcessHandler = null; + } + + public void waitForOutput(String string) throws InterruptedException { + int count = 0; + while (!output().contains(string)) { + if (count > 10) { + Assert.fail("'" + string + "'" + " is not present in output.\n" + output()); + } + Thread.sleep(2000); + count++; + } + } + + protected void waitForReady() throws InterruptedException { + int count = 0; + while (!myExecuteHandler.isEnabled() || !canExecuteNow()) { + if (count > 10) { + Assert.fail("Console is not ready"); + } + Thread.sleep(300); + count++; + } + } + + protected boolean canExecuteNow() { + return myExecuteHandler.canExecuteNow(); + } + + public void setShouldPrintOutput(boolean shouldPrintOutput) { + this.shouldPrintOutput = shouldPrintOutput; + } + + private class OutputPrinter { + private Thread myThread; + private int myLen = 0; + + public void start() { + myThread = new Thread(new Runnable() { + @Override + public void run() { + doJob(); + } + }); + myThread.setDaemon(true); + myThread.start(); + } + + private void doJob() { + try { + while (true) { + printToConsole(); + + Thread.sleep(500); + } + } + catch (Exception e) { + } + } + + private synchronized void printToConsole() { + String s = output(); + if (s.length() > myLen) { + System.out.print(s.substring(myLen)); + } + myLen = s.length(); + } + + public void stop() { + printToConsole(); + myThread.interrupt(); + } + } + + protected void exec(String command) throws InterruptedException { + waitForReady(); + int p = mySemaphore.availablePermits(); + myConsoleView.executeInConsole(command); + mySemaphore.acquire(p + 1); + //waitForOutput(">>> " + command); + } + + protected void input(String text) { + myConsoleView.executeInConsole(text); + } + + protected void waitForFinish() throws InterruptedException { + waitFor(mySemaphore); + } + + protected void execNoWait(String command) { + myConsoleView.executeCode(command); + } + + protected void interrupt() { + myCommunication.interrupt(); + } + + + public void addTextToEditor(final String text) { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + getConsoleView().getLanguageConsole().addTextToCurrentEditor(text); + PsiDocumentManager.getInstance(getProject()).commitAllDocuments(); + } + } + ); + } +} diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java new file mode 100644 index 000000000000..f150245262b0 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java @@ -0,0 +1,292 @@ +package com.jetbrains.env.python.debug; + +import com.google.common.collect.Sets; +import com.intellij.openapi.application.Result; +import com.intellij.openapi.application.WriteAction; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.Disposer; +import com.intellij.openapi.util.Pair; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.util.ui.UIUtil; +import com.intellij.xdebugger.*; +import com.intellij.xdebugger.frame.XValue; +import com.intellij.xdebugger.impl.XSourcePositionImpl; +import com.jetbrains.django.util.VirtualFileUtil; +import com.jetbrains.python.console.PythonDebugLanguageConsoleView; +import com.jetbrains.python.debugger.PyDebugProcess; +import com.jetbrains.python.debugger.PyDebugValue; +import com.jetbrains.python.debugger.PyDebuggerException; +import org.jetbrains.annotations.NotNull; +import org.junit.Assert; + +import java.io.PrintWriter; +import java.lang.reflect.InvocationTargetException; +import java.util.Set; +import java.util.concurrent.Semaphore; + +/** + * @author traff + */ +public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { + private Set> myBreakpoints = Sets.newHashSet(); + protected PyDebugProcess myDebugProcess; + protected XDebugSession mySession; + protected Semaphore myPausedSemaphore; + protected Semaphore myTerminateSemaphore; + protected boolean shouldPrintOutput = false; + protected boolean myProcessCanTerminate; + + protected void waitForPause() throws InterruptedException, InvocationTargetException { + Assert.assertTrue("Debugger didn't stopped within timeout\nOutput:" + output(), waitFor(myPausedSemaphore)); + + XDebuggerTestUtil.waitForSwing(); + } + + protected void waitForTerminate() throws InterruptedException, InvocationTargetException { + setProcessCanTerminate(true); + + Assert.assertTrue("Debugger didn't terminated within timeout\nOutput:" + output(), waitFor(myTerminateSemaphore)); + + XDebuggerTestUtil.waitForSwing(); + } + + protected void runToLine(int line) throws InvocationTargetException, InterruptedException { + XDebugSession currentSession = XDebuggerManager.getInstance(getProject()).getCurrentSession(); + XSourcePosition position = currentSession.getCurrentPosition(); + + + currentSession.runToPosition(XSourcePositionImpl.create(position.getFile(), line), false); + + waitForPause(); + } + + protected void resume() { + XDebugSession currentSession = XDebuggerManager.getInstance(getProject()).getCurrentSession(); + + Assert.assertTrue(currentSession.isSuspended()); + Assert.assertEquals(0, myPausedSemaphore.availablePermits()); + + currentSession.resume(); + } + + protected void stepOver() { + XDebugSession currentSession = XDebuggerManager.getInstance(getProject()).getCurrentSession(); + + Assert.assertTrue(currentSession.isSuspended()); + Assert.assertEquals(0, myPausedSemaphore.availablePermits()); + + currentSession.stepOver(false); + } + + protected void stepInto() { + XDebugSession currentSession = XDebuggerManager.getInstance(getProject()).getCurrentSession(); + + Assert.assertTrue(currentSession.isSuspended()); + Assert.assertEquals(0, myPausedSemaphore.availablePermits()); + + currentSession.stepInto(); + } + + protected void smartStepInto(String funcName) { + XDebugSession currentSession = XDebuggerManager.getInstance(getProject()).getCurrentSession(); + + Assert.assertTrue(currentSession.isSuspended()); + Assert.assertEquals(0, myPausedSemaphore.availablePermits()); + + myDebugProcess.startSmartStepInto(funcName); + } + + @NotNull + protected String output() { + return XDebuggerTestUtil.getConsoleText(((PythonDebugLanguageConsoleView)mySession.getConsoleView()).getTextConsole()); + } + + @NotNull + protected void input(String text) { + PrintWriter pw = new PrintWriter(myDebugProcess.getProcessHandler().getProcessInput()); + pw.println(text); + pw.flush(); + } + + private void outputContains(String substring) { + Assert.assertTrue(output().contains(substring)); + } + + public void setProcessCanTerminate(boolean processCanTerminate) { + myProcessCanTerminate = processCanTerminate; + } + + protected void clearAllBreakpoints() { + for (Pair bp : myBreakpoints) { + doToggleBreakpoint(bp.first, bp.second); + } + } + + /** + * Toggles breakpoint + * @param file getScriptPath() or path to script + * @param line starting with 0 + */ + protected void toggleBreakpoint(final String file, final int line) { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + doToggleBreakpoint(file, line); + } + }); + + if (myBreakpoints.contains(Pair.create(file, line))) { + myBreakpoints.remove(Pair.create(file, line)); + } + else { + myBreakpoints.add(Pair.create(file, line)); + } + } + + public boolean canPutBreakpointAt(Project project, String file, int line) { + VirtualFile vFile = VirtualFileUtil.findFile(file); + Assert.assertNotNull(vFile); + return XDebuggerUtil.getInstance().canPutBreakpointAt(project, vFile, line); + } + + private void doToggleBreakpoint(String file, int line) { + Assert.assertTrue(canPutBreakpointAt(getProject(), file, line)); + XDebuggerTestUtil.toggleBreakpoint(getProject(), VirtualFileUtil.findFile(file), line); + } + + protected Variable eval(String name) throws InterruptedException { + Assert.assertTrue("Eval works only while suspended", mySession.isSuspended()); + XValue var = XDebuggerTestUtil.evaluate(mySession, name).first; + return new Variable(var); + } + + protected void setVal(String name, String value) throws InterruptedException, PyDebuggerException { + XValue var = XDebuggerTestUtil.evaluate(mySession, name).first; + myDebugProcess.changeVariable((PyDebugValue)var, value); + } + + public void waitForOutput(String string) throws InterruptedException { + int count = 0; + while (!output().contains(string)) { + if (count > 10) { + Assert.fail("'" + string + "'" + " is not present in output.\n" + output()); + } + Thread.sleep(2000); + count++; + } + } + + public void setShouldPrintOutput(boolean shouldPrintOutput) { + this.shouldPrintOutput = shouldPrintOutput; + } + + @Override + public void setUp() throws Exception { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + try { + if (myFixture == null) { + PyBaseDebuggerTask.super.setUp(); + } + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + }); + } + + @Override + public void tearDown() throws Exception { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + try { + if (mySession != null) { + finishSession(); + } + PyBaseDebuggerTask.super.tearDown(); + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + }); + } + + protected void finishSession() throws InterruptedException { + disposeDebugProcess(); + + if (mySession != null) { + new WriteAction() { + protected void run(Result result) throws Throwable { + Disposer.dispose(mySession.getConsoleView()); + mySession = null; + myDebugProcess = null; + myPausedSemaphore = null; + } + }.execute(); + } + } + + protected abstract void disposeDebugProcess() throws InterruptedException; + + protected static class Variable { + private final XTestValueNode myValueNode; + + public Variable(XValue value) throws InterruptedException { + myValueNode = XDebuggerTestUtil.computePresentation(value); + } + + public Variable hasValue(String value) { + Assert.assertEquals(value, myValueNode.myValue); + return this; + } + + public Variable hasType(String type) { + Assert.assertEquals(type, myValueNode.myType); + return this; + } + + public Variable hasName(String name) { + Assert.assertEquals(name, myValueNode.myName); + return this; + } + } + + protected class OutputPrinter { + private Thread myThread; + + public void start() { + myThread = new Thread(new Runnable() { + @Override + public void run() { + doJob(); + } + }); + myThread.setDaemon(true); + myThread.start(); + } + + private void doJob() { + int len = 0; + try { + while (true) { + String s = output(); + if (s.length() > len) { + System.out.print(s.substring(len)); + } + len = s.length(); + + Thread.sleep(500); + } + } + catch (Exception e) { + } + } + + public void stop() { + myThread.interrupt(); + } + } +} diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java new file mode 100644 index 000000000000..dcdf8f06afa2 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -0,0 +1,205 @@ +package com.jetbrains.env.python.debug; + +import com.intellij.execution.*; +import com.intellij.execution.configurations.ConfigurationFactory; +import com.intellij.execution.configurations.RunProfile; +import com.intellij.execution.executors.DefaultDebugExecutor; +import com.intellij.execution.process.KillableColoredProcessHandler; +import com.intellij.execution.process.ProcessAdapter; +import com.intellij.execution.process.ProcessEvent; +import com.intellij.execution.runners.ExecutionEnvironment; +import com.intellij.openapi.application.Result; +import com.intellij.openapi.application.WriteAction; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.Key; +import com.intellij.xdebugger.*; +import com.jetbrains.python.debugger.PyDebugProcess; +import com.jetbrains.python.debugger.PyDebugRunner; +import com.jetbrains.python.run.PythonCommandLineState; +import com.jetbrains.python.run.PythonConfigurationType; +import com.jetbrains.python.run.PythonRunConfiguration; +import org.jetbrains.annotations.NotNull; +import org.junit.Assert; + +import java.io.IOException; +import java.net.ServerSocket; +import java.util.concurrent.Semaphore; + +/** + * @author traff + */ +public class PyDebuggerTask extends PyBaseDebuggerTask { + + private boolean myMultiprocessDebug = false; + + public PyDebuggerTask() { + } + + public PyDebuggerTask(String workingFolder, String scriptName, String scriptParameters) { + setWorkingFolder(getTestDataPath() + workingFolder); + setScriptName(scriptName); + setScriptParameters(scriptParameters); + } + + public PyDebuggerTask(String workingFolder, String scriptName) { + this(workingFolder, scriptName, null); + } + + public void runTestOn(String sdkHome) throws Exception { + final Project project = getProject(); + + final ConfigurationFactory factory = PythonConfigurationType.getInstance().getConfigurationFactories()[0]; + + + final RunnerAndConfigurationSettings settings = + RunManager.getInstance(project).createRunConfiguration("test", factory); + + PythonRunConfiguration config = (PythonRunConfiguration)settings.getConfiguration(); + + config.setSdkHome(sdkHome); + config.setScriptName(getScriptPath()); + config.setWorkingDirectory(getWorkingFolder()); + config.setScriptParameters(getScriptParameters()); + + config.setMultiprocessMode(isMultiprocessDebug()); + + new WriteAction() { + @Override + protected void run(Result result) throws Throwable { + RunManagerEx.getInstanceEx(project).addConfiguration(settings, false); + RunManagerEx.getInstanceEx(project).setSelectedConfiguration(settings); + Assert.assertSame(settings, RunManagerEx.getInstanceEx(project).getSelectedConfiguration()); + } + }.execute(); + + final PyDebugRunner runner = (PyDebugRunner)ProgramRunnerUtil.getRunner(DefaultDebugExecutor.EXECUTOR_ID, settings); + Assert.assertTrue(runner.canRun(DefaultDebugExecutor.EXECUTOR_ID, config)); + + final ExecutionEnvironment env = new ExecutionEnvironment(runner, settings, project); + final Executor executor = DefaultDebugExecutor.getDebugExecutorInstance(); + + + final PythonCommandLineState pyState = (PythonCommandLineState)config.getState(executor, env); + assert pyState != null; + pyState.setMultiprocessDebug(isMultiprocessDebug()); + + final ServerSocket serverSocket; + try { + //noinspection SocketOpenedButNotSafelyClosed + serverSocket = new ServerSocket(0); + } + catch (IOException e) { + throw new ExecutionException("Failed to find free socket port", e); + } + + + final int serverLocalPort = serverSocket.getLocalPort(); + final RunProfile profile = env.getRunProfile(); + + + before(); + + setProcessCanTerminate(false); + + ExecutionResult result = new WriteAction() { + @Override + protected void run(Result result) throws Throwable { + final ExecutionResult res = + pyState.execute(executor, PyDebugRunner.createCommandLinePatchers(pyState, profile, serverLocalPort)); + + mySession = XDebuggerManager.getInstance(getProject()). + startSession(runner, env, env.getContentToReuse(), new XDebugProcessStarter() { + @NotNull + public XDebugProcess start(@NotNull final XDebugSession session) { + myDebugProcess = + new PyDebugProcess(session, serverSocket, res.getExecutionConsole(), res.getProcessHandler(), isMultiprocessDebug()); + + myDebugProcess.getProcessHandler().addProcessListener(new ProcessAdapter() { + + @Override + public void onTextAvailable(ProcessEvent event, Key outputType) { + } + + @Override + public void processTerminated(ProcessEvent event) { + myTerminateSemaphore.release(); + if (event.getExitCode() != 0 && !myProcessCanTerminate) { + Assert.fail("Process terminated unexpectedly\n" + output()); + } + } + }); + + + myDebugProcess.getProcessHandler().startNotify(); + + return myDebugProcess; + } + }); + result.setResult(res); + } + }.execute().getResultObject(); + + OutputPrinter myOutputPrinter = null; + if (shouldPrintOutput) { + myOutputPrinter = new OutputPrinter(); + myOutputPrinter.start(); + } + + + myPausedSemaphore = new Semaphore(0); + myTerminateSemaphore = new Semaphore(0); + + mySession.addSessionListener(new XDebugSessionAdapter() { + @Override + public void sessionPaused() { + if (myPausedSemaphore != null) { + myPausedSemaphore.release(); + } + } + }); + + try { + testing(); + } + catch (Throwable e) { + throw new RuntimeException(output(), e); + } + + after(); + + clearAllBreakpoints(); + + setProcessCanTerminate(true); + + if (myOutputPrinter != null) { + myOutputPrinter.stop(); + } + + finishSession(); + } + + private boolean isMultiprocessDebug() { + return myMultiprocessDebug; + } + + public void setMultiprocessDebug(boolean multiprocessDebug) { + myMultiprocessDebug = multiprocessDebug; + } + + @Override + protected void disposeDebugProcess() throws InterruptedException { + if (myDebugProcess != null) { + + myDebugProcess.stop(); + + KillableColoredProcessHandler h = (KillableColoredProcessHandler)myDebugProcess.getProcessHandler(); + if (!h.isProcessTerminated()) { + + h.killProcess(); + if (!waitFor(h)) { + new Throwable("Cannot stop debugger process").printStackTrace(); + } + } + } + } +} diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java new file mode 100644 index 000000000000..0dd5d418534d --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -0,0 +1,205 @@ +package com.jetbrains.env.python.debug; + +import com.google.common.collect.Lists; +import com.google.common.collect.Sets; +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.util.text.StringUtil; +import com.intellij.testFramework.UsefulTestCase; +import com.intellij.util.ui.UIUtil; +import com.jetbrains.python.fixtures.PyTestCase; +import com.jetbrains.python.sdk.PythonSdkType; +import org.jetbrains.annotations.NotNull; + +import java.io.File; +import java.io.IOException; +import java.util.List; +import java.util.Set; + +/** + * @author traff + */ +public abstract class PyEnvTestCase extends UsefulTestCase { + private static final Logger LOG = Logger.getInstance(PyEnvTestCase.class.getName()); + + private static final String TAGS_FILE = "tags.txt"; + public static final String PYCHARM_PYTHON_ENVS = "PYCHARM_PYTHON_ENVS"; + private static final String PYCHARM_PYTHON_VIRTUAL_ENVS = "PYCHARM_PYTHON_VIRTUAL_ENVS"; + + public static final boolean IS_UNDER_TEAMCITY = System.getProperty("bootstrap.testcases") != null; + + protected static final boolean IS_ENV_CONFIGURATION = System.getProperty("pycharm.env") != null; + + + @SuppressWarnings({"JUnitTestCaseWithNonTrivialConstructors"}) + public PyEnvTestCase() { + PyTestCase.initPlatformPrefix(); + } + + @Override + protected void invokeTestRunnable(final Runnable runnable) throws Exception { + if (runInWriteAction()) { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + ApplicationManager.getApplication().runWriteAction(runnable); + } + }); + } + else { + runnable.run(); + } + } + + @Override + protected boolean runInDispatchThread() { + return false; + } + + protected boolean runInWriteAction() { + return false; + } + + public void runPythonTest(PyTestTask testTask) { + runTest(testTask); + } + + private void runTest(@NotNull PyTestTask testTask) { + if (notEnvConfiguration()) { + System.out.println("Running under teamcity but not by Env configuration. Skipping."); + return; + } + + List roots = getPythonRoots(); + + if (roots.size() == 0) { + String msg = getTestName(false) + ": environments are not defined. Skipping. \nSpecify either " + PYCHARM_PYTHON_ENVS + " or " + PYCHARM_PYTHON_VIRTUAL_ENVS + " environment variable."; + LOG.warn(msg); + System.out.println(msg); + return; + } + + boolean wasExecuted = false; + + List passedRoots = Lists.newArrayList(); + + for (String env : roots) { + + if (!isSuitableForTask(loadEnvTags(env), testTask)) { + continue; + } + + try { + testTask.setUp(); + wasExecuted = true; + if (isJython(env)) { + testTask.useLongTimeout(); + } + else { + testTask.useNormalTimeout(); + } + final String executable = PythonSdkType.getPythonExecutable(env); + if (executable == null) { + throw new RuntimeException("Cannot find Python interpreter in " + env); + } + testTask.runTestOn(executable); + passedRoots.add(env); + } + catch (Throwable e) { + throw new RuntimeException(joinStrings(passedRoots, "Tests passed environments: ") + "Test failed on environment " + env, e); + } + finally { + try { + testTask.tearDown(); + } + catch (Exception e) { + e.printStackTrace(); + } + } + } + + if (!wasExecuted) { + throw new RuntimeException("test" + getTestName(false) + " was not executed.\n" + joinStrings(roots, "All roots: ")); + } + } + + public static boolean notEnvConfiguration() { + return IS_UNDER_TEAMCITY && ! IS_ENV_CONFIGURATION; + } + + public static List getPythonRoots() { + List roots = Lists.newArrayList(); + + String envs = System.getenv(PYCHARM_PYTHON_ENVS); + if (envs != null) { + roots.addAll(Lists.newArrayList(envs.split(File.pathSeparator))); + } + + String virtualEnvs = System.getenv(PYCHARM_PYTHON_VIRTUAL_ENVS); + + if (virtualEnvs != null) { + roots.addAll(readVirtualEnvRoots(virtualEnvs)); + } + return roots; + } + + protected static List readVirtualEnvRoots(@NotNull String envs) { + List result = Lists.newArrayList(); + String[] roots = envs.split(File.pathSeparator); + for (String root : roots) { + File virtualEnvRoot = new File(root); + for (File f : virtualEnvRoot.listFiles()) { + result.add(f.getAbsolutePath()); + } + } + + return result; + } + + public static List loadEnvTags(String env) { + List envTags; + + try { + File parent = new File(env); + if (parent.isFile()) { + parent = parent.getParentFile(); + } + envTags = com.jetbrains.appengine.util.FileUtil.loadLines(new File(parent, TAGS_FILE)); + } + catch (IOException e) { + envTags = Lists.newArrayList(); + } + return envTags; + } + + private static boolean isSuitableForTask(List tags, PyTestTask task) { + return isSuitableForTags(tags, task.getTags()); + } + + public static boolean isSuitableForTags(List envTags, Set taskTags) { + Set necessaryTags = Sets.newHashSet(taskTags); + + for (String tag : envTags) { + necessaryTags.remove(tag.trim()); + } + + for (String tag : taskTags) { + if (tag.startsWith("-")) { //do not run on envs with that tag + if (envTags.contains(tag.substring(1))) { + return false; + } + necessaryTags.remove(tag); + } + } + + return necessaryTags.isEmpty(); + } + + public static String joinStrings(List roots, String rootsName) { + return roots.size() > 0 ? rootsName + StringUtil.join(roots, ", ") + "\n" : ""; + } + + private static boolean isJython(String sdkHome) { + return sdkHome.toLowerCase().contains("jython"); + } +} + diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java new file mode 100644 index 000000000000..a223ed66a13e --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java @@ -0,0 +1,137 @@ +package com.jetbrains.env.python.debug; + +import com.intellij.execution.process.ProcessHandler; +import com.intellij.ide.util.projectWizard.EmptyModuleBuilder; +import com.intellij.openapi.module.ModuleType; +import com.intellij.openapi.module.ModuleTypeManager; +import com.intellij.openapi.project.Project; +import com.intellij.testFramework.LightProjectDescriptor; +import com.intellij.testFramework.builders.ModuleFixtureBuilder; +import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; +import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory; +import com.intellij.testFramework.fixtures.ModuleFixture; +import com.intellij.testFramework.fixtures.TestFixtureBuilder; +import com.intellij.testFramework.fixtures.impl.ModuleFixtureBuilderImpl; +import com.intellij.testFramework.fixtures.impl.ModuleFixtureImpl; +import com.intellij.util.ui.UIUtil; +import com.jetbrains.python.PythonModuleTypeBase; +import com.jetbrains.python.PythonTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.concurrent.Semaphore; +import java.util.concurrent.TimeUnit; + +/** + * @author traff + */ +public abstract class PyExecutionFixtureTestTask extends PyTestTask { + public static final int NORMAL_TIMEOUT = 30000; + public static final int LONG_TIMEOUT = 120000; + private int myTimeout = NORMAL_TIMEOUT; + protected IdeaProjectTestFixture myFixture; + + public Project getProject() { + return myFixture.getProject(); + } + + public void useNormalTimeout() { + myTimeout = NORMAL_TIMEOUT; + } + + public void useLongTimeout() { + myTimeout = LONG_TIMEOUT; + } + + public void setUp() throws Exception { + initFixtureBuilder(); + + IdeaTestFixtureFactory factory = IdeaTestFixtureFactory.getFixtureFactory(); + final TestFixtureBuilder fixtureBuilder = factory.createFixtureBuilder(); + + myFixture = fixtureBuilder.getFixture(); + + UIUtil.invokeAndWaitIfNeeded( + new Runnable() { + @Override + public void run() { + ModuleFixtureBuilder moduleFixtureBuilder = fixtureBuilder.addModule(MyModuleFixtureBuilder.class); + moduleFixtureBuilder.addSourceContentRoot(getTestDataPath()); + } + }); + + myFixture.setUp(); + } + + protected String getTestDataPath() { + return PythonTestUtil.getTestDataPath(); + } + + protected void initFixtureBuilder() { + IdeaTestFixtureFactory.getFixtureFactory().registerFixtureBuilder(MyModuleFixtureBuilder.class, MyModuleFixtureBuilderImpl.class); + } + + public void tearDown() throws Exception { + if (myFixture != null) { + myFixture.tearDown(); + myFixture = null; + } + } + + @Nullable + protected LightProjectDescriptor getProjectDescriptor() { + return null; + } + + protected void disposeProcess(ProcessHandler h) throws InterruptedException { + h.destroyProcess(); + if (!waitFor(h)) { + new Throwable("Can't stop process").printStackTrace(); + } + } + + protected boolean waitFor(ProcessHandler p) throws InterruptedException { + return p.waitFor(myTimeout); + } + + protected boolean waitFor(@NotNull Semaphore s) throws InterruptedException { + return waitFor(s, myTimeout); + } + + protected static boolean waitFor(@NotNull Semaphore s, long timeout) throws InterruptedException { + return s.tryAcquire(timeout, TimeUnit.MILLISECONDS); + } + + public static class MyModuleFixtureBuilderImpl extends ModuleFixtureBuilderImpl implements MyModuleFixtureBuilder { + public MyModuleFixtureBuilderImpl(TestFixtureBuilder fixtureBuilder) { + super(new PlatformPythonModuleType(), fixtureBuilder); + } + + @Override + protected ModuleFixture instantiateFixture() { + return new ModuleFixtureImpl(this); + } + } + + public static class PlatformPythonModuleType extends PythonModuleTypeBase { + @NotNull + public static PlatformPythonModuleType getInstance() { + return (PlatformPythonModuleType)ModuleTypeManager.getInstance().findByID(PYTHON_MODULE); + } + + + @Override + public EmptyModuleBuilder createModuleBuilder() { + return new EmptyModuleBuilder() { + @Override + public ModuleType getModuleType() { + return getInstance(); + } + }; + } + } + + public interface MyModuleFixtureBuilder extends ModuleFixtureBuilder { + + } +} diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java new file mode 100644 index 000000000000..ada431afb0d7 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java @@ -0,0 +1,242 @@ +package com.jetbrains.env.python.debug; + +import com.intellij.execution.*; +import com.intellij.execution.configurations.ConfigurationFactory; +import com.intellij.execution.executors.DefaultDebugExecutor; +import com.intellij.execution.process.ProcessAdapter; +import com.intellij.execution.process.ProcessEvent; +import com.intellij.execution.process.ProcessHandler; +import com.intellij.execution.process.ProcessOutput; +import com.intellij.execution.runners.ExecutionEnvironment; +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.application.Result; +import com.intellij.openapi.application.WriteAction; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.Key; +import com.intellij.util.ui.UIUtil; +import com.intellij.xdebugger.*; +import com.jetbrains.python.PythonHelpersLocator; +import com.jetbrains.python.debugger.remote.*; +import com.jetbrains.python.debugger.remote.vfs.PyRemotePositionConverter; +import com.jetbrains.python.sdk.PySdkUtil; +import com.jetbrains.python.sdk.PythonEnvUtil; +import org.jetbrains.annotations.NotNull; +import org.junit.Assert; + +import java.io.IOException; +import java.net.ServerSocket; +import java.util.concurrent.Semaphore; + +/** + * @author traff + */ +public class PyRemoteDebuggerTask extends PyBaseDebuggerTask { + private Semaphore mySessionInitializedSemaphore; + + public PyRemoteDebuggerTask() { + } + + public PyRemoteDebuggerTask(String workingFolder, String scriptName, String scriptParameters) { + setWorkingFolder(getTestDataPath() + workingFolder); + setScriptName(scriptName); + setScriptParameters(scriptParameters); + } + + public PyRemoteDebuggerTask(String workingFolder, String scriptName) { + this(workingFolder, scriptName, null); + } + + public void runTestOn(final String sdkHome) throws Exception { + final Project project = getProject(); + + final ConfigurationFactory factory = PyRemoteDebugConfigurationType.getInstance().getConfigurationFactories()[0]; + + + final RunnerAndConfigurationSettings settings = + RunManager.getInstance(project).createRunConfiguration("test", factory); + + + PyRemoteDebugConfiguration config = (PyRemoteDebugConfiguration)settings.getConfiguration(); + + + new WriteAction() { + @Override + protected void run(Result result) throws Throwable { + RunManagerEx.getInstanceEx(project).addConfiguration(settings, false); + RunManagerEx.getInstanceEx(project).setSelectedConfiguration(settings); + Assert.assertSame(settings, RunManagerEx.getInstanceEx(project).getSelectedConfiguration()); + } + }.execute(); + + final PyRemoteDebugRunner runner = (PyRemoteDebugRunner)ProgramRunnerUtil.getRunner(DefaultDebugExecutor.EXECUTOR_ID, settings); + Assert.assertTrue(runner.canRun(DefaultDebugExecutor.EXECUTOR_ID, config)); + + final ExecutionEnvironment env = new ExecutionEnvironment(runner, settings, project); + final Executor executor = DefaultDebugExecutor.getDebugExecutorInstance(); + + + final PyRemoteDebugCommandLineState pyState = (PyRemoteDebugCommandLineState)config.getState(executor, env); + assert pyState != null; + + final ServerSocket serverSocket; + final PyRemoteDebugConfiguration conf = (PyRemoteDebugConfiguration)env.getRunProfile(); + try { + //noinspection SocketOpenedButNotSafelyClosed + serverSocket = new ServerSocket(conf.getPort()); + } + catch (IOException e) { + throw new ExecutionException("Failed to find free socket port", e); + } + + setProcessCanTerminate(false); + + mySessionInitializedSemaphore = new Semaphore(0); + + UIUtil.invokeLaterIfNeeded(new Runnable() { + public void run() { + ApplicationManager.getApplication().runWriteAction(new Runnable() { + @Override + public void run() { + try { + final ExecutionResult res = + pyState.execute(executor, runner); + + + mySession = XDebuggerManager.getInstance(project). + startSession(runner, env, env.getContentToReuse(), new XDebugProcessStarter() { + @NotNull + public XDebugProcess start(@NotNull final XDebugSession session) { + myDebugProcess = + new PyRemoteDebugProcess(session, serverSocket, res.getExecutionConsole(), + res.getProcessHandler()); + myDebugProcess.setPositionConverter(new PyRemotePositionConverter(myDebugProcess, conf.getMappingSettings())); + + myDebugProcess.getProcessHandler().addProcessListener(new ProcessAdapter() { + + @Override + public void onTextAvailable(ProcessEvent event, Key outputType) { + } + + @Override + public void processTerminated(ProcessEvent event) { + myTerminateSemaphore.release(); + if (event.getExitCode() != 0 && !myProcessCanTerminate) { + Assert.fail("Process terminated unexpectedly\n" + output()); + } + } + }); + + myPausedSemaphore = new Semaphore(0); + + myTerminateSemaphore = new Semaphore(0); + + return myDebugProcess; + } + }); + + mySession.addSessionListener(new XDebugSessionAdapter() { + @Override + public void sessionPaused() { + if (myPausedSemaphore != null) { + myPausedSemaphore.release(); + } + } + }); + + mySessionInitializedSemaphore.release(); + } + catch (ExecutionException e1) { + throw new RuntimeException(e1); + } + } + }); + } + }); + + before(); + + new Thread(new Runnable() { + @Override + public void run() { + while (myDebugProcess == null || !myDebugProcess.isWaitingForConnection()) { + try { + Thread.sleep(300); + } + catch (InterruptedException e) { + } + } + + ProcessOutput output = + PySdkUtil.getProcessOutput(getWorkingFolder(), new String[]{sdkHome, getScriptPath(), Integer.toString(serverSocket.getLocalPort())}, new String[]{ + PythonEnvUtil.PYTHONUNBUFFERED + "=x", PythonEnvUtil.PYTHONPATH+"="+ PythonHelpersLocator.getHelpersRoot()}, 0); + checkOutput(output); + } + }).start(); + + + OutputPrinter myOutputPrinter = null; + if (shouldPrintOutput) + + { + myOutputPrinter = new OutputPrinter(); + myOutputPrinter.start(); + } + + + waitFor(mySessionInitializedSemaphore); + + try { + testing(); + } + catch (Throwable e) { + throw new RuntimeException(output(), e); + } + + after(); + + clearAllBreakpoints(); + + setProcessCanTerminate(true); + + if (myOutputPrinter != null) + + { + myOutputPrinter.stop(); + } + + finishSession(); + } + + protected void checkOutput(ProcessOutput output) { + } + + protected void stopDebugServer() throws InterruptedException { + if (myDebugProcess != null) { + ProcessHandler h = myDebugProcess.getProcessHandler(); + h.destroyProcess(); + h.detachProcess(); + + if (!h.isStartNotified()) { + h.startNotify(); + } + } + } + + protected void disposeDebugProcess() throws InterruptedException { + if (myDebugProcess != null) { + + myDebugProcess.stop(); + + ProcessHandler h = myDebugProcess.getProcessHandler(); + if (!h.isProcessTerminated()) { + + h.destroyProcess(); + + if (!waitFor(h)) { + new Throwable("Cannot stop debugger process").printStackTrace(); + } + } + } + } + +} diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java new file mode 100644 index 000000000000..8987dbafc24e --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java @@ -0,0 +1,75 @@ +package com.jetbrains.env.python.debug; + +import com.google.common.collect.Sets; +import com.intellij.openapi.util.io.FileUtil; + +import java.util.Set; + +/** + * @author traff + */ +public abstract class PyTestTask { + private String myWorkingFolder; + private String myScriptName; + private String myScriptParameters; + + public void setWorkingFolder(String workingFolder) { + myWorkingFolder = workingFolder; + } + + public void setScriptName(String scriptName) { + myScriptName = scriptName; + } + + public void setScriptParameters(String scriptParameters) { + myScriptParameters = scriptParameters; + } + + public void setUp() throws Exception { + } + + public void tearDown() throws Exception { + } + + public abstract void runTestOn(String sdkHome) throws Exception; + + public void before() throws Exception { + } + + public void testing() throws Exception { + } + + public void after() throws Exception { + } + + public void useNormalTimeout() { + } + + public void useLongTimeout() { + } + + public String getScriptName() { + return myScriptName; + } + + public String getScriptPath() { + return getFilePath(myScriptName); + } + + public String getFilePath(String scriptName) { + return FileUtil + .toSystemDependentName(myWorkingFolder.endsWith("/") ? myWorkingFolder + scriptName : myWorkingFolder + "/" + scriptName); + } + + public String getScriptParameters() { + return myScriptParameters; + } + + public String getWorkingFolder() { + return myWorkingFolder; + } + + public Set getTags() { + return Sets.newHashSet(); + } +} diff --git a/python/testSrc/com/jetbrains/env/ut/PyDocTestTask.java b/python/testSrc/com/jetbrains/env/ut/PyDocTestTask.java new file mode 100644 index 000000000000..e8228d767287 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/ut/PyDocTestTask.java @@ -0,0 +1,24 @@ +package com.jetbrains.env.ut; + +import com.intellij.execution.configurations.ConfigurationFactory; +import com.intellij.openapi.project.Project; +import com.jetbrains.python.testing.PythonTestConfigurationType; + +/** + * User : catherine + */ +public abstract class PyDocTestTask extends PyUnitTestTask { + public PyDocTestTask(String workingFolder, String scriptName, String scriptParameters) { + super(workingFolder, scriptName, scriptParameters); + } + + public PyDocTestTask(String workingFolder, String scriptName) { + this(workingFolder, scriptName, null); + } + + public void runTestOn(String sdkHome) throws Exception { + final Project project = getProject(); + final ConfigurationFactory factory = PythonTestConfigurationType.getInstance().PY_DOCTEST_FACTORY; + runConfiguration(factory, sdkHome, project); + } +} diff --git a/python/testSrc/com/jetbrains/env/ut/PyNoseTestTask.java b/python/testSrc/com/jetbrains/env/ut/PyNoseTestTask.java new file mode 100644 index 000000000000..e130dd5717a4 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/ut/PyNoseTestTask.java @@ -0,0 +1,32 @@ +package com.jetbrains.env.ut; + +import com.google.common.collect.ImmutableSet; +import com.intellij.execution.configurations.ConfigurationFactory; +import com.intellij.openapi.project.Project; +import com.jetbrains.python.testing.PythonTestConfigurationType; + +import java.util.Set; + +/** + * User : catherine + */ +public abstract class PyNoseTestTask extends PyUnitTestTask { + public PyNoseTestTask(String workingFolder, String scriptName, String scriptParameters) { + super(workingFolder, scriptName, scriptParameters); + } + + public PyNoseTestTask(String workingFolder, String scriptName) { + this(workingFolder, scriptName, null); + } + + public void runTestOn(String sdkHome) throws Exception { + final Project project = getProject(); + final ConfigurationFactory factory = PythonTestConfigurationType.getInstance().PY_NOSETEST_FACTORY; + runConfiguration(factory, sdkHome, project); + } + + @Override + public Set getTags() { + return ImmutableSet.of("nose"); + } +} diff --git a/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java b/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java new file mode 100644 index 000000000000..20eb9bb3cf3d --- /dev/null +++ b/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java @@ -0,0 +1,240 @@ +package com.jetbrains.env.ut; + +import com.google.common.collect.Lists; +import com.intellij.execution.*; +import com.intellij.execution.configurations.ConfigurationFactory; +import com.intellij.execution.executors.DefaultRunExecutor; +import com.intellij.execution.process.ProcessAdapter; +import com.intellij.execution.process.ProcessEvent; +import com.intellij.execution.process.ProcessHandler; +import com.intellij.execution.runners.ExecutionEnvironment; +import com.intellij.execution.runners.ProgramRunner; +import com.intellij.execution.testframework.Filter; +import com.intellij.execution.testframework.sm.runner.SMTestProxy; +import com.intellij.execution.testframework.sm.runner.ui.SMTRunnerConsoleView; +import com.intellij.execution.testframework.sm.runner.ui.TestResultsViewer; +import com.intellij.execution.ui.RunContentDescriptor; +import com.intellij.openapi.application.Result; +import com.intellij.openapi.application.WriteAction; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.Disposer; +import com.intellij.openapi.util.Key; +import com.intellij.util.ui.UIUtil; +import com.intellij.xdebugger.XDebuggerTestUtil; +import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; +import com.jetbrains.python.sdk.JythonSdkFlavor; +import com.jetbrains.python.sdk.PythonEnvUtil; +import com.jetbrains.python.sdk.PythonSdkFlavor; +import com.jetbrains.python.testing.AbstractPythonTestRunConfiguration; +import com.jetbrains.python.testing.PythonTestConfigurationType; +import org.jetbrains.annotations.NotNull; +import org.junit.Assert; + +/** + * @author traff + */ +public abstract class PyUnitTestTask extends PyExecutionFixtureTestTask { + + protected ProcessHandler myProcessHandler; + private boolean shouldPrintOutput = false; + private SMTestProxy.SMRootTestProxy myTestProxy; + private boolean mySetUp = false; + private SMTRunnerConsoleView myConsoleView; + private RunContentDescriptor myDescriptor; + private StringBuilder myOutput; + + public PyUnitTestTask() { + } + + public PyUnitTestTask(String workingFolder, String scriptName, String scriptParameters) { + setWorkingFolder(getTestDataPath() + workingFolder); + setScriptName(scriptName); + setScriptParameters(scriptParameters); + } + + public PyUnitTestTask(String workingFolder, String scriptName) { + this(workingFolder, scriptName, null); + } + + @Override + public void setUp() throws Exception { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + try { + if (myFixture == null) { + PyUnitTestTask.super.setUp(); + mySetUp = true; + } + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + }); + } + + @NotNull + protected String output() { + return myOutput.toString(); + } + + @Override + public void tearDown() throws Exception { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + try { + if (mySetUp) { + if (myConsoleView != null) { + Disposer.dispose(myConsoleView); + myConsoleView = null; + } + if (myDescriptor != null) { + myDescriptor.dispose(); + myDescriptor = null; + } + + + PyUnitTestTask.super.tearDown(); + + mySetUp = false; + } + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + } + + ); + } + + public void runTestOn(String sdkHome) throws Exception { + final Project project = getProject(); + final ConfigurationFactory factory = PythonTestConfigurationType.getInstance().PY_UNITTEST_FACTORY; + runConfiguration(factory, sdkHome, project); + } + + protected void runConfiguration(ConfigurationFactory factory, String sdkHome, final Project project) throws Exception { + final RunnerAndConfigurationSettings settings = + RunManager.getInstance(project).createRunConfiguration("test", factory); + + AbstractPythonTestRunConfiguration config = (AbstractPythonTestRunConfiguration)settings.getConfiguration(); + + + config.setSdkHome(sdkHome); + config.setScriptName(getScriptPath()); + config.setWorkingDirectory(getWorkingFolder()); + + PythonSdkFlavor sdk = PythonSdkFlavor.getFlavor(sdkHome); + + + if (sdk instanceof JythonSdkFlavor) { + config.setInterpreterOptions(JythonSdkFlavor.getPythonPathCmdLineArgument(Lists.newArrayList(getWorkingFolder()))); + } + else { + PythonEnvUtil.addToPythonPath(config.getEnvs(), getWorkingFolder()); + } + + + configure(config); + + new WriteAction() { + @Override + protected void run(Result result) throws Throwable { + RunManagerEx.getInstanceEx(project).addConfiguration(settings, false); + RunManagerEx.getInstanceEx(project).setSelectedConfiguration(settings); + Assert.assertSame(settings, RunManagerEx.getInstanceEx(project).getSelectedConfiguration()); + } + }.execute(); + + final ProgramRunner runner = ProgramRunnerUtil.getRunner(DefaultRunExecutor.EXECUTOR_ID, settings); + + Assert.assertTrue(runner.canRun(DefaultRunExecutor.EXECUTOR_ID, config)); + + final ExecutionEnvironment env = new ExecutionEnvironment(runner, settings, project); + final Executor executor = DefaultRunExecutor.getRunExecutorInstance(); + + before(); + + final com.intellij.util.concurrency.Semaphore s = new com.intellij.util.concurrency.Semaphore(); + s.down(); + + myOutput = new StringBuilder(); + + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + try { + runner.execute(executor, env, new ProgramRunner.Callback() { + @Override + public void processStarted(RunContentDescriptor descriptor) { + myDescriptor = descriptor; + myProcessHandler = myDescriptor.getProcessHandler(); + myProcessHandler.addProcessListener(new ProcessAdapter() { + @Override + public void onTextAvailable(ProcessEvent event, Key outputType) { + myOutput.append(event.getText()); + } + }); + myConsoleView = (com.intellij.execution.testframework.sm.runner.ui.SMTRunnerConsoleView)descriptor.getExecutionConsole(); + myTestProxy = myConsoleView.getResultsViewer().getTestsRootNode(); + myConsoleView.getResultsViewer().addEventsListener(new TestResultsViewer.SMEventsAdapter() { + @Override + public void onTestingFinished(TestResultsViewer sender) { + s.up(); + } + }); + } + }); + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + }); + + Assert.assertTrue(s.waitFor(60000)); + + XDebuggerTestUtil.waitForSwing(); + + assertFinished(); + + Assert.assertTrue(output(), allTestsCount() > 0); + + after(); + + disposeProcess(myProcessHandler); + } + + protected void configure(AbstractPythonTestRunConfiguration config) { + } + + public void allTestsPassed() { + Assert.assertEquals(output(), 0, myTestProxy.getChildren(Filter.NOT_PASSED).size()); + Assert.assertEquals(output(), 0, failedTestsCount()); + } + + public int failedTestsCount() { + return myTestProxy.collectChildren(NOT_SUIT.and(Filter.FAILED_OR_INTERRUPTED)).size(); + } + + public int passedTestsCount() { + return myTestProxy.collectChildren(NOT_SUIT.and(Filter.PASSED)).size(); + } + + public void assertFinished() { + Assert.assertTrue("State is " + myTestProxy.getMagnitudeInfo().getTitle() + "\n" + output(), + myTestProxy.wasLaunched() && !myTestProxy.wasTerminated()); + } + + public int allTestsCount() { + return myTestProxy.collectChildren(NOT_SUIT).size(); + } + + public static final Filter NOT_SUIT = new Filter() { + @Override + public boolean shouldAccept(SMTestProxy test) { + return !test.isSuite(); + } + }; +} From ed589cf113d3a7840033f1eae11adcec1739ce01 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 3 Jul 2012 21:35:53 +0200 Subject: [PATCH 002/183] Fail on wrong configuration. --- .../testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index 0dd5d418534d..8c67cb4ca12a 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -65,7 +65,7 @@ public abstract class PyEnvTestCase extends UsefulTestCase { private void runTest(@NotNull PyTestTask testTask) { if (notEnvConfiguration()) { - System.out.println("Running under teamcity but not by Env configuration. Skipping."); + fail("Running under teamcity but not by Env configuration. Skipping."); return; } From 02f0fe160c052643ae4fc1ae342f982c4a429b16 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 3 Jul 2012 21:41:45 +0200 Subject: [PATCH 003/183] Why Git-Integration didn't add that class on move refactoring? --- .../env/django/DjangoPathTestTask.java | 248 ++++++++++++++++++ 1 file changed, 248 insertions(+) create mode 100644 python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java new file mode 100644 index 000000000000..aa5ba1d60b64 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java @@ -0,0 +1,248 @@ +package com.jetbrains.env.django; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.intellij.execution.*; +import com.intellij.execution.configurations.ConfigurationFactory; +import com.intellij.execution.executors.DefaultRunExecutor; +import com.intellij.execution.process.ProcessAdapter; +import com.intellij.execution.process.ProcessEvent; +import com.intellij.execution.process.ProcessHandler; +import com.intellij.execution.runners.ExecutionEnvironment; +import com.intellij.execution.runners.ProgramRunner; +import com.intellij.execution.ui.ExecutionConsole; +import com.intellij.execution.ui.RunContentDescriptor; +import com.intellij.openapi.application.Result; +import com.intellij.openapi.application.WriteAction; +import com.intellij.openapi.module.Module; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil; +import com.intellij.openapi.util.Disposer; +import com.intellij.openapi.util.Key; +import com.intellij.openapi.vfs.LocalFileSystem; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.util.concurrency.Semaphore; +import com.intellij.util.ui.UIUtil; +import com.intellij.xdebugger.XDebuggerTestUtil; +import com.jetbrains.django.facet.DjangoFacet; +import com.jetbrains.django.fixtures.DjangoTestCase; +import com.jetbrains.django.manage.DjangoManageTask; +import com.jetbrains.django.ui.DjangoBundle; +import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; +import com.jetbrains.python.PythonHelpersLocator; +import com.jetbrains.python.PythonTestUtil; +import com.jetbrains.python.run.AbstractPythonRunConfiguration; +import com.jetbrains.python.run.PythonTracebackFilter; +import com.jetbrains.python.sdk.PythonSdkType; +import com.jetbrains.python.templateLanguages.TemplatesConfigurationsModel; +import com.jetbrains.python.templateLanguages.TemplatesService; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.junit.Assert; + +import java.io.IOException; +import java.util.Set; + +/** + * User : catherine + */ +public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { + + private StringBuilder myOutput; + private RunContentDescriptor myDescriptor; + private ProcessHandler myProcessHandler; + private ExecutionConsole myConsoleView; + private boolean mySetUp; + private Sdk mySdk; + + @Override + protected String getTestDataPath() { + return PythonTestUtil.getTestDataPath() + "/django/path/djangoPath"; + } + + @Override + public void setUp() throws Exception { + super.setUp(); + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + if (myFixture == null) + mySetUp = true; + Module module = myFixture.getModule(); + if (module != null && !DjangoFacet.isPresent(module)) { + DjangoTestCase.addDjangoFacet(module); + TemplatesService.getInstance(module).setTemplateLanguage(TemplatesConfigurationsModel.DJANGO); + } + TemplatesService.getInstance(module).setTemplateLanguage(TemplatesConfigurationsModel.DJANGO); + } + }); + } + + @Override + public void tearDown() throws Exception { + TemplatesService.getInstance(myFixture.getModule()).setTemplateLanguage(TemplatesService.NONE); + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + try { + if (mySetUp) { + DjangoPathTestTask.super.tearDown(); + if (myConsoleView != null) { + Disposer.dispose(myConsoleView); + myConsoleView = null; + } + if (myDescriptor != null) { + myDescriptor.dispose(); + myDescriptor = null; + } + mySetUp = false; + } + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + }); + } + + private void createTempSdk(@NotNull final String sdkHome) { + final VirtualFile binary = LocalFileSystem.getInstance().findFileByPath(sdkHome); + if (binary != null) { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + mySdk = SdkConfigurationUtil.createAndAddSDK(sdkHome, PythonSdkType.getInstance()); + + } + }); + } + } + + @Nullable + public abstract ConfigurationFactory getFactory(); + + @Override + public void runTestOn(final String sdkHome) throws Exception { + createTempSdk(sdkHome); + before(); + + final Semaphore s = new Semaphore(); + s.down(); + + myOutput = new StringBuilder(); + runProcess(sdkHome, s); + + testing(); + Assert.assertTrue(s.waitFor(60000)); + + XDebuggerTestUtil.waitForSwing(); + after(); + disposeProcess(myProcessHandler); + } + + private void runProcess(final String sdkHome, final Semaphore s) throws ExecutionException, IOException { + final ConfigurationFactory factory = getFactory(); + if (factory == null) { // PythonTask (there is no run configuration) + final Module module = myFixture.getModule(); + final DjangoManageTask task = new DjangoManageTask(module, DjangoBundle.message("manage.run.tab.name"), mySdk); + + task.setWorkingDirectory(getWorkingFolder()); + task.setRunnerScript(PythonHelpersLocator.getHelperPath("pycharm/django_manage.py")); + final ImmutableList.Builder parametersString = + new ImmutableList.Builder().add("validate").add(getTestDataPath()); + task.setParameters(parametersString.build()); + + myProcessHandler = task.createProcess(); + myOutput = new StringBuilder(); + myProcessHandler.addProcessListener(new ProcessAdapter() { + @Override + public void onTextAvailable(ProcessEvent event, Key outputType) { + myOutput.append(event.getText()); + } + }); + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + final Project project = myFixture.getProject(); + new RunContentExecutor(project, myProcessHandler) + .withFilter(new PythonTracebackFilter(project)) + .run(); + } + }); + s.up(); + } + else { //run dango server and django test + final Project project = getProject(); + final RunnerAndConfigurationSettings settings = + RunManager.getInstance(project).createRunConfiguration("test", factory); + + final AbstractPythonRunConfiguration config = (AbstractPythonRunConfiguration)settings.getConfiguration(); + config.setSdkHome(sdkHome); + config.setWorkingDirectory(getWorkingFolder()); + configure(config); + + new WriteAction() { + @Override + protected void run(Result result) throws Throwable { + RunManagerEx.getInstanceEx(project).addConfiguration(settings, false); + RunManagerEx.getInstanceEx(project).setSelectedConfiguration(settings); + Assert.assertSame(settings, RunManagerEx.getInstanceEx(project).getSelectedConfiguration()); + } + }.execute(); + + final ProgramRunner runner = ProgramRunnerUtil.getRunner(DefaultRunExecutor.EXECUTOR_ID, settings); + + Assert.assertTrue(runner.canRun(DefaultRunExecutor.EXECUTOR_ID, config)); + + final ExecutionEnvironment env = new ExecutionEnvironment(runner, settings, project); + final Executor executor = DefaultRunExecutor.getRunExecutorInstance(); + + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + try { + runner.execute(executor, env, new ProgramRunner.Callback() { + @Override + public void processStarted(RunContentDescriptor descriptor) { + myDescriptor = descriptor; + myProcessHandler = myDescriptor.getProcessHandler(); + myProcessHandler.addProcessListener(new ProcessAdapter() { + @Override + public void onTextAvailable(ProcessEvent event, Key outputType) { + myOutput.append(event.getText()); + } + }); + myConsoleView = myDescriptor.getExecutionConsole(); + s.up(); + } + }); + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + }); + } + } + + protected void configure(AbstractPythonRunConfiguration config) throws IOException { + } + + @NotNull + protected String output() { + return myOutput.toString(); + } + + + public void waitForOutput(@NotNull final String string) throws InterruptedException { + int count = 0; + while (!output().contains(string)) { + if (count > 10) { + Assert.fail("'" + string + "'" + " is not present in output.\n" + output()); + } + Thread.sleep(2000); + count++; + } + } + + @Override + public Set getTags() { + return ImmutableSet.of("django"); + } +} From af9aa17bad60d0e01243e00e57e222d0aa466a2c Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 3 Jul 2012 22:02:10 +0200 Subject: [PATCH 004/183] Fixed separators normalization. --- .../jetbrains/env/django/DjangoPathTest.java | 66 ++++++++++--------- 1 file changed, 34 insertions(+), 32 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java index c4a681dbf9f5..715a495fb3cf 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java @@ -2,6 +2,7 @@ package com.jetbrains.env.django; import com.google.common.collect.Lists; import com.intellij.execution.configurations.ConfigurationFactory; +import com.intellij.openapi.util.io.FileUtil; import com.jetbrains.django.run.DjangoServerRunConfiguration; import com.jetbrains.django.run.DjangoServerRunConfigurationType; import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; @@ -9,6 +10,7 @@ import com.jetbrains.django.testRunner.DjangoTestsRunConfiguration; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.python.PythonHelpersLocator; import com.jetbrains.python.run.AbstractPythonRunConfiguration; +import junit.framework.Assert; import org.jetbrains.annotations.Nullable; import java.io.IOException; @@ -37,24 +39,38 @@ public class DjangoPathTest extends PyEnvTestCase { public void testing() throws Exception { waitForOutput("Development server is running"); - final String[] splittedOutput = output().split("\\n"); - final ArrayList outputList = Lists.newArrayList(); - for (String s : splittedOutput) { - if (s.equals("The end of sys.path")) - break; - outputList.add(s); - } - - assertEquals(getTestDataPath(), outputList.get(1)); - assertTrue(outputList.contains(PythonHelpersLocator.getHelpersRoot().getPath())); - assertEquals(outputList.indexOf(PythonHelpersLocator.getHelpersRoot().getPath()), - outputList.lastIndexOf(PythonHelpersLocator.getHelpersRoot().getPath())); - assertEquals(outputList.indexOf(getTestDataPath()), - outputList.lastIndexOf(getTestDataPath())); + doTest(output(), getTestDataPath()); } - }); + } + private static void doTest(String output, String testDataPath) { + final String[] splittedOutput = output.split("\\n"); + final ArrayList outputList = Lists.newArrayList(); + for (String s : splittedOutput) { + if (s.equals("The end of sys.path")) { + break; + } + outputList.add(norm(s)); + } + + String helpersRoot = PythonHelpersLocator.getHelpersRoot().getPath(); + helpersRoot = norm(helpersRoot); + + testDataPath = norm(testDataPath); + + + Assert.assertEquals(testDataPath, outputList.get(1)); + + assertTrue(outputList.contains(helpersRoot)); + assertEquals(outputList.indexOf(helpersRoot), + outputList.lastIndexOf(helpersRoot)); + assertEquals(outputList.indexOf(testDataPath), + outputList.lastIndexOf(testDataPath)); + } + + private static String norm(String testDataPath) { + return FileUtil.toSystemIndependentName(testDataPath); } public void testTestPath() throws IOException { @@ -72,23 +88,9 @@ public class DjangoPathTest extends PyEnvTestCase { public void testing() throws Exception { waitForOutput("The end of sys.path"); - final String[] splittedOutput = output().split("\\n"); - final ArrayList outputList = Lists.newArrayList(); - for (String s : splittedOutput) { - if (s.equals("The end of sys.path")) - break; - outputList.add(s); - } - - assertEquals(getTestDataPath(), outputList.get(1)); - assertTrue(outputList.contains(PythonHelpersLocator.getHelpersRoot().getPath())); - assertEquals(outputList.indexOf(PythonHelpersLocator.getHelpersRoot().getPath()), - outputList.lastIndexOf(PythonHelpersLocator.getHelpersRoot().getPath())); - assertEquals(outputList.indexOf(getTestDataPath()), - outputList.lastIndexOf(getTestDataPath())); + doTest(output(), getTestDataPath()); } }); - } public void testManagePath() throws IOException { @@ -106,8 +108,9 @@ public class DjangoPathTest extends PyEnvTestCase { final String[] splittedOutput = output().split("\\n"); final ArrayList outputList = Lists.newArrayList(); for (String s : splittedOutput) { - if (s.equals("The end of sys.path")) + if (s.equals("The end of sys.path")) { break; + } outputList.add(s); } @@ -119,6 +122,5 @@ public class DjangoPathTest extends PyEnvTestCase { outputList.lastIndexOf(getTestDataPath())); } }); - } } From 0106354f262f5aea3e3125ef1b20ad8a18b7c70e Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 3 Jul 2012 22:41:28 +0200 Subject: [PATCH 005/183] Excluded temporarily some not-working tests. --- .../testSrc/com/jetbrains/env/python/PythonDebuggerTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index 416b7cdca7e7..37a76a99e795 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -340,7 +340,7 @@ public class PythonDebuggerTest extends PyEnvTestCase { @Override public Set getTags() { - return ImmutableSet.of("-pypy"); //TODO: fix it for Pypy + return ImmutableSet.of("-pypy", "-iron"); //TODO: fix it for Pypy and ironpython } }); } @@ -387,7 +387,7 @@ public class PythonDebuggerTest extends PyEnvTestCase { @Override public Set getTags() { - return ImmutableSet.of("-pypy"); //TODO: fix that for PyPy + return ImmutableSet.of("-pypy", "-iron"); //TODO: fix that for PyPy and IronPython } }); } From 2b60f7eda88c7db3e4fe9cb794d90c9fdd91398d Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Wed, 4 Jul 2012 15:50:13 +0200 Subject: [PATCH 006/183] Added more clear message about missing tags. --- .../com/jetbrains/env/python/debug/PyEnvTestCase.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index 8c67cb4ca12a..90cd9510a7d9 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -13,6 +13,7 @@ import org.jetbrains.annotations.NotNull; import java.io.File; import java.io.IOException; +import java.util.Collection; import java.util.List; import java.util.Set; @@ -118,7 +119,8 @@ public abstract class PyEnvTestCase extends UsefulTestCase { } if (!wasExecuted) { - throw new RuntimeException("test" + getTestName(false) + " was not executed.\n" + joinStrings(roots, "All roots: ")); + throw new RuntimeException("test" + getTestName(false) + " was not executed.\n" + joinStrings(roots, "All roots: ") + "\n" + joinStrings(testTask.getTags(), "Required tags in tags.txt in root: ")); + } } @@ -194,7 +196,7 @@ public abstract class PyEnvTestCase extends UsefulTestCase { return necessaryTags.isEmpty(); } - public static String joinStrings(List roots, String rootsName) { + public static String joinStrings(Collection roots, String rootsName) { return roots.size() > 0 ? rootsName + StringUtil.join(roots, ", ") + "\n" : ""; } From 9cc5e1a276f36bc9c80e299d67ea18d512854f28 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Wed, 4 Jul 2012 16:21:54 +0200 Subject: [PATCH 007/183] Fixed test. --- .../com/jetbrains/env/django/DjangoPathTest.java | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java index 715a495fb3cf..1215e6f8ef58 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java @@ -8,7 +8,6 @@ import com.jetbrains.django.run.DjangoServerRunConfigurationType; import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; import com.jetbrains.django.testRunner.DjangoTestsRunConfiguration; import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.python.PythonHelpersLocator; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import junit.framework.Assert; import org.jetbrains.annotations.Nullable; @@ -54,17 +53,11 @@ public class DjangoPathTest extends PyEnvTestCase { outputList.add(norm(s)); } - String helpersRoot = PythonHelpersLocator.getHelpersRoot().getPath(); - helpersRoot = norm(helpersRoot); - testDataPath = norm(testDataPath); Assert.assertEquals(testDataPath, outputList.get(1)); - assertTrue(outputList.contains(helpersRoot)); - assertEquals(outputList.indexOf(helpersRoot), - outputList.lastIndexOf(helpersRoot)); assertEquals(outputList.indexOf(testDataPath), outputList.lastIndexOf(testDataPath)); } @@ -115,9 +108,6 @@ public class DjangoPathTest extends PyEnvTestCase { } assertEquals(getTestDataPath(), outputList.get(1)); - assertTrue(outputList.contains(PythonHelpersLocator.getHelperPath("pycharm/"))); - assertEquals(outputList.indexOf(PythonHelpersLocator.getHelperPath("pycharm/")), - outputList.lastIndexOf(PythonHelpersLocator.getHelperPath("pycharm/"))); assertEquals(outputList.indexOf(getTestDataPath()), outputList.lastIndexOf(getTestDataPath())); } From 0e05d0b663ee16f5f9a52688abfa3d0713c4c0ed Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 5 Jul 2012 17:39:17 +0200 Subject: [PATCH 008/183] Fixed memory leak. --- .../env/django/DjangoPathTestTask.java | 32 ++++++++----------- 1 file changed, 13 insertions(+), 19 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java index aa5ba1d60b64..da3d6dafb14f 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java @@ -53,7 +53,6 @@ public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { private RunContentDescriptor myDescriptor; private ProcessHandler myProcessHandler; private ExecutionConsole myConsoleView; - private boolean mySetUp; private Sdk mySdk; @Override @@ -66,8 +65,6 @@ public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { super.setUp(); UIUtil.invokeAndWaitIfNeeded(new Runnable() { public void run() { - if (myFixture == null) - mySetUp = true; Module module = myFixture.getModule(); if (module != null && !DjangoFacet.isPresent(module)) { DjangoTestCase.addDjangoFacet(module); @@ -84,18 +81,15 @@ public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { UIUtil.invokeAndWaitIfNeeded(new Runnable() { public void run() { try { - if (mySetUp) { - DjangoPathTestTask.super.tearDown(); - if (myConsoleView != null) { - Disposer.dispose(myConsoleView); - myConsoleView = null; - } - if (myDescriptor != null) { - myDescriptor.dispose(); - myDescriptor = null; - } - mySetUp = false; + if (myConsoleView != null) { + Disposer.dispose(myConsoleView); + myConsoleView = null; } + if (myDescriptor != null) { + myDescriptor.dispose(); + myDescriptor = null; + } + DjangoPathTestTask.super.tearDown(); } catch (Exception e) { throw new RuntimeException(e); @@ -110,7 +104,6 @@ public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { UIUtil.invokeAndWaitIfNeeded(new Runnable() { public void run() { mySdk = SdkConfigurationUtil.createAndAddSDK(sdkHome, PythonSdkType.getInstance()); - } }); } @@ -135,6 +128,7 @@ public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { XDebuggerTestUtil.waitForSwing(); after(); + disposeProcess(myProcessHandler); } @@ -147,7 +141,7 @@ public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { task.setWorkingDirectory(getWorkingFolder()); task.setRunnerScript(PythonHelpersLocator.getHelperPath("pycharm/django_manage.py")); final ImmutableList.Builder parametersString = - new ImmutableList.Builder().add("validate").add(getTestDataPath()); + new ImmutableList.Builder().add("validate").add(getTestDataPath()); task.setParameters(parametersString.build()); myProcessHandler = task.createProcess(); @@ -162,8 +156,8 @@ public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { public void run() { final Project project = myFixture.getProject(); new RunContentExecutor(project, myProcessHandler) - .withFilter(new PythonTracebackFilter(project)) - .run(); + .withFilter(new PythonTracebackFilter(project)) + .run(); } }); s.up(); @@ -171,7 +165,7 @@ public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { else { //run dango server and django test final Project project = getProject(); final RunnerAndConfigurationSettings settings = - RunManager.getInstance(project).createRunConfiguration("test", factory); + RunManager.getInstance(project).createRunConfiguration("test", factory); final AbstractPythonRunConfiguration config = (AbstractPythonRunConfiguration)settings.getConfiguration(); config.setSdkHome(sdkHome); From 10b893bf7d3bb41b76a5ef46e5005dba1ab6c2ab Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 5 Jul 2012 20:57:22 +0200 Subject: [PATCH 009/183] Fixed test for ipython 0.10 --- .../env/python/IPythonConsoleTest.java | 2 +- .../env/python/console/PyConsoleTask.java | 21 +++++++++++++++++-- 2 files changed, 20 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java index 14346bc90dbf..39cc5348e016 100644 --- a/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java @@ -19,7 +19,7 @@ public class IPythonConsoleTest extends PyEnvTestCase { public void testing() throws Exception { exec("import multiprocessing"); exec("multiprocessing?"); - waitForOutput("Base Class: "); + waitForOutput("Base Class:", ""); } }); } diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 2d8818086d5f..69b497d9390b 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -214,9 +214,26 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { myProcessHandler = null; } - public void waitForOutput(String string) throws InterruptedException { + /** + * Waits until all passed strings appear in output. + * If they don't appear in timelimit, then exception is raised. + * + * @param string + * @throws InterruptedException + */ + public void waitForOutput(String... string) throws InterruptedException { int count = 0; - while (!output().contains(string)) { + while (true) { + String out = output(); + boolean flag = true; + for (String s : string) { + if (!out.contains(s)) { + flag = false; + } + } + if (flag) { + break; + } if (count > 10) { Assert.fail("'" + string + "'" + " is not present in output.\n" + output()); } From 0122f004ddf052f6cbd421b0a164a90cb9ba05e5 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Fri, 6 Jul 2012 13:14:48 +0200 Subject: [PATCH 010/183] Fixed a leak in console test. --- .../env/python/console/PyConsoleTask.java | 12 +++++++++++- .../env/python/debug/PyEnvTestCase.java | 19 ++++++++++++++----- 2 files changed, 25 insertions(+), 6 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 69b497d9390b..04380fb38bdd 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -103,6 +103,16 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { } private void disposeConsole() throws InterruptedException { + if (myCommunication != null) { + try { + myCommunication.close(); + } + catch (Exception e) { + e.printStackTrace(); + } + myCommunication = null; + } + disposeConsoleProcess(); if (myConsoleView != null) { @@ -110,7 +120,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { protected void run(Result result) throws Throwable { Disposer.dispose(myConsoleView); myConsoleView = null; - myCommunication = null; + } }.execute(); } diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index 90cd9510a7d9..e49c7d3bf00e 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -73,7 +73,12 @@ public abstract class PyEnvTestCase extends UsefulTestCase { List roots = getPythonRoots(); if (roots.size() == 0) { - String msg = getTestName(false) + ": environments are not defined. Skipping. \nSpecify either " + PYCHARM_PYTHON_ENVS + " or " + PYCHARM_PYTHON_VIRTUAL_ENVS + " environment variable."; + String msg = getTestName(false) + + ": environments are not defined. Skipping. \nSpecify either " + + PYCHARM_PYTHON_ENVS + + " or " + + PYCHARM_PYTHON_VIRTUAL_ENVS + + " environment variable."; LOG.warn(msg); System.out.println(msg); return; @@ -113,19 +118,23 @@ public abstract class PyEnvTestCase extends UsefulTestCase { testTask.tearDown(); } catch (Exception e) { - e.printStackTrace(); + throw new RuntimeException("Couldn't tear down task", e); } } } if (!wasExecuted) { - throw new RuntimeException("test" + getTestName(false) + " was not executed.\n" + joinStrings(roots, "All roots: ") + "\n" + joinStrings(testTask.getTags(), "Required tags in tags.txt in root: ")); - + throw new RuntimeException("test" + + getTestName(false) + + " was not executed.\n" + + joinStrings(roots, "All roots: ") + + "\n" + + joinStrings(testTask.getTags(), "Required tags in tags.txt in root: ")); } } public static boolean notEnvConfiguration() { - return IS_UNDER_TEAMCITY && ! IS_ENV_CONFIGURATION; + return IS_UNDER_TEAMCITY && !IS_ENV_CONFIGURATION; } public static List getPythonRoots() { From b3e0b3809837023cdd67d58a970622283d3eaaa3 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Fri, 6 Jul 2012 14:11:05 +0200 Subject: [PATCH 011/183] Fixed versions. --- .../testSrc/com/jetbrains/env/python/PyPackagingTest.java | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index b1528ea5ec7f..fbe7a159c905 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -30,6 +30,8 @@ import java.util.List; */ public class PyPackagingTest extends PyTestCase { private static final Logger LOG = Logger.getInstance(PyEnvTestCase.class.getName()); + public static final String PIP_VERSION = "1.1"; + public static final String DISTRIBUTE_VERSION = "0.6.27"; public void testGetPackages() { forAllPythonEnvs(getTestName(false), new Processor() { @@ -70,11 +72,11 @@ public class PyPackagingTest extends PyTestCase { final PyPackage distribute = findPackage("distribute", packages); assertNotNull(distribute); assertEquals("distribute", distribute.getName()); - assertEquals("0.6.24", distribute.getVersion()); + assertEquals(DISTRIBUTE_VERSION, distribute.getVersion()); final PyPackage pip = findPackage("pip", packages); assertNotNull(pip); assertEquals("pip", pip.getName()); - assertEquals("1.0.2", pip.getVersion()); + assertEquals(PIP_VERSION, pip.getVersion()); } catch (IOException e) { throw new RuntimeException(e); @@ -108,7 +110,7 @@ public class PyPackagingTest extends PyTestCase { final PyPackage pip1 = findPackage("pip", packages1); assertNotNull(pip1); assertEquals("pip", pip1.getName()); - assertEquals("1.0.2", pip1.getVersion()); + assertEquals(PIP_VERSION, pip1.getVersion()); manager.uninstall(list(pip1)); final List packages3 = manager.getPackages(); final PyPackage pip2 = findPackage("pip", packages3); From 6818d49d874e9b552d2c468e10b7f9197be21d81 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Mon, 9 Jul 2012 17:40:23 +0200 Subject: [PATCH 012/183] Strings printing in tests. --- .../com/jetbrains/env/python/console/PyConsoleTask.java | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 04380fb38bdd..a900ccd322fd 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -1,5 +1,6 @@ package com.jetbrains.env.python.console; +import com.google.common.collect.Lists; import com.intellij.execution.console.LanguageConsoleViewImpl; import com.intellij.execution.process.ProcessAdapter; import com.intellij.execution.process.ProcessEvent; @@ -10,6 +11,7 @@ import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.projectRoots.SdkType; import com.intellij.openapi.projectRoots.impl.ProjectJdkImpl; import com.intellij.openapi.util.Disposer; +import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiDocumentManager; import com.intellij.util.ui.UIUtil; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; @@ -19,6 +21,7 @@ import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.NotNull; import org.junit.Assert; +import java.util.List; import java.util.concurrent.Semaphore; /** @@ -234,18 +237,20 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { public void waitForOutput(String... string) throws InterruptedException { int count = 0; while (true) { + List missing = Lists.newArrayList(); String out = output(); boolean flag = true; for (String s : string) { if (!out.contains(s)) { flag = false; + missing.add(s); } } if (flag) { break; } if (count > 10) { - Assert.fail("'" + string + "'" + " is not present in output.\n" + output()); + Assert.fail("Strings: <--\n" + StringUtil.join(missing, "\n---\n") + "-->" + "are not present in output.\n" + output()); } Thread.sleep(2000); count++; From ca2728b12959e1629f71736ae0d9b8610aa77cd1 Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Thu, 2 Aug 2012 20:59:21 +0400 Subject: [PATCH 013/183] Fixed parsing '-' in package names inside requirement URLs (PY-7034) --- .../jetbrains/env/python/PyPackagingTest.java | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index fbe7a159c905..3818c07b2002 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -146,9 +146,6 @@ public class PyPackagingTest extends PyTestCase { "django==1.3\n" + "--index-url http://example.com/\n" + "foo\n")); - // PY-6328 - assertEquals(new PyRequirement("django-haystack", "dev", "git://github.com/toastdriven/django-haystack.git@4fb267623b58", false), - PyRequirement.fromString("git://github.com/toastdriven/django-haystack.git@4fb267623b58#egg=django_haystack-dev")); } // PY-6355 @@ -167,6 +164,20 @@ public class PyPackagingTest extends PyTestCase { assertTrue(req.match(list(pkg)) != null); } + // PY-6328 + public void testNotEditableGitRequirement() { + assertEquals(new PyRequirement("django-haystack", "dev", "git://github.com/toastdriven/django-haystack.git@4fb267623b58", false), + PyRequirement.fromString("git://github.com/toastdriven/django-haystack.git@4fb267623b58#egg=django_haystack-dev")); + } + + // PY-7034 + public void testMinusInRequirementEggName() { + assertEquals(new PyRequirement("django-haystack", null, "git://github.com/toastdriven/django-haystack.git", true), + PyRequirement.fromString("-e git://github.com/toastdriven/django-haystack.git#egg=django-haystack")); + assertEquals(new PyRequirement("django-haystack", "dev", "git://github.com/toastdriven/django-haystack.git", true), + PyRequirement.fromString("-e git://github.com/toastdriven/django-haystack.git#egg=django-haystack-dev")); + } + @Nullable private static PyPackage findPackage(String name, List packages) { for (PyPackage pkg : packages) { From 06e47394774ce6f932b81ec7648c0276b7d75b14 Mon Sep 17 00:00:00 2001 From: Vassiliy Kudryashov Date: Thu, 2 Aug 2012 21:25:16 +0400 Subject: [PATCH 014/183] Memory leak in ExecutionManagerImpl --- python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java | 2 +- python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java index da3d6dafb14f..b2c007050c88 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java @@ -86,7 +86,7 @@ public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { myConsoleView = null; } if (myDescriptor != null) { - myDescriptor.dispose(); + Disposer.dispose(myDescriptor); myDescriptor = null; } DjangoPathTestTask.super.tearDown(); diff --git a/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java b/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java index 20eb9bb3cf3d..9a7b2c791174 100644 --- a/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java +++ b/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java @@ -90,7 +90,7 @@ public abstract class PyUnitTestTask extends PyExecutionFixtureTestTask { myConsoleView = null; } if (myDescriptor != null) { - myDescriptor.dispose(); + Disposer.dispose(myDescriptor); myDescriptor = null; } From e80f89fdd168e6c19fe283d81253b68de59e0813 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Wed, 8 Aug 2012 13:07:54 +0200 Subject: [PATCH 015/183] a bit of PyPackageManage in python-openapi --- .../jetbrains/env/python/PyPackagingTest.java | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index 3818c07b2002..32e01960b477 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -11,10 +11,7 @@ import com.intellij.openapi.vfs.VirtualFile; import com.intellij.util.Processor; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.python.fixtures.PyTestCase; -import com.jetbrains.python.packaging.PyExternalProcessException; -import com.jetbrains.python.packaging.PyPackage; -import com.jetbrains.python.packaging.PyPackageManager; -import com.jetbrains.python.packaging.PyRequirement; +import com.jetbrains.python.packaging.*; import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -39,11 +36,11 @@ public class PyPackagingTest extends PyTestCase { public boolean process(Sdk sdk) { List packages = null; try { - packages = PyPackageManager.getInstance(sdk).getPackages(); + packages = PyPackageManagerImpl.getInstance(sdk).getPackages(); } catch (PyExternalProcessException e) { final int retcode = e.getRetcode(); - if (retcode != PyPackageManager.ERROR_NO_PIP && retcode != PyPackageManager.ERROR_NO_DISTRIBUTE) { + if (retcode != PyPackageManagerImpl.ERROR_NO_PIP && retcode != PyPackageManagerImpl.ERROR_NO_DISTRIBUTE) { fail(String.format("Error for interpreter '%s': %s", sdk.getHomePath(), e.getMessage())); } } @@ -64,11 +61,11 @@ public class PyPackagingTest extends PyTestCase { public boolean process(Sdk sdk) { try { final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); - final String venvSdkHome = PyPackageManager.getInstance(sdk).createVirtualEnv(tempDir.toString(), false); + final String venvSdkHome = PyPackageManagerImpl.getInstance(sdk).createVirtualEnv(tempDir.toString(), false); final Sdk venvSdk = createTempSdk(venvSdkHome); assertNotNull(venvSdk); assertTrue(PythonSdkType.isVirtualEnv(venvSdk)); - final List packages = PyPackageManager.getInstance(venvSdk).getPackages(); + final List packages = PyPackageManagerImpl.getInstance(venvSdk).getPackages(); final PyPackage distribute = findPackage("distribute", packages); assertNotNull(distribute); assertEquals("distribute", distribute.getName()); @@ -95,10 +92,10 @@ public class PyPackagingTest extends PyTestCase { public boolean process(final Sdk sdk) { try { final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); - final String venvSdkHome = PyPackageManager.getInstance(sdk).createVirtualEnv(tempDir.getPath(), false); + final String venvSdkHome = PyPackageManagerImpl.getInstance(sdk).createVirtualEnv(tempDir.getPath(), false); final Sdk venvSdk = createTempSdk(venvSdkHome); assertNotNull(venvSdk); - final PyPackageManager manager = PyPackageManager.getInstance(venvSdk); + final PyPackageManagerImpl manager = PyPackageManagerImpl.getInstance(venvSdk); final List packages1 = manager.getPackages(); // TODO: Install Markdown from a local file manager.install(list(PyRequirement.fromString("Markdown<2.2"), From 2d5f533f92915f3a7a93d904cbc22fefc142e2a2 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Wed, 8 Aug 2012 13:25:22 +0200 Subject: [PATCH 016/183] PyPackageManager.getInstance() in python-openapi --- .../com/jetbrains/env/python/PyPackagingTest.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index 32e01960b477..9945f6c46aef 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -36,7 +36,7 @@ public class PyPackagingTest extends PyTestCase { public boolean process(Sdk sdk) { List packages = null; try { - packages = PyPackageManagerImpl.getInstance(sdk).getPackages(); + packages = ((PyPackageManagerImpl) PyPackageManager.getInstance(sdk)).getPackages(); } catch (PyExternalProcessException e) { final int retcode = e.getRetcode(); @@ -61,11 +61,11 @@ public class PyPackagingTest extends PyTestCase { public boolean process(Sdk sdk) { try { final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); - final String venvSdkHome = PyPackageManagerImpl.getInstance(sdk).createVirtualEnv(tempDir.toString(), false); + final String venvSdkHome = ((PyPackageManagerImpl) PyPackageManagerImpl.getInstance(sdk)).createVirtualEnv(tempDir.toString(), false); final Sdk venvSdk = createTempSdk(venvSdkHome); assertNotNull(venvSdk); assertTrue(PythonSdkType.isVirtualEnv(venvSdk)); - final List packages = PyPackageManagerImpl.getInstance(venvSdk).getPackages(); + final List packages = ((PyPackageManagerImpl) PyPackageManagerImpl.getInstance(venvSdk)).getPackages(); final PyPackage distribute = findPackage("distribute", packages); assertNotNull(distribute); assertEquals("distribute", distribute.getName()); @@ -92,10 +92,10 @@ public class PyPackagingTest extends PyTestCase { public boolean process(final Sdk sdk) { try { final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); - final String venvSdkHome = PyPackageManagerImpl.getInstance(sdk).createVirtualEnv(tempDir.getPath(), false); + final String venvSdkHome = ((PyPackageManagerImpl)PyPackageManager.getInstance(sdk)).createVirtualEnv(tempDir.getPath(), false); final Sdk venvSdk = createTempSdk(venvSdkHome); assertNotNull(venvSdk); - final PyPackageManagerImpl manager = PyPackageManagerImpl.getInstance(venvSdk); + final PyPackageManagerImpl manager = (PyPackageManagerImpl)PyPackageManager.getInstance(venvSdk); final List packages1 = manager.getPackages(); // TODO: Install Markdown from a local file manager.install(list(PyRequirement.fromString("Markdown<2.2"), From f0c0f624f26d6aea98176f77f0b2882b1c702232 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Wed, 8 Aug 2012 16:24:00 +0200 Subject: [PATCH 017/183] TemplatesService in python-openapi --- .../testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java | 5 ++--- .../testSrc/com/jetbrains/env/django/DjangoPathTestTask.java | 5 ++--- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java index 297f51d5d6ea..c9ea32ec5473 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java @@ -11,7 +11,6 @@ import com.jetbrains.django.facet.DjangoFacet; import com.jetbrains.django.fixtures.DjangoTestCase; import com.jetbrains.env.python.debug.PyDebuggerTask; import com.jetbrains.python.PythonTestUtil; -import com.jetbrains.python.templateLanguages.TemplatesConfigurationsModel; import com.jetbrains.python.templateLanguages.TemplatesService; import org.junit.Assert; @@ -46,9 +45,9 @@ public class DjangoEnvTestTask extends PyDebuggerTask { Module module = myFixture.getModule(); if (module != null && !DjangoFacet.isPresent(module)) { DjangoTestCase.addDjangoFacet(module); - TemplatesService.getInstance(module).setTemplateLanguage(TemplatesConfigurationsModel.DJANGO); + TemplatesService.getInstance(module).setTemplateLanguage(TemplatesService.DJANGO); } - TemplatesService.getInstance(module).setTemplateLanguage(TemplatesConfigurationsModel.DJANGO); + TemplatesService.getInstance(module).setTemplateLanguage(TemplatesService.DJANGO); } }); } diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java index b2c007050c88..8fa7b330c77a 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java @@ -35,7 +35,6 @@ import com.jetbrains.python.PythonTestUtil; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import com.jetbrains.python.run.PythonTracebackFilter; import com.jetbrains.python.sdk.PythonSdkType; -import com.jetbrains.python.templateLanguages.TemplatesConfigurationsModel; import com.jetbrains.python.templateLanguages.TemplatesService; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -68,9 +67,9 @@ public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { Module module = myFixture.getModule(); if (module != null && !DjangoFacet.isPresent(module)) { DjangoTestCase.addDjangoFacet(module); - TemplatesService.getInstance(module).setTemplateLanguage(TemplatesConfigurationsModel.DJANGO); + TemplatesService.getInstance(module).setTemplateLanguage(TemplatesService.DJANGO); } - TemplatesService.getInstance(module).setTemplateLanguage(TemplatesConfigurationsModel.DJANGO); + TemplatesService.getInstance(module).setTemplateLanguage(TemplatesService.DJANGO); } }); } From 286621afbef2ccc099280a2c72e873b1f0fb58fe Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 16 Aug 2012 18:02:47 +0200 Subject: [PATCH 018/183] --noreload is need for Django 1.3 in tests on Unix --- python/testSrc/com/jetbrains/env/django/DjangoPathTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java index 1215e6f8ef58..49e73cd1ac2c 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java @@ -27,6 +27,7 @@ public class DjangoPathTest extends PyEnvTestCase { protected void configure(AbstractPythonRunConfiguration config) throws IOException { final int[] ports = DjangoTemplateDebuggerTest.findFreePorts(2); ((DjangoServerRunConfiguration)config).setPort(ports[1]); + ((DjangoServerRunConfiguration)config).setRunNoReload(true); } @Override From 7303a247a750a9b4cf3630b2558a4e54093570d0 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Fri, 17 Aug 2012 17:48:34 +0200 Subject: [PATCH 019/183] Test changed to pass for IPython 0.13 --- python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java index 39cc5348e016..a9c8a1327a48 100644 --- a/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java @@ -19,7 +19,7 @@ public class IPythonConsoleTest extends PyEnvTestCase { public void testing() throws Exception { exec("import multiprocessing"); exec("multiprocessing?"); - waitForOutput("Base Class:", ""); + waitForOutput("Type:", "module"); } }); } From e074dd943fcfdf0693dc5ca375cd361b278339d2 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Fri, 17 Aug 2012 22:33:51 +0200 Subject: [PATCH 020/183] Correct shutdown of env-tests. --- .../env/django/DjangoPathTestTask.java | 15 ++++++---- .../env/python/PythonDebuggerTest.java | 1 - .../env/python/console/PyConsoleTask.java | 30 +++++++------------ .../env/python/debug/PyBaseDebuggerTask.java | 21 +++++++++---- .../env/python/debug/PyDebuggerTask.java | 16 +++++----- 5 files changed, 44 insertions(+), 39 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java index 8fa7b330c77a..ec965821f1ea 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java @@ -122,13 +122,16 @@ public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { myOutput = new StringBuilder(); runProcess(sdkHome, s); - testing(); - Assert.assertTrue(s.waitFor(60000)); + try { + testing(); + Assert.assertTrue(s.waitFor(60000)); + XDebuggerTestUtil.waitForSwing(); + after(); + } + finally { - XDebuggerTestUtil.waitForSwing(); - after(); - - disposeProcess(myProcessHandler); + disposeProcess(myProcessHandler); + } } private void runProcess(final String sdkHome, final Semaphore s) throws ExecutionException, IOException { diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index 37a76a99e795..6d3a3ba3b8ce 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -276,7 +276,6 @@ public class PythonDebuggerTest extends PyEnvTestCase { }); } - private static void addExceptionBreakpoint(IdeaProjectTestFixture fixture, PyExceptionBreakpointProperties properties) { XDebuggerTestUtil.addBreakpoint(fixture.getProject(), PyExceptionBreakpointType.class, properties); } diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index a900ccd322fd..aba99c2b0075 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -45,15 +45,6 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { setWorkingFolder(getTestDataPath()); } - public PyConsoleTask(String workingFolder, String scriptName, String scriptParameters) { - setWorkingFolder(getTestDataPath() + workingFolder); - setScriptParameters(scriptParameters); - } - - public PyConsoleTask(String workingFolder) { - this(workingFolder, null, null); - } - public PythonConsoleView getConsoleView() { return myConsoleView; } @@ -123,7 +114,6 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { protected void run(Result result) throws Throwable { Disposer.dispose(myConsoleView); myConsoleView = null; - } }.execute(); } @@ -202,17 +192,19 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { waitForOutput("PyDev console"); - testing(); - - after(); - - setProcessCanTerminate(true); - - if (myOutputPrinter != null) { - myOutputPrinter.stop(); + try { + testing(); + after(); } + finally { + setProcessCanTerminate(true); - disposeConsole(); + if (myOutputPrinter != null) { + myOutputPrinter.stop(); + } + + disposeConsole(); + } } private void disposeConsoleProcess() throws InterruptedException { diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java index f150245262b0..bd9865e18705 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java @@ -1,6 +1,8 @@ package com.jetbrains.env.python.debug; import com.google.common.collect.Sets; +import com.intellij.openapi.application.Application; +import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.application.Result; import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.project.Project; @@ -46,7 +48,6 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { setProcessCanTerminate(true); Assert.assertTrue("Debugger didn't terminated within timeout\nOutput:" + output(), waitFor(myTerminateSemaphore)); - XDebuggerTestUtil.waitForSwing(); } @@ -117,13 +118,22 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { } protected void clearAllBreakpoints() { - for (Pair bp : myBreakpoints) { - doToggleBreakpoint(bp.first, bp.second); - } + + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + new WriteAction() { + protected void run(final Result result) { + XDebuggerTestUtil.removeAllBreakpoints(getProject()); + } + }; + } + }); } /** - * Toggles breakpoint + * Toggles breakpoint + * * @param file getScriptPath() or path to script * @param line starting with 0 */ @@ -220,6 +230,7 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { if (mySession != null) { new WriteAction() { protected void run(Result result) throws Throwable { + mySession.stop(); Disposer.dispose(mySession.getConsoleView()); mySession = null; myDebugProcess = null; diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index dcdf8f06afa2..6f4694777455 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -160,22 +160,22 @@ public class PyDebuggerTask extends PyBaseDebuggerTask { try { testing(); + after(); } catch (Throwable e) { throw new RuntimeException(output(), e); } + finally { + clearAllBreakpoints(); - after(); + setProcessCanTerminate(true); - clearAllBreakpoints(); + if (myOutputPrinter != null) { + myOutputPrinter.stop(); + } - setProcessCanTerminate(true); - - if (myOutputPrinter != null) { - myOutputPrinter.stop(); + finishSession(); } - - finishSession(); } private boolean isMultiprocessDebug() { From d393d41f4a3f4bfcbba6ef55cbd4eff00d0d0a3d Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Fri, 17 Aug 2012 22:43:18 +0200 Subject: [PATCH 021/183] Fixed test of debug in reload mode for Django 1.3 --- .../env/django/DjangoTemplateDebuggerTest.java | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java index d238026a3f53..88d5316f50bd 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java @@ -1,5 +1,6 @@ package com.jetbrains.env.django; +import com.google.common.collect.Sets; import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; import com.intellij.xdebugger.XDebuggerTestUtil; import com.jetbrains.django.util.VirtualFileUtil; @@ -9,6 +10,7 @@ import com.jetbrains.python.debugger.django.DjangoExceptionBreakpointType; import java.io.IOException; import java.net.ServerSocket; +import java.util.Set; /** * @author traff @@ -335,7 +337,14 @@ public class DjangoTemplateDebuggerTest extends PyEnvTestCase { public void testBreakpointStopAndEvalInAutoReloadMode() throws IOException { final int[] ports = findFreePorts(4); - BreakpointStopAndEvalTask testTask = new BreakpointStopAndEvalTask("/djangoDebug", "manage.py", "runserver ", ports[3]); + BreakpointStopAndEvalTask testTask = new BreakpointStopAndEvalTask("/djangoDebug", "manage.py", "runserver ", ports[3]) { + @Override + public Set getTags() { + Set tags = Sets.newHashSet(super.getTags()); + tags.add("-django13"); //Django 1.3 doesn't work in reload mode on Unix + return tags; + } + }; //testTask.setShouldPrintOutput(true); testTask.setMultiprocessDebug(true); runPythonTest(testTask); From bbdf1a341a09b1e324370ac3e98c3c90fac92262 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Sat, 18 Aug 2012 20:02:10 +0200 Subject: [PATCH 022/183] That is sad, but debugger doesn't work with PyPy stable. --- python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java b/python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java index 741d5399d53b..8eb886f2965f 100644 --- a/python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java +++ b/python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java @@ -15,7 +15,7 @@ import java.util.Set; */ public class PyEnvSufficiencyTest extends PyEnvTestCase { private static final List BASE_TAGS = - ImmutableList.builder().add("python3", "django", "jython", "pypy", "ipython", "ipython011", "ipython012", "nose", "pytest").build(); + ImmutableList.builder().add("python3", "django", "jython", "ipython", "ipython011", "ipython012", "nose", "pytest").build(); public void testSufficiency() { if (IS_UNDER_TEAMCITY && IS_ENV_CONFIGURATION) { From d2973e014e366f94a2d2bafdfd7bc832748abd8f Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Mon, 20 Aug 2012 11:21:27 +0200 Subject: [PATCH 023/183] Fixed memory leak in tests. --- .../jetbrains/env/python/debug/PyBaseDebuggerTask.java | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java index bd9865e18705..71a410ec8bd7 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java @@ -231,12 +231,13 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { new WriteAction() { protected void run(Result result) throws Throwable { mySession.stop(); - Disposer.dispose(mySession.getConsoleView()); - mySession = null; - myDebugProcess = null; - myPausedSemaphore = null; } }.execute(); + + XDebuggerTestUtil.disposeDebugSession(mySession); + mySession = null; + myDebugProcess = null; + myPausedSemaphore = null; } } From 6fe5ecbe05a2f316982a49067515c2d624d45473 Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Mon, 27 Aug 2012 19:29:05 +0400 Subject: [PATCH 024/183] Fixed platform-independent SDK flavor for Python 3.3 virtualenvs --- .../com/jetbrains/env/python/PyPackagingTest.java | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index 9945f6c46aef..dd828cdad14b 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -12,7 +12,9 @@ import com.intellij.util.Processor; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.python.fixtures.PyTestCase; import com.jetbrains.python.packaging.*; +import com.jetbrains.python.sdk.PythonSdkFlavor; import com.jetbrains.python.sdk.PythonSdkType; +import com.jetbrains.python.sdk.VirtualEnvSdkFlavor; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -61,10 +63,13 @@ public class PyPackagingTest extends PyTestCase { public boolean process(Sdk sdk) { try { final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); - final String venvSdkHome = ((PyPackageManagerImpl) PyPackageManagerImpl.getInstance(sdk)).createVirtualEnv(tempDir.toString(), false); + final File venvDir = new File(tempDir, "venv"); + final String venvSdkHome = ((PyPackageManagerImpl) PyPackageManagerImpl.getInstance(sdk)).createVirtualEnv(venvDir.toString(), + false); final Sdk venvSdk = createTempSdk(venvSdkHome); assertNotNull(venvSdk); assertTrue(PythonSdkType.isVirtualEnv(venvSdk)); + assertInstanceOf(PythonSdkFlavor.getPlatformIndependentFlavor(venvSdk.getHomePath()), VirtualEnvSdkFlavor.class); final List packages = ((PyPackageManagerImpl) PyPackageManagerImpl.getInstance(venvSdk)).getPackages(); final PyPackage distribute = findPackage("distribute", packages); assertNotNull(distribute); @@ -92,7 +97,8 @@ public class PyPackagingTest extends PyTestCase { public boolean process(final Sdk sdk) { try { final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); - final String venvSdkHome = ((PyPackageManagerImpl)PyPackageManager.getInstance(sdk)).createVirtualEnv(tempDir.getPath(), false); + final File venvDir = new File(tempDir, "venv"); + final String venvSdkHome = ((PyPackageManagerImpl)PyPackageManager.getInstance(sdk)).createVirtualEnv(venvDir.getPath(), false); final Sdk venvSdk = createTempSdk(venvSdkHome); assertNotNull(venvSdk); final PyPackageManagerImpl manager = (PyPackageManagerImpl)PyPackageManager.getInstance(venvSdk); From 822366cf657ca307b8c1fddbe64f4d383b3cc6ca Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Fri, 7 Sep 2012 22:11:53 +0400 Subject: [PATCH 025/183] Added envtest of skeleton header parsing and resolve for builtins (PY-7451) --- .../env/python/PythonSkeletonsTest.java | 125 ++++++++++++++++++ .../env/python/debug/PyEnvTestCase.java | 8 +- 2 files changed, 129 insertions(+), 4 deletions(-) create mode 100644 python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java new file mode 100644 index 000000000000..27ae6e7299a9 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -0,0 +1,125 @@ +package com.jetbrains.env.python; + +import com.google.common.collect.ImmutableSet; +import com.intellij.openapi.module.Module; +import com.intellij.openapi.module.ModuleManager; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.projectRoots.SdkModificator; +import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil; +import com.intellij.openapi.roots.ModuleRootModificationUtil; +import com.intellij.openapi.roots.OrderRootType; +import com.intellij.openapi.util.io.FileUtil; +import com.intellij.openapi.vfs.LocalFileSystem; +import com.intellij.openapi.vfs.VirtualFile; +import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.python.debug.PyTestTask; +import com.jetbrains.python.fixtures.PyTestCase; +import com.jetbrains.python.inspections.PyUnresolvedReferencesInspection; +import com.jetbrains.python.psi.PyFile; +import com.jetbrains.python.psi.impl.PyBuiltinCache; +import com.jetbrains.python.sdk.InvalidSdkException; +import com.jetbrains.python.sdk.PySkeletonRefresher; +import com.jetbrains.python.sdk.PythonSdkType; +import com.jetbrains.python.sdk.SkeletonVersionChecker; +import org.jetbrains.annotations.NotNull; + +import java.io.File; +import java.io.IOException; +import java.util.List; +import java.util.Set; + +/** + * Heavyweight integration tests of skeletons of Python binary modules. + * + * An environment test environment must have a 'skeletons' tag in order to be compatible with this test case. No specific packages are + * required currently. Both Python 2 and Python 3 are OK. All platforms are OK. + * + * @author vlan + */ +public class PythonSkeletonsTest extends PyTestCase { + public static final ImmutableSet TAGS = ImmutableSet.of("skeletons"); + + public void testBuiltins() { + runTest(new SkeletonsTask() { + @Override + public void runTestOn(@NotNull Sdk sdk) { + // Check the builtin skeleton header + final PyFile builtins = PyBuiltinCache.getBuiltinsForSdk(myFixture.getProject(), sdk); + assertNotNull(builtins); + final VirtualFile virtualFile = builtins.getVirtualFile(); + assertNotNull(virtualFile); + assertTrue(virtualFile.isInLocalFileSystem()); + final String path = virtualFile.getPath(); + final PySkeletonRefresher.SkeletonHeader header = PySkeletonRefresher.readSkeletonHeader(new File(path)); + assertNotNull(header); + final int version = header.getVersion(); + assertTrue("Header version must be > 0, currently it is " + version, version > 0); + assertEquals(SkeletonVersionChecker.BUILTIN_NAME, header.getBinaryFile()); + + // Run inspections on a file that uses builtins + myFixture.configureByFile("skeletons/" + getTestName(false) + ".py"); + myFixture.enableInspections(PyUnresolvedReferencesInspection.class); + myFixture.checkHighlighting(true, false, false); + } + }); + } + + private void generateTempSkeletons(@NotNull Sdk sdk) throws InvalidSdkException, IOException { + final Project project = myFixture.getProject(); + ModuleRootModificationUtil.setModuleSdk(getSingleModule(project), sdk); + + final SdkModificator modificator = sdk.getSdkModificator(); + modificator.removeRoots(OrderRootType.CLASSES); + for (String path : PythonSdkType.getSysPathsFromScript(sdk.getHomePath())) { + PythonSdkType.addSdkRoot(modificator, path); + } + final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); + final File skeletonsDir = new File(tempDir, PythonSdkType.SKELETON_DIR_NAME); + FileUtil.createDirectory(skeletonsDir); + final String skeletonsPath = skeletonsDir.toString(); + PythonSdkType.addSdkRoot(modificator, skeletonsPath); + modificator.commitChanges(); + + final SkeletonVersionChecker checker = new SkeletonVersionChecker(0); + final PySkeletonRefresher refresher = new PySkeletonRefresher(project, sdk, skeletonsPath, null); + final List errors = refresher.regenerateSkeletons(checker, null); + assertEmpty(errors); + } + + @NotNull + private static Module getSingleModule(@NotNull Project project) { + Module[] modules = ModuleManager.getInstance(project).getModules(); + assertEquals(1, modules.length); + return modules[0]; + } + + private void runTest(@NotNull PyTestTask task) { + PyEnvTestCase.runTest(task, getTestName(false)); + } + + @NotNull + private static Sdk createTempSdk(@NotNull String sdkHome) { + final VirtualFile binary = LocalFileSystem.getInstance().findFileByPath(sdkHome); + assertNotNull("Interpreter file not found: " + sdkHome, binary); + final Sdk sdk = SdkConfigurationUtil.setupSdk(new Sdk[0], binary, PythonSdkType.getInstance(), true, null, null); + assertNotNull(sdk); + return sdk; + } + + private abstract class SkeletonsTask extends PyTestTask { + @Override + public void runTestOn(String sdkHome) throws Exception { + final Sdk sdk = createTempSdk(sdkHome); + generateTempSkeletons(sdk); + runTestOn(sdk); + } + + @Override + public Set getTags() { + return TAGS; + } + + protected abstract void runTestOn(@NotNull Sdk sdk); + } +} diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index e49c7d3bf00e..052c39e75989 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -61,10 +61,10 @@ public abstract class PyEnvTestCase extends UsefulTestCase { } public void runPythonTest(PyTestTask testTask) { - runTest(testTask); + runTest(testTask, getTestName(false)); } - private void runTest(@NotNull PyTestTask testTask) { + public static void runTest(@NotNull PyTestTask testTask, @NotNull String testName) { if (notEnvConfiguration()) { fail("Running under teamcity but not by Env configuration. Skipping."); return; @@ -73,7 +73,7 @@ public abstract class PyEnvTestCase extends UsefulTestCase { List roots = getPythonRoots(); if (roots.size() == 0) { - String msg = getTestName(false) + + String msg = testName + ": environments are not defined. Skipping. \nSpecify either " + PYCHARM_PYTHON_ENVS + " or " + @@ -125,7 +125,7 @@ public abstract class PyEnvTestCase extends UsefulTestCase { if (!wasExecuted) { throw new RuntimeException("test" + - getTestName(false) + + testName + " was not executed.\n" + joinStrings(roots, "All roots: ") + "\n" + From ba696cc2da4ecbe0cd43e7854c29d6468e61d0b7 Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Mon, 10 Sep 2012 20:39:04 +0400 Subject: [PATCH 026/183] Refactored package requirements tests for better diagnostics --- .../PyPackageRequirementsInspectionTest.java | 23 +++++++++++++++---- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java index 5285968e4ec5..581312541ca7 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java @@ -4,12 +4,16 @@ import com.intellij.openapi.module.Module; import com.intellij.openapi.module.ModuleManager; import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil; import com.intellij.openapi.roots.ModuleRootModificationUtil; +import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.testFramework.PsiTestUtil; -import com.intellij.util.Processor; +import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.python.debug.PyTestTask; import com.jetbrains.python.fixtures.PyTestCase; import com.jetbrains.python.inspections.PyPackageRequirementsInspection; +import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.NotNull; import java.io.File; @@ -33,17 +37,17 @@ public class PyPackageRequirementsInspectionTest extends PyTestCase { private void doTest(@NotNull final String filename) { final String dir = String.format("inspections/PyPackageRequirementsInspection/%s", getTestName(false)); myFixture.enableInspections(PyPackageRequirementsInspection.class); - PyPackagingTest.forAllPythonEnvs(getTestName(false), new Processor() { + PyEnvTestCase.runTest(new PyTestTask() { @Override - public boolean process(Sdk sdk) { + public void runTestOn(String sdkHome) throws Exception { + final Sdk sdk = createTempSdk(sdkHome); final String perSdkDir = Integer.toHexString(System.identityHashCode(sdk)); final VirtualFile root = myFixture.copyDirectoryToProject(dir, perSdkDir); assertNotNull(root); setupModuleSdk(getSingleModule(myFixture.getProject()), sdk, root); myFixture.testHighlighting(true, true, true, perSdkDir + File.separator + filename); - return true; } - }); + }, getTestName(false)); } @NotNull @@ -57,4 +61,13 @@ public class PyPackageRequirementsInspectionTest extends PyTestCase { ModuleRootModificationUtil.setModuleSdk(module, sdk); PsiTestUtil.addContentRoot(module, root); } + + @NotNull + private static Sdk createTempSdk(@NotNull String sdkHome) { + final VirtualFile binary = LocalFileSystem.getInstance().findFileByPath(sdkHome); + assertNotNull("Interpreter file not found: " + sdkHome, binary); + final Sdk sdk = SdkConfigurationUtil.setupSdk(new Sdk[0], binary, PythonSdkType.getInstance(), true, null, null); + assertNotNull(sdk); + return sdk; + } } From 228fb51d6ed93707bc731be66aa4635539b9923d Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Wed, 12 Sep 2012 20:46:04 +0400 Subject: [PATCH 027/183] Fixed unresolved attributes of namedtuple classes (PY-4349) --- .../env/python/PythonSkeletonsTest.java | 22 ++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index 27ae6e7299a9..488ce566e9cf 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -16,6 +16,7 @@ import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.python.debug.PyTestTask; import com.jetbrains.python.fixtures.PyTestCase; import com.jetbrains.python.inspections.PyUnresolvedReferencesInspection; +import com.jetbrains.python.psi.LanguageLevel; import com.jetbrains.python.psi.PyFile; import com.jetbrains.python.psi.impl.PyBuiltinCache; import com.jetbrains.python.sdk.InvalidSdkException; @@ -33,7 +34,7 @@ import java.util.Set; * Heavyweight integration tests of skeletons of Python binary modules. * * An environment test environment must have a 'skeletons' tag in order to be compatible with this test case. No specific packages are - * required currently. Both Python 2 and Python 3 are OK. All platforms are OK. + * required currently. Both Python 2 and Python 3 are OK. All platforms are OK. At least one Python 2.6+ environment is required. * * @author vlan */ @@ -65,6 +66,25 @@ public class PythonSkeletonsTest extends PyTestCase { }); } + // PY-4349 + public void testFakeNamedTuple() { + runTest(new SkeletonsTask() { + @Override + protected void runTestOn(@NotNull Sdk sdk) { + final LanguageLevel languageLevel = PythonSdkType.getLanguageLevelForSdk(sdk); + // Named tuples have been introduced in Python 2.6 + if (languageLevel.isOlderThan(LanguageLevel.PYTHON26)) { + return; + } + + // Run inspections on code that uses named tuples + myFixture.configureByFile("skeletons/" + getTestName(false) + ".py"); + myFixture.enableInspections(PyUnresolvedReferencesInspection.class); + myFixture.checkHighlighting(true, false, false); + } + }); + } + private void generateTempSkeletons(@NotNull Sdk sdk) throws InvalidSdkException, IOException { final Project project = myFixture.getProject(); ModuleRootModificationUtil.setModuleSdk(getSingleModule(project), sdk); From 76ff56b0371505755c1e0a2c8b4564ecea46dc33 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 27 Sep 2012 10:53:38 +0400 Subject: [PATCH 028/183] Removed obsolete setting. --- .../testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index 6f4694777455..74e3957be77f 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -61,8 +61,6 @@ public class PyDebuggerTask extends PyBaseDebuggerTask { config.setWorkingDirectory(getWorkingFolder()); config.setScriptParameters(getScriptParameters()); - config.setMultiprocessMode(isMultiprocessDebug()); - new WriteAction() { @Override protected void run(Result result) throws Throwable { @@ -80,6 +78,7 @@ public class PyDebuggerTask extends PyBaseDebuggerTask { final PythonCommandLineState pyState = (PythonCommandLineState)config.getState(executor, env); + assert pyState != null; pyState.setMultiprocessDebug(isMultiprocessDebug()); From 939f6653766bdd561511d1fb364c530d3b36f458 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 16 Oct 2012 19:09:45 +0200 Subject: [PATCH 029/183] Refatored a bit. --- .../env/python/PythonDebuggerTest.java | 1 + .../env/python/debug/PyBaseDebuggerTask.java | 22 ++++++++++++++ .../env/python/debug/PyDebuggerTask.java | 19 +----------- .../python/debug/PyRemoteDebuggerTask.java | 29 ++++--------------- 4 files changed, 30 insertions(+), 41 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index 6d3a3ba3b8ce..945144f4a593 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -17,6 +17,7 @@ import java.util.Set; /** * @author traff */ + public class PythonDebuggerTest extends PyEnvTestCase { public void testBreakpointStopAndEval() throws Exception { runPythonTest(new PyDebuggerTask("/debug", "test1.py") { diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java index 71a410ec8bd7..f45ae5c08e08 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java @@ -19,6 +19,7 @@ import com.jetbrains.python.debugger.PyDebugProcess; import com.jetbrains.python.debugger.PyDebugValue; import com.jetbrains.python.debugger.PyDebuggerException; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.junit.Assert; import java.io.PrintWriter; @@ -243,6 +244,27 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { protected abstract void disposeDebugProcess() throws InterruptedException; + protected void doTest(@Nullable OutputPrinter myOutputPrinter) throws InterruptedException { + try { + testing(); + after(); + } + catch (Throwable e) { + throw new RuntimeException(output(), e); + } + finally { + clearAllBreakpoints(); + + setProcessCanTerminate(true); + + if (myOutputPrinter != null) { + myOutputPrinter.stop(); + } + + finishSession(); + } + } + protected static class Variable { private final XTestValueNode myValueNode; diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index 74e3957be77f..0e7d83ca15cb 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -157,24 +157,7 @@ public class PyDebuggerTask extends PyBaseDebuggerTask { } }); - try { - testing(); - after(); - } - catch (Throwable e) { - throw new RuntimeException(output(), e); - } - finally { - clearAllBreakpoints(); - - setProcessCanTerminate(true); - - if (myOutputPrinter != null) { - myOutputPrinter.stop(); - } - - finishSession(); - } + doTest(myOutputPrinter); } private boolean isMultiprocessDebug() { diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java index ada431afb0d7..f33224898e22 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java @@ -167,8 +167,11 @@ public class PyRemoteDebuggerTask extends PyBaseDebuggerTask { } ProcessOutput output = - PySdkUtil.getProcessOutput(getWorkingFolder(), new String[]{sdkHome, getScriptPath(), Integer.toString(serverSocket.getLocalPort())}, new String[]{ - PythonEnvUtil.PYTHONUNBUFFERED + "=x", PythonEnvUtil.PYTHONPATH+"="+ PythonHelpersLocator.getHelpersRoot()}, 0); + PySdkUtil + .getProcessOutput(getWorkingFolder(), new String[]{sdkHome, getScriptPath(), Integer.toString(serverSocket.getLocalPort())}, + new String[]{ + PythonEnvUtil.PYTHONUNBUFFERED + "=x", + PythonEnvUtil.PYTHONPATH + "=" + PythonHelpersLocator.getHelpersRoot()}, 0); checkOutput(output); } }).start(); @@ -185,26 +188,7 @@ public class PyRemoteDebuggerTask extends PyBaseDebuggerTask { waitFor(mySessionInitializedSemaphore); - try { - testing(); - } - catch (Throwable e) { - throw new RuntimeException(output(), e); - } - - after(); - - clearAllBreakpoints(); - - setProcessCanTerminate(true); - - if (myOutputPrinter != null) - - { - myOutputPrinter.stop(); - } - - finishSession(); + doTest(myOutputPrinter); } protected void checkOutput(ProcessOutput output) { @@ -238,5 +222,4 @@ public class PyRemoteDebuggerTask extends PyBaseDebuggerTask { } } } - } From a5abf95ba8f31e8d5da82e3110e85597fc9c8696 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Wed, 17 Oct 2012 15:08:45 +0200 Subject: [PATCH 030/183] Wait for process termination before dispose in env debugger tests. --- .../com/jetbrains/env/python/debug/PyBaseDebuggerTask.java | 2 ++ .../com/jetbrains/env/python/debug/PyDebuggerTask.java | 6 ++++-- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java index f45ae5c08e08..0a595694d58a 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java @@ -235,6 +235,8 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { } }.execute(); + waitFor(mySession.getDebugProcess().getProcessHandler()); //wait for process termination after session.stop() which is async + XDebuggerTestUtil.disposeDebugSession(mySession); mySession = null; myDebugProcess = null; diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index 0e7d83ca15cb..7bde199795be 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -174,8 +174,10 @@ public class PyDebuggerTask extends PyBaseDebuggerTask { myDebugProcess.stop(); - KillableColoredProcessHandler h = (KillableColoredProcessHandler)myDebugProcess.getProcessHandler(); - if (!h.isProcessTerminated()) { + waitFor(myDebugProcess.getProcessHandler()); + + if (!myDebugProcess.getProcessHandler().isProcessTerminated()) { + KillableColoredProcessHandler h = (KillableColoredProcessHandler)myDebugProcess.getProcessHandler(); h.killProcess(); if (!waitFor(h)) { From 934b24d2f27066f785c484758f5dc3d863c73e70 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Mon, 22 Oct 2012 16:11:42 +0200 Subject: [PATCH 031/183] Add wait to destroy of console process. --- .../com/jetbrains/env/python/console/PyConsoleTask.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index aba99c2b0075..6f1b637c4748 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -209,6 +209,9 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { private void disposeConsoleProcess() throws InterruptedException { myProcessHandler.destroyProcess(); + + waitFor(myProcessHandler); + if (!myProcessHandler.isProcessTerminated()) { if (!waitFor(myProcessHandler)) { if (!myProcessHandler.isProcessTerminated()) { From e095486fcdfc866d7d87da1d4bb7971ed3ed7e34 Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Fri, 26 Oct 2012 17:53:35 +0400 Subject: [PATCH 032/183] added tests for pytest runner --- .../jetbrains/env/PythonPyTestingTest.java | 33 +++++++++++++++ .../com/jetbrains/env/ut/PyTestTestTask.java | 40 +++++++++++++++++++ 2 files changed, 73 insertions(+) create mode 100644 python/testSrc/com/jetbrains/env/PythonPyTestingTest.java create mode 100644 python/testSrc/com/jetbrains/env/ut/PyTestTestTask.java diff --git a/python/testSrc/com/jetbrains/env/PythonPyTestingTest.java b/python/testSrc/com/jetbrains/env/PythonPyTestingTest.java new file mode 100644 index 000000000000..8fe94eb680e0 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/PythonPyTestingTest.java @@ -0,0 +1,33 @@ +package com.jetbrains.env; + +import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.ut.PyTestTestTask; + +/** + * User : catherine + */ +public class PythonPyTestingTest extends PyEnvTestCase{ + public void testPytestRunner() { + runPythonTest(new PyTestTestTask("/testRunner/env/pytest", "test1.py") { + + @Override + public void after() { + assertEquals(3, allTestsCount()); + assertEquals(3, passedTestsCount()); + allTestsPassed(); + } + }); + } + + public void testPytestRunner2() { + runPythonTest(new PyTestTestTask("/testRunner/env/pytest", "test2.py") { + + @Override + public void after() { + assertEquals(8, allTestsCount()); + assertEquals(5, passedTestsCount()); + assertEquals(3, failedTestsCount()); + } + }); + } +} diff --git a/python/testSrc/com/jetbrains/env/ut/PyTestTestTask.java b/python/testSrc/com/jetbrains/env/ut/PyTestTestTask.java new file mode 100644 index 000000000000..1e4261188206 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/ut/PyTestTestTask.java @@ -0,0 +1,40 @@ +package com.jetbrains.env.ut; + +import com.google.common.collect.ImmutableSet; +import com.intellij.execution.configurations.ConfigurationFactory; +import com.intellij.openapi.project.Project; +import com.jetbrains.python.testing.AbstractPythonTestRunConfiguration; +import com.jetbrains.python.testing.PythonTestConfigurationType; +import com.jetbrains.python.testing.pytest.PyTestRunConfiguration; + +import java.util.Set; + +/** + * User : catherine + */ +public abstract class PyTestTestTask extends PyUnitTestTask { + public PyTestTestTask(String workingFolder, String scriptName, String scriptParameters) { + super(workingFolder, scriptName, scriptParameters); + } + + public PyTestTestTask(String workingFolder, String scriptName) { + this(workingFolder, scriptName, null); + } + + public void runTestOn(String sdkHome) throws Exception { + final Project project = getProject(); + final ConfigurationFactory factory = PythonTestConfigurationType.getInstance().PY_PYTEST_FACTORY; + runConfiguration(factory, sdkHome, project); + } + + @Override + public Set getTags() { + return ImmutableSet.of("pytest"); + } + + protected void configure(AbstractPythonTestRunConfiguration config) { + if (config instanceof PyTestRunConfiguration) + ((PyTestRunConfiguration)config).setTestToRun(getScriptPath()); + } + +} From 19058a00eda2f4201af32f7c4b18da61ce3fcd50 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Mon, 12 Nov 2012 14:51:41 +0100 Subject: [PATCH 033/183] moving skeleton-related stuff to a separate package --- .../testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index 488ce566e9cf..fc8288ea3537 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -20,9 +20,9 @@ import com.jetbrains.python.psi.LanguageLevel; import com.jetbrains.python.psi.PyFile; import com.jetbrains.python.psi.impl.PyBuiltinCache; import com.jetbrains.python.sdk.InvalidSdkException; -import com.jetbrains.python.sdk.PySkeletonRefresher; +import com.jetbrains.python.sdk.skeletons.PySkeletonRefresher; import com.jetbrains.python.sdk.PythonSdkType; -import com.jetbrains.python.sdk.SkeletonVersionChecker; +import com.jetbrains.python.sdk.skeletons.SkeletonVersionChecker; import org.jetbrains.annotations.NotNull; import java.io.File; From 870977b57b405d7dd87657e70f64fff8e7ed4d6c Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Mon, 19 Nov 2012 19:24:16 +0100 Subject: [PATCH 034/183] group all Python SDK flavors in a single package --- python/testSrc/com/jetbrains/env/python/PyPackagingTest.java | 4 ++-- python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index dd828cdad14b..aa8f0ed0ed0a 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -12,9 +12,9 @@ import com.intellij.util.Processor; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.python.fixtures.PyTestCase; import com.jetbrains.python.packaging.*; -import com.jetbrains.python.sdk.PythonSdkFlavor; +import com.jetbrains.python.sdk.flavors.PythonSdkFlavor; import com.jetbrains.python.sdk.PythonSdkType; -import com.jetbrains.python.sdk.VirtualEnvSdkFlavor; +import com.jetbrains.python.sdk.flavors.VirtualEnvSdkFlavor; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; diff --git a/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java b/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java index 9a7b2c791174..46140f8e6ecd 100644 --- a/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java +++ b/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java @@ -22,9 +22,9 @@ import com.intellij.openapi.util.Key; import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.XDebuggerTestUtil; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; -import com.jetbrains.python.sdk.JythonSdkFlavor; +import com.jetbrains.python.sdk.flavors.JythonSdkFlavor; import com.jetbrains.python.sdk.PythonEnvUtil; -import com.jetbrains.python.sdk.PythonSdkFlavor; +import com.jetbrains.python.sdk.flavors.PythonSdkFlavor; import com.jetbrains.python.testing.AbstractPythonTestRunConfiguration; import com.jetbrains.python.testing.PythonTestConfigurationType; import org.jetbrains.annotations.NotNull; From 46af12c1c3e5221795a48e408ae34a93a988b381 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Wed, 21 Nov 2012 20:08:27 +0100 Subject: [PATCH 035/183] ensure we have owner for remote connection when refreshing python sdk skeletons --- .../testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index fc8288ea3537..ed3dc0137d3e 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -102,7 +102,7 @@ public class PythonSkeletonsTest extends PyTestCase { modificator.commitChanges(); final SkeletonVersionChecker checker = new SkeletonVersionChecker(0); - final PySkeletonRefresher refresher = new PySkeletonRefresher(project, sdk, skeletonsPath, null); + final PySkeletonRefresher refresher = new PySkeletonRefresher(project, null, sdk, skeletonsPath, null); final List errors = refresher.regenerateSkeletons(checker, null); assertEmpty(errors); } From 95fd46259ebd0b7d8e6b7c4bcc2d7d4a5b8db6ea Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Mon, 10 Dec 2012 19:58:49 +0400 Subject: [PATCH 036/183] Fixed tear down in package requirements tests --- .../python/PyPackageRequirementsInspectionTest.java | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java index 581312541ca7..ac473a3e4e8b 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java @@ -44,8 +44,14 @@ public class PyPackageRequirementsInspectionTest extends PyTestCase { final String perSdkDir = Integer.toHexString(System.identityHashCode(sdk)); final VirtualFile root = myFixture.copyDirectoryToProject(dir, perSdkDir); assertNotNull(root); - setupModuleSdk(getSingleModule(myFixture.getProject()), sdk, root); - myFixture.testHighlighting(true, true, true, perSdkDir + File.separator + filename); + final Module module = getSingleModule(myFixture.getProject()); + setupModuleSdk(module, sdk, root); + try { + myFixture.testHighlighting(true, true, true, perSdkDir + File.separator + filename); + } + finally { + PsiTestUtil.removeAllRoots(module, sdk); + } } }, getTestName(false)); } From fc873a40be50a9de441f521dcccc9951fb14c1c4 Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Mon, 10 Dec 2012 22:04:35 +0400 Subject: [PATCH 037/183] Search for test file directly in the configured test root --- .../env/python/PyPackageRequirementsInspectionTest.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java index ac473a3e4e8b..af94377eefb9 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java @@ -16,8 +16,6 @@ import com.jetbrains.python.inspections.PyPackageRequirementsInspection; import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.NotNull; -import java.io.File; - /** * @author vlan */ @@ -47,7 +45,9 @@ public class PyPackageRequirementsInspectionTest extends PyTestCase { final Module module = getSingleModule(myFixture.getProject()); setupModuleSdk(module, sdk, root); try { - myFixture.testHighlighting(true, true, true, perSdkDir + File.separator + filename); + final VirtualFile file = root.findFileByRelativePath(filename); + assertNotNull(file); + myFixture.testHighlighting(true, true, true, file); } finally { PsiTestUtil.removeAllRoots(module, sdk); From 638ed36e975c05bbd0de56f5566a147bd7fca1cc Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Tue, 11 Dec 2012 19:24:01 +0400 Subject: [PATCH 038/183] Env tests tag 'requirements' for requirements tests --- .../python/PyPackageRequirementsInspectionTest.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java index af94377eefb9..56eb3d4f4be2 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java @@ -1,5 +1,6 @@ package com.jetbrains.env.python; +import com.google.common.collect.ImmutableSet; import com.intellij.openapi.module.Module; import com.intellij.openapi.module.ModuleManager; import com.intellij.openapi.project.Project; @@ -16,10 +17,14 @@ import com.jetbrains.python.inspections.PyPackageRequirementsInspection; import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.NotNull; +import java.util.Set; + /** * @author vlan */ public class PyPackageRequirementsInspectionTest extends PyTestCase { + public static final ImmutableSet TAGS = ImmutableSet.of("requirements"); + public void testPartiallySatisfiedRequirementsTxt() { doTest("test1.py"); } @@ -53,6 +58,11 @@ public class PyPackageRequirementsInspectionTest extends PyTestCase { PsiTestUtil.removeAllRoots(module, sdk); } } + + @Override + public Set getTags() { + return TAGS; + } }, getTestName(false)); } From 8974b579d611298ab1ed5ea11efaddc08e38de70 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Wed, 12 Dec 2012 00:09:53 +0100 Subject: [PATCH 039/183] Env test for egg debugging. --- .../env/python/PythonDebuggerTest.java | 26 +++++++++++++++++++ .../env/python/debug/PyBaseDebuggerTask.java | 23 ++++++++++++++++ .../env/python/debug/PyDebuggerTask.java | 20 ++++++++------ 3 files changed, 61 insertions(+), 8 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index 945144f4a593..a63a124d2a83 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -2,14 +2,20 @@ package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; import com.intellij.openapi.application.PathManager; +import com.intellij.openapi.util.Pair; +import com.intellij.openapi.vfs.JarFileSystem; +import com.intellij.openapi.vfs.VirtualFile; import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; +import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.XDebuggerTestUtil; +import com.jetbrains.django.util.VirtualFileUtil; import com.jetbrains.env.python.debug.PyDebuggerTask; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.ut.PyUnitTestTask; import com.jetbrains.python.console.pydev.PydevCompletionVariant; import com.jetbrains.python.debugger.PyExceptionBreakpointProperties; import com.jetbrains.python.debugger.PyExceptionBreakpointType; +import org.junit.Assert; import java.util.List; import java.util.Set; @@ -392,6 +398,26 @@ public class PythonDebuggerTest extends PyEnvTestCase { }); } + public void testEggDebug() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test_egg.py") { + @Override + public void before() throws Exception { + String egg = getFilePath("Adder-0.1.egg"); + toggleBreakpointInEgg(egg, "adder/adder.py", 2); + getRunConfiguration().getEnvs().put("PYTHONPATH", egg); + } + + @Override + public void testing() throws Exception { + waitForPause(); + eval("ret").hasValue("16"); + resume(); + } + }); + } + + + //TODO: fix me as I don't work properly sometimes (something connected with process termination on agent) //public void testResume() throws Exception { diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java index 0a595694d58a..eac187606c88 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java @@ -8,6 +8,7 @@ import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.Pair; +import com.intellij.openapi.vfs.JarFileSystem; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.*; @@ -146,6 +147,10 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { } }); + addOrRemoveBreakpoint(file, line); + } + + private void addOrRemoveBreakpoint(String file, int line) { if (myBreakpoints.contains(Pair.create(file, line))) { myBreakpoints.remove(Pair.create(file, line)); } @@ -154,6 +159,23 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { } } + protected void toggleBreakpointInEgg(final String file, final String innerPath, final int line) { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + VirtualFile f = VirtualFileUtil.findFile(file); + Assert.assertNotNull(f); + final VirtualFile jarRoot = JarFileSystem.getInstance().getJarRootForLocalFile(f); + Assert.assertNotNull(jarRoot); + VirtualFile innerFile = jarRoot.findFileByRelativePath(innerPath); + Assert.assertNotNull(innerFile); + XDebuggerTestUtil.toggleBreakpoint(getProject(), innerFile, line); + } + }); + + addOrRemoveBreakpoint(file, line); + } + public boolean canPutBreakpointAt(Project project, String file, int line) { VirtualFile vFile = VirtualFileUtil.findFile(file); Assert.assertNotNull(vFile); @@ -168,6 +190,7 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { protected Variable eval(String name) throws InterruptedException { Assert.assertTrue("Eval works only while suspended", mySession.isSuspended()); XValue var = XDebuggerTestUtil.evaluate(mySession, name).first; + Assert.assertNotNull("There is no variable named " + name, var); return new Variable(var); } diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index 7bde199795be..5159cf13b90e 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -31,6 +31,7 @@ import java.util.concurrent.Semaphore; public class PyDebuggerTask extends PyBaseDebuggerTask { private boolean myMultiprocessDebug = false; + private PythonRunConfiguration myRunConfiguration; public PyDebuggerTask() { } @@ -54,12 +55,12 @@ public class PyDebuggerTask extends PyBaseDebuggerTask { final RunnerAndConfigurationSettings settings = RunManager.getInstance(project).createRunConfiguration("test", factory); - PythonRunConfiguration config = (PythonRunConfiguration)settings.getConfiguration(); + myRunConfiguration = (PythonRunConfiguration)settings.getConfiguration(); - config.setSdkHome(sdkHome); - config.setScriptName(getScriptPath()); - config.setWorkingDirectory(getWorkingFolder()); - config.setScriptParameters(getScriptParameters()); + myRunConfiguration.setSdkHome(sdkHome); + myRunConfiguration.setScriptName(getScriptPath()); + myRunConfiguration.setWorkingDirectory(getWorkingFolder()); + myRunConfiguration.setScriptParameters(getScriptParameters()); new WriteAction() { @Override @@ -71,13 +72,13 @@ public class PyDebuggerTask extends PyBaseDebuggerTask { }.execute(); final PyDebugRunner runner = (PyDebugRunner)ProgramRunnerUtil.getRunner(DefaultDebugExecutor.EXECUTOR_ID, settings); - Assert.assertTrue(runner.canRun(DefaultDebugExecutor.EXECUTOR_ID, config)); + Assert.assertTrue(runner.canRun(DefaultDebugExecutor.EXECUTOR_ID, myRunConfiguration)); final ExecutionEnvironment env = new ExecutionEnvironment(runner, settings, project); final Executor executor = DefaultDebugExecutor.getDebugExecutorInstance(); - final PythonCommandLineState pyState = (PythonCommandLineState)config.getState(executor, env); + final PythonCommandLineState pyState = (PythonCommandLineState)myRunConfiguration.getState(executor, env); assert pyState != null; pyState.setMultiprocessDebug(isMultiprocessDebug()); @@ -95,7 +96,6 @@ public class PyDebuggerTask extends PyBaseDebuggerTask { final int serverLocalPort = serverSocket.getLocalPort(); final RunProfile profile = env.getRunProfile(); - before(); setProcessCanTerminate(false); @@ -160,6 +160,10 @@ public class PyDebuggerTask extends PyBaseDebuggerTask { doTest(myOutputPrinter); } + public PythonRunConfiguration getRunConfiguration() { + return myRunConfiguration; + } + private boolean isMultiprocessDebug() { return myMultiprocessDebug; } From 3a1a5474c9f1a2ce8bf853b678435c1185bbc571 Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Tue, 18 Dec 2012 15:18:09 +0400 Subject: [PATCH 040/183] More details for builtin skeletons test --- .../env/python/PythonSkeletonsTest.java | 24 +++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index ed3dc0137d3e..27e08442f3b4 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -12,16 +12,21 @@ import com.intellij.openapi.roots.OrderRootType; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiFile; +import com.intellij.psi.PsiReference; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.python.debug.PyTestTask; import com.jetbrains.python.fixtures.PyTestCase; import com.jetbrains.python.inspections.PyUnresolvedReferencesInspection; import com.jetbrains.python.psi.LanguageLevel; +import com.jetbrains.python.psi.PyExpression; import com.jetbrains.python.psi.PyFile; +import com.jetbrains.python.psi.PyFunction; import com.jetbrains.python.psi.impl.PyBuiltinCache; import com.jetbrains.python.sdk.InvalidSdkException; -import com.jetbrains.python.sdk.skeletons.PySkeletonRefresher; import com.jetbrains.python.sdk.PythonSdkType; +import com.jetbrains.python.sdk.skeletons.PySkeletonRefresher; import com.jetbrains.python.sdk.skeletons.SkeletonVersionChecker; import org.jetbrains.annotations.NotNull; @@ -46,7 +51,8 @@ public class PythonSkeletonsTest extends PyTestCase { @Override public void runTestOn(@NotNull Sdk sdk) { // Check the builtin skeleton header - final PyFile builtins = PyBuiltinCache.getBuiltinsForSdk(myFixture.getProject(), sdk); + final Project project = myFixture.getProject(); + final PyFile builtins = PyBuiltinCache.getBuiltinsForSdk(project, sdk); assertNotNull(builtins); final VirtualFile virtualFile = builtins.getVirtualFile(); assertNotNull(virtualFile); @@ -58,6 +64,20 @@ public class PythonSkeletonsTest extends PyTestCase { assertTrue("Header version must be > 0, currently it is " + version, version > 0); assertEquals(SkeletonVersionChecker.BUILTIN_NAME, header.getBinaryFile()); + // Resolve a single reference to built-ins + myFixture.configureByText("a.py", "len('foo')\n"); + final PyExpression expr = myFixture.findElementByText("len", PyExpression.class); + assertNotNull(expr); + final PsiReference ref = expr.getReference(); + assertNotNull(ref); + final PsiElement resolved = ref.resolve(); + assertNotNull(resolved); + assertInstanceOf(resolved, PyFunction.class); + final PyFunction len = (PyFunction)resolved; + assertEquals("len", len.getName()); + final PsiFile file = resolved.getContainingFile(); + assertEquals(builtins, file); + // Run inspections on a file that uses builtins myFixture.configureByFile("skeletons/" + getTestName(false) + ".py"); myFixture.enableInspections(PyUnresolvedReferencesInspection.class); From dad36967cade8c11d7686e1ecfd64ba46dc11df5 Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Tue, 18 Dec 2012 15:57:48 +0400 Subject: [PATCH 041/183] Checks for generated builtin files --- .../com/jetbrains/env/python/PythonSkeletonsTest.java | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index 27e08442f3b4..d1d4a50f6b68 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -24,6 +24,7 @@ import com.jetbrains.python.psi.PyExpression; import com.jetbrains.python.psi.PyFile; import com.jetbrains.python.psi.PyFunction; import com.jetbrains.python.psi.impl.PyBuiltinCache; +import com.jetbrains.python.psi.resolve.PythonSdkPathCache; import com.jetbrains.python.sdk.InvalidSdkException; import com.jetbrains.python.sdk.PythonSdkType; import com.jetbrains.python.sdk.skeletons.PySkeletonRefresher; @@ -68,6 +69,16 @@ public class PythonSkeletonsTest extends PyTestCase { myFixture.configureByText("a.py", "len('foo')\n"); final PyExpression expr = myFixture.findElementByText("len", PyExpression.class); assertNotNull(expr); + + final Sdk sdkFromPsi = PyBuiltinCache.findSdkForFile(expr.getContainingFile()); + final PyFile builtinsFromSdkCache = PythonSdkPathCache.getInstance(project, sdkFromPsi).getBuiltins().getBuiltinsFile(); + assertNotNull(builtinsFromSdkCache); + assertEquals(builtins, builtinsFromSdkCache); + + final PyFile builtinsFromPsi = PyBuiltinCache.getInstance(expr).getBuiltinsFile(); + assertNotNull(builtinsFromPsi); + assertEquals(builtins, builtinsFromPsi); + final PsiReference ref = expr.getReference(); assertNotNull(ref); final PsiElement resolved = ref.resolve(); From 7caf48fbca58869d4a1bb97ac8acb19177accd92 Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Tue, 18 Dec 2012 17:35:17 +0400 Subject: [PATCH 042/183] More checks in skeletons test --- .../com/jetbrains/env/python/PythonSkeletonsTest.java | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index d1d4a50f6b68..200e3fdbc347 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -3,6 +3,7 @@ package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; import com.intellij.openapi.module.Module; import com.intellij.openapi.module.ModuleManager; +import com.intellij.openapi.module.ModuleUtil; import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.projectRoots.SdkModificator; @@ -66,10 +67,15 @@ public class PythonSkeletonsTest extends PyTestCase { assertEquals(SkeletonVersionChecker.BUILTIN_NAME, header.getBinaryFile()); // Resolve a single reference to built-ins - myFixture.configureByText("a.py", "len('foo')\n"); + myFixture.configureByText("a.py", "len('foo')"); final PyExpression expr = myFixture.findElementByText("len", PyExpression.class); assertNotNull(expr); + final Module module = ModuleUtil.findModuleForPsiElement(expr.getContainingFile()); + assertEquals(getSingleModule(project), module); + final Sdk sdkFromModule = PythonSdkType.findPythonSdk(module); + assertNotNull(sdkFromModule); + final Sdk sdkFromPsi = PyBuiltinCache.findSdkForFile(expr.getContainingFile()); final PyFile builtinsFromSdkCache = PythonSdkPathCache.getInstance(project, sdkFromPsi).getBuiltins().getBuiltinsFile(); assertNotNull(builtinsFromSdkCache); From f1c1edce94e6073335a6ae02da054cdc0fb9dc6b Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Wed, 19 Dec 2012 15:37:36 +0400 Subject: [PATCH 043/183] moved django manage test to env test --- .../env/django/DjangoManageTest.java | 60 +++++++++++++++++++ .../env/django/DjangoPathTestTask.java | 6 +- 2 files changed, 65 insertions(+), 1 deletion(-) create mode 100644 python/testSrc/com/jetbrains/env/django/DjangoManageTest.java diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTest.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTest.java new file mode 100644 index 000000000000..04a6d28cef0c --- /dev/null +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTest.java @@ -0,0 +1,60 @@ +package com.jetbrains.env.django; + +import com.intellij.execution.ExecutionException; +import com.intellij.execution.configurations.ConfigurationFactory; +import com.jetbrains.django.manage.BaseCommand; +import com.jetbrains.django.manage.ManageTasksModel; +import com.jetbrains.django.util.ManagePyUtil; +import com.jetbrains.env.python.debug.PyEnvTestCase; +import org.apache.commons.lang.builder.ToStringBuilder; +import org.apache.commons.lang.builder.ToStringStyle; +import org.jetbrains.annotations.Nullable; + +import java.io.IOException; +import java.util.Set; + +/** + * User : ktisha + */ +public class DjangoManageTest extends PyEnvTestCase { + + public void testTaskListCompleteness() throws IOException { + runPythonTest(new DjangoPathTestTask() { + + public void testing() throws Exception { + waitForOutput("Process finished with exit code 0"); + + Set defCommands = getCommands(); + String allCommands = ToStringBuilder.reflectionToString(defCommands.toArray(), ToStringStyle.SIMPLE_STYLE); + for (BaseCommand task : ManageTasksModel.getTasks(null)) { + assertTrue(String.format("'%s' not found in a list of possible commands :%s", task.getCommand(), allCommands), + defCommands.remove(task.getCommand())); + } + defCommands.remove("startproject"); + assertEmpty( + "Not all possible commands was listed:" + ToStringBuilder.reflectionToString(defCommands.toArray(), ToStringStyle.SIMPLE_STYLE), + defCommands); + } + + public Set getCommands() throws ExecutionException { + Set result = ManagePyUtil.extractAvailableCommands(output()); + assertFalse(output(), result.isEmpty()); + result.add("createsuperuser"); + result.add("changepassword"); + + return result; + } + + @Nullable + @Override + public ConfigurationFactory getFactory() { + return null; + } + + @Override + protected String getSubcommand() { + return ""; + } + }); + } +} diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java index ec965821f1ea..bfe35b12a8c3 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java @@ -143,7 +143,7 @@ public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { task.setWorkingDirectory(getWorkingFolder()); task.setRunnerScript(PythonHelpersLocator.getHelperPath("pycharm/django_manage.py")); final ImmutableList.Builder parametersString = - new ImmutableList.Builder().add("validate").add(getTestDataPath()); + new ImmutableList.Builder().add(getSubcommand()).add(getTestDataPath()); task.setParameters(parametersString.build()); myProcessHandler = task.createProcess(); @@ -217,6 +217,10 @@ public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { } } + protected String getSubcommand() { + return "validate"; + } + protected void configure(AbstractPythonRunConfiguration config) throws IOException { } From 7371f8bb4e635aaa3f4a8c17d591f3f8bdbcfcc0 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Mon, 24 Dec 2012 16:52:28 +0100 Subject: [PATCH 044/183] Print settrace call code on starting remote debug server. --- .../com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java index f33224898e22..676ad580d5d0 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java @@ -108,7 +108,7 @@ public class PyRemoteDebuggerTask extends PyBaseDebuggerTask { public XDebugProcess start(@NotNull final XDebugSession session) { myDebugProcess = new PyRemoteDebugProcess(session, serverSocket, res.getExecutionConsole(), - res.getProcessHandler()); + res.getProcessHandler(), null); myDebugProcess.setPositionConverter(new PyRemotePositionConverter(myDebugProcess, conf.getMappingSettings())); myDebugProcess.getProcessHandler().addProcessListener(new ProcessAdapter() { From f0313f898faa9d90ce94791defcac19bd012af8b Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Tue, 22 Jan 2013 20:18:51 +0400 Subject: [PATCH 045/183] Extracted PyRequirementTest --- .../jetbrains/env/python/PyPackagingTest.java | 51 ------------------- 1 file changed, 51 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index aa8f0ed0ed0a..b1377c58c4d7 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -130,57 +130,6 @@ public class PyPackagingTest extends PyTestCase { }); } - public void testParseRequirement() { - assertEquals(new PyRequirement("Django"), PyRequirement.fromString("Django")); - assertEquals(new PyRequirement("django"), PyRequirement.fromString("django")); - assertEquals(new PyRequirement("Django", "1.3.1"), PyRequirement.fromString("Django==1.3.1")); - assertEquals(new PyRequirement("Django", list(new PyRequirement.VersionSpec(PyRequirement.Relation.LT, "1.4"))), - PyRequirement.fromString(" Django < 1.4 ")); - assertEquals(new PyRequirement("Django", list(new PyRequirement.VersionSpec(PyRequirement.Relation.LT, "1.4"), - new PyRequirement.VersionSpec(PyRequirement.Relation.GTE, "1.3.1"))), - PyRequirement.fromString(" Django < 1.4 , >= 1.3.1 ")); - assertEquals(null, PyRequirement.fromString("-e lib/django")); - assertEquals(new PyRequirement("django", null, "svn+http://code.djangoproject.com/svn/django/trunk@17672", true), - PyRequirement.fromString("-e svn+http://code.djangoproject.com/svn/django/trunk@17672#egg=django")); - assertEquals(new PyRequirement("django-haystack", "dev", "git://github.com/toastdriven/django-haystack.git@4fb267623b58", true), - PyRequirement.fromString("-e git://github.com/toastdriven/django-haystack.git@4fb267623b58#egg=django_haystack-dev")); - assertEquals(list(new PyRequirement("django", "1.3"), new PyRequirement("foo")), - PyRequirement.parse("# This is a comment\n" + - "django==1.3\n" + - "--index-url http://example.com/\n" + - "foo\n")); - } - - // PY-6355 - public void testTrailingZeroesInVersion() { - final PyRequirement req080 = PyRequirement.fromString("foo==0.8.0"); - final PyPackage pack08 = new PyPackage("foo", "0.8", null, Collections.emptyList()); - assertNotNull(req080); - assertTrue(req080.match(list(pack08)) != null); - } - - // PY-6438 - public void testUnderscoreMatchesDash() { - final PyRequirement req = PyRequirement.fromString("pyramid_zcml"); - final PyPackage pkg = new PyPackage("pyramid-zcml", "0.1", null, Collections.emptyList()); - assertNotNull(req); - assertTrue(req.match(list(pkg)) != null); - } - - // PY-6328 - public void testNotEditableGitRequirement() { - assertEquals(new PyRequirement("django-haystack", "dev", "git://github.com/toastdriven/django-haystack.git@4fb267623b58", false), - PyRequirement.fromString("git://github.com/toastdriven/django-haystack.git@4fb267623b58#egg=django_haystack-dev")); - } - - // PY-7034 - public void testMinusInRequirementEggName() { - assertEquals(new PyRequirement("django-haystack", null, "git://github.com/toastdriven/django-haystack.git", true), - PyRequirement.fromString("-e git://github.com/toastdriven/django-haystack.git#egg=django-haystack")); - assertEquals(new PyRequirement("django-haystack", "dev", "git://github.com/toastdriven/django-haystack.git", true), - PyRequirement.fromString("-e git://github.com/toastdriven/django-haystack.git#egg=django-haystack-dev")); - } - @Nullable private static PyPackage findPackage(String name, List packages) { for (PyPackage pkg : packages) { From f69498cf31af3aaa2b65250bbc5cd9800b00f7b9 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Sun, 3 Feb 2013 22:13:54 +0100 Subject: [PATCH 046/183] Python debugger settings are project settings. Button to delete dynamic types cache (PY-8136). --- .../testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index 5159cf13b90e..65b4cdc7707a 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -104,7 +104,7 @@ public class PyDebuggerTask extends PyBaseDebuggerTask { @Override protected void run(Result result) throws Throwable { final ExecutionResult res = - pyState.execute(executor, PyDebugRunner.createCommandLinePatchers(pyState, profile, serverLocalPort)); + pyState.execute(executor, PyDebugRunner.createCommandLinePatchers(myFixture.getProject(), pyState, profile, serverLocalPort)); mySession = XDebuggerManager.getInstance(getProject()). startSession(runner, env, env.getContentToReuse(), new XDebugProcessStarter() { From 1fa1e6b183bd0c32c4c1a628facc6c9a17f2591a Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 12 Feb 2013 19:06:25 +0100 Subject: [PATCH 047/183] Fixed django manage completeness test. --- .../env/django/DjangoManageTest.java | 13 +- .../env/django/DjangoManageTestTask.java | 265 ++++++++++++++++++ .../jetbrains/env/django/DjangoPathTest.java | 7 +- .../env/django/DjangoPathTestTask.java | 190 +------------ 4 files changed, 281 insertions(+), 194 deletions(-) create mode 100644 python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTest.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTest.java index 04a6d28cef0c..29622d1dd4f3 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTest.java @@ -6,6 +6,7 @@ import com.jetbrains.django.manage.BaseCommand; import com.jetbrains.django.manage.ManageTasksModel; import com.jetbrains.django.util.ManagePyUtil; import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.python.PythonTestUtil; import org.apache.commons.lang.builder.ToStringBuilder; import org.apache.commons.lang.builder.ToStringStyle; import org.jetbrains.annotations.Nullable; @@ -19,10 +20,14 @@ import java.util.Set; public class DjangoManageTest extends PyEnvTestCase { public void testTaskListCompleteness() throws IOException { - runPythonTest(new DjangoPathTestTask() { + runPythonTest(new DjangoManageTestTask() { + @Override + protected String getTestDataPath() { + return PythonTestUtil.getTestDataPath() + "/django/manage/completeness"; + } public void testing() throws Exception { - waitForOutput("Process finished with exit code 0"); + waitForOutput("Process finished with exit code"); Set defCommands = getCommands(); String allCommands = ToStringBuilder.reflectionToString(defCommands.toArray(), ToStringStyle.SIMPLE_STYLE); @@ -37,8 +42,8 @@ public class DjangoManageTest extends PyEnvTestCase { } public Set getCommands() throws ExecutionException { - Set result = ManagePyUtil.extractAvailableCommands(output()); - assertFalse(output(), result.isEmpty()); + Set result = ManagePyUtil.extractAvailableCommands(stdout() + stderr()); + assertFalse(stdout() + stderr(), result.isEmpty()); result.add("createsuperuser"); result.add("changepassword"); diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java new file mode 100644 index 000000000000..337b543391b6 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java @@ -0,0 +1,265 @@ +package com.jetbrains.env.django; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.intellij.execution.*; +import com.intellij.execution.configurations.ConfigurationFactory; +import com.intellij.execution.executors.DefaultRunExecutor; +import com.intellij.execution.process.ProcessAdapter; +import com.intellij.execution.process.ProcessEvent; +import com.intellij.execution.process.ProcessHandler; +import com.intellij.execution.process.ProcessOutputTypes; +import com.intellij.execution.runners.ExecutionEnvironment; +import com.intellij.execution.runners.ProgramRunner; +import com.intellij.execution.ui.ExecutionConsole; +import com.intellij.execution.ui.RunContentDescriptor; +import com.intellij.openapi.application.Result; +import com.intellij.openapi.application.WriteAction; +import com.intellij.openapi.module.Module; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil; +import com.intellij.openapi.util.Disposer; +import com.intellij.openapi.util.Key; +import com.intellij.openapi.vfs.LocalFileSystem; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.util.concurrency.Semaphore; +import com.intellij.util.ui.UIUtil; +import com.intellij.xdebugger.XDebuggerTestUtil; +import com.jetbrains.django.facet.DjangoFacet; +import com.jetbrains.django.fixtures.DjangoTestCase; +import com.jetbrains.django.manage.DjangoManageTask; +import com.jetbrains.django.ui.DjangoBundle; +import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; +import com.jetbrains.python.PythonHelpersLocator; +import com.jetbrains.python.run.AbstractPythonRunConfiguration; +import com.jetbrains.python.run.PythonTracebackFilter; +import com.jetbrains.python.sdk.PythonSdkType; +import com.jetbrains.python.templateLanguages.TemplatesService; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.junit.Assert; + +import java.io.IOException; +import java.util.Set; + +/** + * @author traff + */ +public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { + private StringBuilder myOutput; + private StringBuilder myStdErr; + private StringBuilder myStdOut; + + private RunContentDescriptor myDescriptor; + private ProcessHandler myProcessHandler; + private ExecutionConsole myConsoleView; + private Sdk mySdk; + + @Override + protected abstract String getTestDataPath(); + + @Override + public void setUp() throws Exception { + super.setUp(); + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + Module module = myFixture.getModule(); + if (module != null && !DjangoFacet.isPresent(module)) { + DjangoTestCase.addDjangoFacet(module); + TemplatesService.getInstance(module).setTemplateLanguage(TemplatesService.DJANGO); + } + TemplatesService.getInstance(module).setTemplateLanguage(TemplatesService.DJANGO); + } + }); + } + + @Override + public void tearDown() throws Exception { + TemplatesService.getInstance(myFixture.getModule()).setTemplateLanguage(TemplatesService.NONE); + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + try { + if (myConsoleView != null) { + Disposer.dispose(myConsoleView); + myConsoleView = null; + } + if (myDescriptor != null) { + Disposer.dispose(myDescriptor); + myDescriptor = null; + } + DjangoManageTestTask.super.tearDown(); + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + }); + } + + private void createTempSdk(@NotNull final String sdkHome) { + final VirtualFile binary = LocalFileSystem.getInstance().findFileByPath(sdkHome); + if (binary != null) { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + mySdk = SdkConfigurationUtil.createAndAddSDK(sdkHome, PythonSdkType.getInstance()); + } + }); + } + } + + @Nullable + public abstract ConfigurationFactory getFactory(); + + @Override + public void runTestOn(final String sdkHome) throws Exception { + createTempSdk(sdkHome); + before(); + + final Semaphore s = new Semaphore(); + s.down(); + + myOutput = new StringBuilder(); + runProcess(sdkHome, s); + + try { + testing(); + Assert.assertTrue(s.waitFor(60000)); + XDebuggerTestUtil.waitForSwing(); + after(); + } + finally { + + disposeProcess(myProcessHandler); + } + } + + private void runProcess(final String sdkHome, final Semaphore s) throws ExecutionException, IOException { + final ConfigurationFactory factory = getFactory(); + if (factory == null) { // PythonTask (there is no run configuration) + final Module module = myFixture.getModule(); + final DjangoManageTask task = new DjangoManageTask(module, DjangoBundle.message("manage.run.tab.name"), mySdk); + + task.setWorkingDirectory(getWorkingFolder()); + task.setRunnerScript(PythonHelpersLocator.getHelperPath("pycharm/django_manage.py")); + ImmutableList.Builder parametersString = + new ImmutableList.Builder().add(getSubcommand()).add(getTestDataPath()); + + task.setParameters(parametersString.build()); + + myProcessHandler = task.createProcess(); + myOutput = new StringBuilder(); + myStdErr = new StringBuilder(); + myStdOut = new StringBuilder(); + + myProcessHandler.addProcessListener(createProcessListener()); + + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + final Project project = myFixture.getProject(); + new RunContentExecutor(project, myProcessHandler) + .withFilter(new PythonTracebackFilter(project)) + .run(); + } + }); + s.up(); + } + else { //run dango server and django test + final Project project = getProject(); + final RunnerAndConfigurationSettings settings = + RunManager.getInstance(project).createRunConfiguration("test", factory); + + final AbstractPythonRunConfiguration config = (AbstractPythonRunConfiguration)settings.getConfiguration(); + config.setSdkHome(sdkHome); + config.setWorkingDirectory(getWorkingFolder()); + configure(config); + + new WriteAction() { + @Override + protected void run(Result result) throws Throwable { + RunManagerEx.getInstanceEx(project).addConfiguration(settings, false); + RunManagerEx.getInstanceEx(project).setSelectedConfiguration(settings); + Assert.assertSame(settings, RunManagerEx.getInstanceEx(project).getSelectedConfiguration()); + } + }.execute(); + + final ProgramRunner runner = ProgramRunnerUtil.getRunner(DefaultRunExecutor.EXECUTOR_ID, settings); + + Assert.assertTrue(runner.canRun(DefaultRunExecutor.EXECUTOR_ID, config)); + + final ExecutionEnvironment env = new ExecutionEnvironment(runner, settings, project); + final Executor executor = DefaultRunExecutor.getRunExecutorInstance(); + + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + try { + runner.execute(executor, env, new ProgramRunner.Callback() { + @Override + public void processStarted(RunContentDescriptor descriptor) { + myDescriptor = descriptor; + myProcessHandler = myDescriptor.getProcessHandler(); + myProcessHandler.addProcessListener(createProcessListener()); + myConsoleView = myDescriptor.getExecutionConsole(); + s.up(); + } + }); + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + }); + } + } + + private ProcessAdapter createProcessListener() { + return new ProcessAdapter() { + @Override + public void onTextAvailable(ProcessEvent event, Key outputType) { + myOutput.append(event.getText()); + if (outputType == ProcessOutputTypes.STDOUT) { + myStdOut.append(event.getText()); + } + else if (outputType == ProcessOutputTypes.STDERR) { + myStdErr.append(event.getText()); + } + } + }; + } + + protected abstract String getSubcommand(); + + protected void configure(AbstractPythonRunConfiguration config) throws IOException { + } + + @NotNull + protected String output() { + return myOutput.toString(); + } + + @NotNull + protected String stderr() { + return myStdErr.toString(); + } + + @NotNull + protected String stdout() { + return myStdOut.toString(); + } + + public void waitForOutput(@NotNull final String string) throws InterruptedException { + int count = 0; + while (!output().contains(string)) { + if (count > 10) { + Assert.fail("'" + string + "'" + " is not present in output.\n" + output()); + } + Thread.sleep(2000); + count++; + } + } + + @Override + public Set getTags() { + return ImmutableSet.of("django"); + } +} diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java index 49e73cd1ac2c..f53062ca4a7b 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java @@ -20,6 +20,11 @@ import java.util.ArrayList; */ public class DjangoPathTest extends PyEnvTestCase { + /** + * This string is printed after printing sys.path in djangoPath/settings.py + */ + public static final String THE_END_OF_SYS_PATH = "The end of sys.path"; + public void testRunserverPath() throws IOException { runPythonTest(new DjangoPathTestTask() { @@ -48,7 +53,7 @@ public class DjangoPathTest extends PyEnvTestCase { final String[] splittedOutput = output.split("\\n"); final ArrayList outputList = Lists.newArrayList(); for (String s : splittedOutput) { - if (s.equals("The end of sys.path")) { + if (s.equals(THE_END_OF_SYS_PATH)) { break; } outputList.add(norm(s)); diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java index bfe35b12a8c3..c63b37ed9c02 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java @@ -46,13 +46,7 @@ import java.util.Set; /** * User : catherine */ -public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { - - private StringBuilder myOutput; - private RunContentDescriptor myDescriptor; - private ProcessHandler myProcessHandler; - private ExecutionConsole myConsoleView; - private Sdk mySdk; +public abstract class DjangoPathTestTask extends DjangoManageTestTask { @Override protected String getTestDataPath() { @@ -60,189 +54,7 @@ public abstract class DjangoPathTestTask extends PyExecutionFixtureTestTask { } @Override - public void setUp() throws Exception { - super.setUp(); - UIUtil.invokeAndWaitIfNeeded(new Runnable() { - public void run() { - Module module = myFixture.getModule(); - if (module != null && !DjangoFacet.isPresent(module)) { - DjangoTestCase.addDjangoFacet(module); - TemplatesService.getInstance(module).setTemplateLanguage(TemplatesService.DJANGO); - } - TemplatesService.getInstance(module).setTemplateLanguage(TemplatesService.DJANGO); - } - }); - } - - @Override - public void tearDown() throws Exception { - TemplatesService.getInstance(myFixture.getModule()).setTemplateLanguage(TemplatesService.NONE); - UIUtil.invokeAndWaitIfNeeded(new Runnable() { - public void run() { - try { - if (myConsoleView != null) { - Disposer.dispose(myConsoleView); - myConsoleView = null; - } - if (myDescriptor != null) { - Disposer.dispose(myDescriptor); - myDescriptor = null; - } - DjangoPathTestTask.super.tearDown(); - } - catch (Exception e) { - throw new RuntimeException(e); - } - } - }); - } - - private void createTempSdk(@NotNull final String sdkHome) { - final VirtualFile binary = LocalFileSystem.getInstance().findFileByPath(sdkHome); - if (binary != null) { - UIUtil.invokeAndWaitIfNeeded(new Runnable() { - public void run() { - mySdk = SdkConfigurationUtil.createAndAddSDK(sdkHome, PythonSdkType.getInstance()); - } - }); - } - } - - @Nullable - public abstract ConfigurationFactory getFactory(); - - @Override - public void runTestOn(final String sdkHome) throws Exception { - createTempSdk(sdkHome); - before(); - - final Semaphore s = new Semaphore(); - s.down(); - - myOutput = new StringBuilder(); - runProcess(sdkHome, s); - - try { - testing(); - Assert.assertTrue(s.waitFor(60000)); - XDebuggerTestUtil.waitForSwing(); - after(); - } - finally { - - disposeProcess(myProcessHandler); - } - } - - private void runProcess(final String sdkHome, final Semaphore s) throws ExecutionException, IOException { - final ConfigurationFactory factory = getFactory(); - if (factory == null) { // PythonTask (there is no run configuration) - final Module module = myFixture.getModule(); - final DjangoManageTask task = new DjangoManageTask(module, DjangoBundle.message("manage.run.tab.name"), mySdk); - - task.setWorkingDirectory(getWorkingFolder()); - task.setRunnerScript(PythonHelpersLocator.getHelperPath("pycharm/django_manage.py")); - final ImmutableList.Builder parametersString = - new ImmutableList.Builder().add(getSubcommand()).add(getTestDataPath()); - task.setParameters(parametersString.build()); - - myProcessHandler = task.createProcess(); - myOutput = new StringBuilder(); - myProcessHandler.addProcessListener(new ProcessAdapter() { - @Override - public void onTextAvailable(ProcessEvent event, Key outputType) { - myOutput.append(event.getText()); - } - }); - UIUtil.invokeAndWaitIfNeeded(new Runnable() { - public void run() { - final Project project = myFixture.getProject(); - new RunContentExecutor(project, myProcessHandler) - .withFilter(new PythonTracebackFilter(project)) - .run(); - } - }); - s.up(); - } - else { //run dango server and django test - final Project project = getProject(); - final RunnerAndConfigurationSettings settings = - RunManager.getInstance(project).createRunConfiguration("test", factory); - - final AbstractPythonRunConfiguration config = (AbstractPythonRunConfiguration)settings.getConfiguration(); - config.setSdkHome(sdkHome); - config.setWorkingDirectory(getWorkingFolder()); - configure(config); - - new WriteAction() { - @Override - protected void run(Result result) throws Throwable { - RunManagerEx.getInstanceEx(project).addConfiguration(settings, false); - RunManagerEx.getInstanceEx(project).setSelectedConfiguration(settings); - Assert.assertSame(settings, RunManagerEx.getInstanceEx(project).getSelectedConfiguration()); - } - }.execute(); - - final ProgramRunner runner = ProgramRunnerUtil.getRunner(DefaultRunExecutor.EXECUTOR_ID, settings); - - Assert.assertTrue(runner.canRun(DefaultRunExecutor.EXECUTOR_ID, config)); - - final ExecutionEnvironment env = new ExecutionEnvironment(runner, settings, project); - final Executor executor = DefaultRunExecutor.getRunExecutorInstance(); - - UIUtil.invokeAndWaitIfNeeded(new Runnable() { - public void run() { - try { - runner.execute(executor, env, new ProgramRunner.Callback() { - @Override - public void processStarted(RunContentDescriptor descriptor) { - myDescriptor = descriptor; - myProcessHandler = myDescriptor.getProcessHandler(); - myProcessHandler.addProcessListener(new ProcessAdapter() { - @Override - public void onTextAvailable(ProcessEvent event, Key outputType) { - myOutput.append(event.getText()); - } - }); - myConsoleView = myDescriptor.getExecutionConsole(); - s.up(); - } - }); - } - catch (Exception e) { - throw new RuntimeException(e); - } - } - }); - } - } - protected String getSubcommand() { return "validate"; } - - protected void configure(AbstractPythonRunConfiguration config) throws IOException { - } - - @NotNull - protected String output() { - return myOutput.toString(); - } - - - public void waitForOutput(@NotNull final String string) throws InterruptedException { - int count = 0; - while (!output().contains(string)) { - if (count > 10) { - Assert.fail("'" + string + "'" + " is not present in output.\n" + output()); - } - Thread.sleep(2000); - count++; - } - } - - @Override - public Set getTags() { - return ImmutableSet.of("django"); - } } From e3c1b51436d62b67b6cfe53f7170fbb698ee438d Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 12 Feb 2013 19:49:45 +0100 Subject: [PATCH 048/183] Fixed path tests. --- .../com/jetbrains/env/django/DjangoManageTestTask.java | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java index 337b543391b6..85537a4093cb 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java @@ -119,7 +119,11 @@ public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { final Semaphore s = new Semaphore(); s.down(); + myOutput = new StringBuilder(); + myStdErr = new StringBuilder(); + myStdOut = new StringBuilder(); + runProcess(sdkHome, s); try { @@ -136,6 +140,7 @@ public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { private void runProcess(final String sdkHome, final Semaphore s) throws ExecutionException, IOException { final ConfigurationFactory factory = getFactory(); + if (factory == null) { // PythonTask (there is no run configuration) final Module module = myFixture.getModule(); final DjangoManageTask task = new DjangoManageTask(module, DjangoBundle.message("manage.run.tab.name"), mySdk); @@ -148,9 +153,6 @@ public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { task.setParameters(parametersString.build()); myProcessHandler = task.createProcess(); - myOutput = new StringBuilder(); - myStdErr = new StringBuilder(); - myStdOut = new StringBuilder(); myProcessHandler.addProcessListener(createProcessListener()); From 7d61205736fa4c5ac6971c27971db86f63b4c9d0 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 14 Feb 2013 17:31:26 +0100 Subject: [PATCH 049/183] Fixed tests. Refactored setting python path. --- .../env/python/PythonDebuggerTest.java | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index a63a124d2a83..ebdd2f10204d 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -1,6 +1,7 @@ package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Lists; import com.intellij.openapi.application.PathManager; import com.intellij.openapi.util.Pair; import com.intellij.openapi.vfs.JarFileSystem; @@ -15,6 +16,10 @@ import com.jetbrains.env.ut.PyUnitTestTask; import com.jetbrains.python.console.pydev.PydevCompletionVariant; import com.jetbrains.python.debugger.PyExceptionBreakpointProperties; import com.jetbrains.python.debugger.PyExceptionBreakpointType; +import com.jetbrains.python.sdk.PySdkUtil; +import com.jetbrains.python.sdk.PythonSdkType; +import com.jetbrains.python.sdk.flavors.JythonSdkFlavor; +import com.jetbrains.python.sdk.flavors.PythonSdkFlavor; import org.junit.Assert; import java.util.List; @@ -256,6 +261,11 @@ public class PythonDebuggerTest extends PyEnvTestCase { input("GO!"); waitForOutput("command was GO!"); } + + @Override + public Set getTags() { + return ImmutableSet.of("-jython"); //can't run on jython + } }); } @@ -404,7 +414,12 @@ public class PythonDebuggerTest extends PyEnvTestCase { public void before() throws Exception { String egg = getFilePath("Adder-0.1.egg"); toggleBreakpointInEgg(egg, "adder/adder.py", 2); - getRunConfiguration().getEnvs().put("PYTHONPATH", egg); + PythonSdkFlavor flavor = PythonSdkFlavor.getFlavor(getRunConfiguration().getSdkHome()); + if (flavor != null) { + flavor.initPythonPath(Lists.newArrayList(egg), getRunConfiguration().getEnvs()); + } else { + getRunConfiguration().getEnvs().put("PYTHONPATH", egg); + } } @Override @@ -417,8 +432,6 @@ public class PythonDebuggerTest extends PyEnvTestCase { } - - //TODO: fix me as I don't work properly sometimes (something connected with process termination on agent) //public void testResume() throws Exception { // runPythonTest(new PyDebuggerTask("/debug", "Test_Resume.py") { From b0bce2eb31177e949183d26e8264170b50030793 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Sat, 16 Feb 2013 22:20:11 +0100 Subject: [PATCH 050/183] Env tests work with remote python interpreters. --- .../env/PyTestRemoteSdkProvider.java | 111 +++++++++++++ .../com/jetbrains/env/RemoteSdkTestable.java | 7 + .../env/django/DjangoManageTestTask.java | 19 ++- .../env/python/console/PyConsoleTask.java | 31 ++-- .../env/python/debug/PyDebuggerTask.java | 26 ++- .../env/python/debug/PyEnvTestCase.java | 154 ++++++++++++++---- 6 files changed, 286 insertions(+), 62 deletions(-) create mode 100644 python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java create mode 100644 python/testSrc/com/jetbrains/env/RemoteSdkTestable.java diff --git a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java new file mode 100644 index 000000000000..91d980c53d09 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java @@ -0,0 +1,111 @@ +package com.jetbrains.env; + +import com.google.common.cache.CacheBuilder; +import com.google.common.cache.CacheLoader; +import com.google.common.cache.LoadingCache; +import com.google.common.collect.Lists; +import com.google.common.hash.HashFunction; +import com.google.common.hash.Hashing; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.util.SystemInfo; +import com.intellij.openapi.util.io.FileUtil; +import com.intellij.openapi.util.text.StringHash; +import com.intellij.remotesdk.RemoteInterpreterException; +import com.jetbrains.python.remote.PyRemoteInterpreterManagerImpl; +import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; +import gnu.trove.HashFunctions; +import org.apache.commons.lang.StringUtils; +import org.jetbrains.annotations.NonNls; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.io.File; +import java.io.IOException; +import java.util.concurrent.ExecutionException; + +/** + * @author traff + */ +public class PyTestRemoteSdkProvider { + public static final String SSH_PASSWORD = "SSH_PASSWORD"; + public static final String LOCAL_SSH_WITHOUT_PASSWORD = "LOCAL_SSH_WITHOUT_PASSWORD"; + private final PyRemoteInterpreterManagerImpl myInterpreterManager; + private static final String SSH_USER_NAME = "SSH_USER_NAME"; + + private Project myProject; + + private static PyTestRemoteSdkProvider INSTANCE = null; + + public synchronized static PyTestRemoteSdkProvider getInstance() { + if (INSTANCE == null) { + INSTANCE = new PyTestRemoteSdkProvider(); + } + return INSTANCE; + } + + public PyTestRemoteSdkProvider() { + myInterpreterManager = new PyRemoteInterpreterManagerImpl(); + } + + private final LoadingCache mySdkTable = CacheBuilder.newBuilder() + .build( + new CacheLoader() { + @Override + public Sdk load(String key) throws Exception { + return createSdk(key); + } + }); + + public Sdk getSdk(Project project, String sdkPath) throws ExecutionException { + myProject = project; + return mySdkTable.get(sdkPath); + } + + private Sdk createSdk(String interpreterPath) throws RemoteInterpreterException { + try { + PyRemoteSdkAdditionalData data = createRemoteSdkData(interpreterPath); + Sdk sdk = myInterpreterManager.createRemoteSdk(myProject, data, null, Lists.newArrayList()); + myInterpreterManager.initSdk(sdk, myProject, null); + return sdk; + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + + private PyRemoteSdkAdditionalData createRemoteSdkData(String path) throws IOException { + PyRemoteSdkAdditionalData data = new PyRemoteSdkAdditionalData(path); + data.setHost("localhost"); + data.setPort(22); + data.setUserName(getUserName()); + data.setPassword(getPassword()); + data.setHelpersPath(getHelpersPath(data)); + return data; + } + + public static boolean canRunRemoteSdk() { + return SystemInfo.isUnix && isPasswordSpecified(); + } + + private static boolean isPasswordSpecified() { + return !StringUtils.isEmpty(System.getenv(LOCAL_SSH_WITHOUT_PASSWORD)) || !StringUtils.isEmpty(getPassword()); + } + + private static String getHelpersPath(PyRemoteSdkAdditionalData data) throws IOException { + final File dir = new File("/tmp"); + + File tmpDir = FileUtil.createTempDirectory(dir, "pycharm_helpers_", "_" + Math.abs( + Hashing.md5().hashString(data.getFullInterpreterPath()).asInt()), true); + return tmpDir.getPath(); + } + + public static String getUserName() { + String userName = System.getenv(SSH_USER_NAME); + return StringUtils.isEmpty(userName) ? System.getProperty("user.name") : userName; + } + + public static String getPassword() { + return System.getenv(SSH_PASSWORD); + } +} diff --git a/python/testSrc/com/jetbrains/env/RemoteSdkTestable.java b/python/testSrc/com/jetbrains/env/RemoteSdkTestable.java new file mode 100644 index 000000000000..c60202ae3257 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/RemoteSdkTestable.java @@ -0,0 +1,7 @@ +package com.jetbrains.env; + +/** + * @author traff + */ +public interface RemoteSdkTestable { +} diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java index 85537a4093cb..931e08295412 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java @@ -98,13 +98,18 @@ public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { } private void createTempSdk(@NotNull final String sdkHome) { - final VirtualFile binary = LocalFileSystem.getInstance().findFileByPath(sdkHome); - if (binary != null) { - UIUtil.invokeAndWaitIfNeeded(new Runnable() { - public void run() { - mySdk = SdkConfigurationUtil.createAndAddSDK(sdkHome, PythonSdkType.getInstance()); - } - }); + + mySdk = PythonSdkType.findSdkByPath(sdkHome); + + if (mySdk == null) { + final VirtualFile binary = LocalFileSystem.getInstance().findFileByPath(sdkHome); + if (binary != null) { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + mySdk = SdkConfigurationUtil.createAndAddSDK(sdkHome, PythonSdkType.getInstance()); + } + }); + } } } diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 6f1b637c4748..7d43bbfb2809 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -8,7 +8,6 @@ import com.intellij.openapi.application.Result; import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; -import com.intellij.openapi.projectRoots.SdkType; import com.intellij.openapi.projectRoots.impl.ProjectJdkImpl; import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.text.StringUtil; @@ -122,19 +121,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { public void runTestOn(final String sdkHome) throws Exception { final Project project = getProject(); - SdkType sdkType = PythonSdkType.getInstance(); - - final Sdk sdk = new ProjectJdkImpl("Python Test Sdk " + sdkHome, sdkType) { - @Override - public String getHomePath() { - return sdkHome; - } - - @Override - public String getVersionString() { - return "Python 2 Mock SDK"; - } - }; + final Sdk sdk = getSdk(sdkHome); setProcessCanTerminate(false); @@ -207,6 +194,22 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { } } + private Sdk getSdk(final String sdkHome) { + Sdk sdk = PythonSdkType.findSdkByPath(sdkHome); + + return sdk != null ? sdk : new ProjectJdkImpl("Python Test Sdk " + sdkHome, PythonSdkType.getInstance()) { + @Override + public String getHomePath() { + return sdkHome; + } + + @Override + public String getVersionString() { + return "Python 2 Mock SDK"; + } + }; + } + private void disposeConsoleProcess() throws InterruptedException { myProcessHandler.destroyProcess(); diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index 65b4cdc7707a..24408a72dc8c 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -7,12 +7,14 @@ import com.intellij.execution.executors.DefaultDebugExecutor; import com.intellij.execution.process.KillableColoredProcessHandler; import com.intellij.execution.process.ProcessAdapter; import com.intellij.execution.process.ProcessEvent; +import com.intellij.execution.process.ProcessHandler; import com.intellij.execution.runners.ExecutionEnvironment; import com.intellij.openapi.application.Result; import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Key; import com.intellij.xdebugger.*; +import com.jetbrains.env.RemoteSdkTestable; import com.jetbrains.python.debugger.PyDebugProcess; import com.jetbrains.python.debugger.PyDebugRunner; import com.jetbrains.python.run.PythonCommandLineState; @@ -28,7 +30,7 @@ import java.util.concurrent.Semaphore; /** * @author traff */ -public class PyDebuggerTask extends PyBaseDebuggerTask { +public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTestable { private boolean myMultiprocessDebug = false; private PythonRunConfiguration myRunConfiguration; @@ -175,19 +177,29 @@ public class PyDebuggerTask extends PyBaseDebuggerTask { @Override protected void disposeDebugProcess() throws InterruptedException { if (myDebugProcess != null) { + ProcessHandler processHandler = myDebugProcess.getProcessHandler(); myDebugProcess.stop(); - waitFor(myDebugProcess.getProcessHandler()); + waitFor(processHandler); - if (!myDebugProcess.getProcessHandler().isProcessTerminated()) { - KillableColoredProcessHandler h = (KillableColoredProcessHandler)myDebugProcess.getProcessHandler(); - - h.killProcess(); - if (!waitFor(h)) { + if (!processHandler.isProcessTerminated()) { + killDebugProcess(); + if (!waitFor(processHandler)) { new Throwable("Cannot stop debugger process").printStackTrace(); } } } } + + private void killDebugProcess() { + if (myDebugProcess.getProcessHandler() instanceof KillableColoredProcessHandler) { + KillableColoredProcessHandler h = (KillableColoredProcessHandler)myDebugProcess.getProcessHandler(); + + h.killProcess(); + } + else { + myDebugProcess.getProcessHandler().destroyProcess(); + } + } } diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index 052c39e75989..f5c02021fe0a 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -4,12 +4,19 @@ import com.google.common.collect.Lists; import com.google.common.collect.Sets; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.projectRoots.ProjectJdkTable; +import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.util.text.StringUtil; import com.intellij.testFramework.UsefulTestCase; import com.intellij.util.ui.UIUtil; +import com.jetbrains.env.PyTestRemoteSdkProvider; +import com.jetbrains.env.RemoteSdkTestable; import com.jetbrains.python.fixtures.PyTestCase; +import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import java.io.File; import java.io.IOException; @@ -84,52 +91,131 @@ public abstract class PyEnvTestCase extends UsefulTestCase { return; } - boolean wasExecuted = false; - List passedRoots = Lists.newArrayList(); + TaskRunner taskRunner = new TaskRunner(roots); - for (String env : roots) { + taskRunner.runTask(testTask, testName); - if (!isSuitableForTask(loadEnvTags(env), testTask)) { - continue; + if (testTask instanceof RemoteSdkTestable) { + if (PyTestRemoteSdkProvider.canRunRemoteSdk()) { + taskRunner = new RemoteTaskRunner(roots); + taskRunner.runTask(testTask, testName); } + else { + fail("Cant run with remote sdk: password isn't set"); + } + } + } - try { - testTask.setUp(); - wasExecuted = true; - if (isJython(env)) { - testTask.useLongTimeout(); + + private static class TaskRunner { + private final List myRoots; + + private TaskRunner(List roots) { + myRoots = roots; + } + + public void runTask(PyTestTask testTask, String testName) { + boolean wasExecuted = false; + + List passedRoots = Lists.newArrayList(); + + for (String root : myRoots) { + + if (!isSuitableForTask(loadEnvTags(root), testTask) || !shouldRun(root, testTask)) { + continue; } - else { - testTask.useNormalTimeout(); - } - final String executable = PythonSdkType.getPythonExecutable(env); - if (executable == null) { - throw new RuntimeException("Cannot find Python interpreter in " + env); - } - testTask.runTestOn(executable); - passedRoots.add(env); - } - catch (Throwable e) { - throw new RuntimeException(joinStrings(passedRoots, "Tests passed environments: ") + "Test failed on environment " + env, e); - } - finally { + try { - testTask.tearDown(); + testTask.setUp(); + wasExecuted = true; + if (isJython(root)) { + testTask.useLongTimeout(); + } + else { + testTask.useNormalTimeout(); + } + final String executable = getExecutable(root, testTask); + if (executable == null) { + throw new RuntimeException("Cannot find Python interpreter in " + root); + } + testTask.runTestOn(executable); + passedRoots.add(root); } - catch (Exception e) { - throw new RuntimeException("Couldn't tear down task", e); + catch (Throwable e) { + throw new RuntimeException(joinStrings(passedRoots, "Tests passed environments: ") + "Test failed on environment " + root, e); } + finally { + try { + testTask.tearDown(); + } + catch (Exception e) { + throw new RuntimeException("Couldn't tear down task", e); + } + } + } + + if (!wasExecuted) { + throw new RuntimeException("test" + + testName + + " was not executed.\n" + + joinStrings(myRoots, "All roots: ") + + "\n" + + joinStrings(testTask.getTags(), "Required tags in tags.txt in root: ")); } } - if (!wasExecuted) { - throw new RuntimeException("test" + - testName + - " was not executed.\n" + - joinStrings(roots, "All roots: ") + - "\n" + - joinStrings(testTask.getTags(), "Required tags in tags.txt in root: ")); + protected boolean shouldRun(String root, PyTestTask task) { + return true; + } + + protected String getExecutable(String root, PyTestTask testTask) { + return PythonSdkType.getPythonExecutable(root); + } + } + + private static class RemoteTaskRunner extends TaskRunner { + private RemoteTaskRunner(List roots) { + super(roots); + } + + @Override + protected String getExecutable(String root, PyTestTask testTask) { + try { + final Sdk sdk = PyTestRemoteSdkProvider.getInstance().getSdk(getProject(testTask), super.getExecutable(root, testTask)); + + if (ProjectJdkTable.getInstance().findJdk(sdk.getName()) == null) { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + ApplicationManager.getApplication().runWriteAction(new Runnable() { + @Override + public void run() { + ProjectJdkTable.getInstance().addJdk(sdk); + } + }); + } + }); + } + + return ((PyRemoteSdkAdditionalData)sdk.getSdkAdditionalData()).getFullInterpreterPath(); + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + + @Nullable + public Project getProject(PyTestTask task) { + if (task instanceof PyExecutionFixtureTestTask) { + return ((PyExecutionFixtureTestTask)task).getProject(); + } + return null; + } + + @Override + protected boolean shouldRun(String root, PyTestTask task) { + return !isJython(super.getExecutable(root, task)); //TODO: make remote tests work for jython } } From 8e394847c44622c74cd2655725d9539f63745075 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Sat, 16 Feb 2013 23:30:36 +0100 Subject: [PATCH 051/183] More clear message for tests failing for remote env. --- .../jetbrains/env/python/debug/PyEnvTestCase.java | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index f5c02021fe0a..50611d84923b 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -143,7 +143,8 @@ public abstract class PyEnvTestCase extends UsefulTestCase { passedRoots.add(root); } catch (Throwable e) { - throw new RuntimeException(joinStrings(passedRoots, "Tests passed environments: ") + "Test failed on environment " + root, e); + throw new RuntimeException( + joinStrings(passedRoots, "Tests passed environments: ") + "Test failed on " + getEnvType() + " environment " + root, e); } finally { try { @@ -172,6 +173,10 @@ public abstract class PyEnvTestCase extends UsefulTestCase { protected String getExecutable(String root, PyTestTask testTask) { return PythonSdkType.getPythonExecutable(root); } + + protected String getEnvType() { + return "local"; + } } private static class RemoteTaskRunner extends TaskRunner { @@ -217,6 +222,11 @@ public abstract class PyEnvTestCase extends UsefulTestCase { protected boolean shouldRun(String root, PyTestTask task) { return !isJython(super.getExecutable(root, task)); //TODO: make remote tests work for jython } + + @Override + protected String getEnvType() { + return "remote"; + } } public static boolean notEnvConfiguration() { From e6e782205468c7ac735027aa88a7818cd348accb Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Sun, 17 Feb 2013 15:09:34 +0100 Subject: [PATCH 052/183] Remote sdk tests: don't run on Windows. --- .../com/jetbrains/env/PyTestRemoteSdkProvider.java | 8 +++++++- .../com/jetbrains/env/python/debug/PyEnvTestCase.java | 2 +- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java index 91d980c53d09..93de1d71598e 100644 --- a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java +++ b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java @@ -12,6 +12,7 @@ import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringHash; import com.intellij.remotesdk.RemoteInterpreterException; +import com.jetbrains.env.python.debug.PyTestTask; import com.jetbrains.python.remote.PyRemoteInterpreterManagerImpl; import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; import gnu.trove.HashFunctions; @@ -22,6 +23,7 @@ import org.jetbrains.annotations.Nullable; import java.io.File; import java.io.IOException; +import java.util.List; import java.util.concurrent.ExecutionException; /** @@ -85,7 +87,7 @@ public class PyTestRemoteSdkProvider { } public static boolean canRunRemoteSdk() { - return SystemInfo.isUnix && isPasswordSpecified(); + return isPasswordSpecified(); } private static boolean isPasswordSpecified() { @@ -108,4 +110,8 @@ public class PyTestRemoteSdkProvider { public static String getPassword() { return System.getenv(SSH_PASSWORD); } + + public static boolean shouldRunRemoteSdk(PyTestTask task) { + return SystemInfo.isUnix && task instanceof RemoteSdkTestable; + } } diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index 50611d84923b..a1ec5fe8c69c 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -96,7 +96,7 @@ public abstract class PyEnvTestCase extends UsefulTestCase { taskRunner.runTask(testTask, testName); - if (testTask instanceof RemoteSdkTestable) { + if (PyTestRemoteSdkProvider.shouldRunRemoteSdk(testTask)) { if (PyTestRemoteSdkProvider.canRunRemoteSdk()) { taskRunner = new RemoteTaskRunner(roots); taskRunner.runTask(testTask, testName); From b7a0d85278c07e45fd47b486181e6fa8c0c20cb0 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 2 Apr 2013 14:12:56 +0200 Subject: [PATCH 053/183] Fixed creation of test remote sdk. --- .../env/PyTestRemoteSdkProvider.java | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java index 93de1d71598e..cb0ff2c0ef0a 100644 --- a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java +++ b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java @@ -4,26 +4,20 @@ import com.google.common.cache.CacheBuilder; import com.google.common.cache.CacheLoader; import com.google.common.cache.LoadingCache; import com.google.common.collect.Lists; -import com.google.common.hash.HashFunction; import com.google.common.hash.Hashing; import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; -import com.intellij.openapi.util.text.StringHash; import com.intellij.remotesdk.RemoteInterpreterException; +import com.intellij.util.ui.UIUtil; import com.jetbrains.env.python.debug.PyTestTask; import com.jetbrains.python.remote.PyRemoteInterpreterManagerImpl; import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; -import gnu.trove.HashFunctions; import org.apache.commons.lang.StringUtils; -import org.jetbrains.annotations.NonNls; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import java.io.File; import java.io.IOException; -import java.util.List; import java.util.concurrent.ExecutionException; /** @@ -67,8 +61,15 @@ public class PyTestRemoteSdkProvider { private Sdk createSdk(String interpreterPath) throws RemoteInterpreterException { try { PyRemoteSdkAdditionalData data = createRemoteSdkData(interpreterPath); - Sdk sdk = myInterpreterManager.createRemoteSdk(myProject, data, null, Lists.newArrayList()); - myInterpreterManager.initSdk(sdk, myProject, null); + + final Sdk sdk = myInterpreterManager.createRemoteSdk(myProject, data, null, Lists.newArrayList()); + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + myInterpreterManager.initSdk(sdk, myProject, null); + } + }); + return sdk; } catch (Exception e) { From ed1ac46ffd2e69d669b7131f821897c717cbb041 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 2 Apr 2013 14:13:37 +0200 Subject: [PATCH 054/183] Fixed step over breakpoints with conditions (PY-9213). --- .../env/python/PythonDebuggerTest.java | 28 +++++++++++++------ 1 file changed, 19 insertions(+), 9 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index ebdd2f10204d..6570ad00ba1d 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -3,24 +3,15 @@ package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; import com.intellij.openapi.application.PathManager; -import com.intellij.openapi.util.Pair; -import com.intellij.openapi.vfs.JarFileSystem; -import com.intellij.openapi.vfs.VirtualFile; import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; -import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.XDebuggerTestUtil; -import com.jetbrains.django.util.VirtualFileUtil; import com.jetbrains.env.python.debug.PyDebuggerTask; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.ut.PyUnitTestTask; import com.jetbrains.python.console.pydev.PydevCompletionVariant; import com.jetbrains.python.debugger.PyExceptionBreakpointProperties; import com.jetbrains.python.debugger.PyExceptionBreakpointType; -import com.jetbrains.python.sdk.PySdkUtil; -import com.jetbrains.python.sdk.PythonSdkType; -import com.jetbrains.python.sdk.flavors.JythonSdkFlavor; import com.jetbrains.python.sdk.flavors.PythonSdkFlavor; -import org.junit.Assert; import java.util.List; import java.util.Set; @@ -431,6 +422,25 @@ public class PythonDebuggerTest extends PyEnvTestCase { }); } + public void testStepOverConditionalBreakpoint() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test_stepOverCondition.py") { + @Override + public void before() throws Exception { + toggleBreakpoint(getScriptPath(), 1); + toggleBreakpoint(getScriptPath(), 2); + XDebuggerTestUtil.setBreakpointCondition(getProject(), 2, "y == 3"); + } + + @Override + public void testing() throws Exception { + waitForPause(); + stepOver(); + waitForPause(); + eval("y").hasValue("2"); + } + }); + } + //TODO: fix me as I don't work properly sometimes (something connected with process termination on agent) //public void testResume() throws Exception { From 5414dd3081fbce6c32ca1663ddcab265158b467e Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 4 Apr 2013 18:43:32 +0200 Subject: [PATCH 055/183] Execute in console should send current line if there is no selection (PY-7800). --- .../testSrc/com/jetbrains/env/python/console/PyConsoleTask.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 7d43bbfb2809..e8e47fa2a608 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -344,7 +344,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { UIUtil.invokeAndWaitIfNeeded(new Runnable() { @Override public void run() { - getConsoleView().getLanguageConsole().addTextToCurrentEditor(text); + getConsoleView().getLanguageConsole().addTextToConsoleEditor(text); PsiDocumentManager.getInstance(getProject()).commitAllDocuments(); } } From 99b7f1364c0312c71ae7126b90404b3f4e091e8d Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 9 Apr 2013 16:24:46 +0200 Subject: [PATCH 056/183] Warn that process is not stopped on code execution (PY-9431). --- .../testSrc/com/jetbrains/env/python/console/PyConsoleTask.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index e8e47fa2a608..69cb927c37cb 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -332,7 +332,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { } protected void execNoWait(String command) { - myConsoleView.executeCode(command); + myConsoleView.executeCode(command, null); } protected void interrupt() { From 1875adadce84460c999308e965943ef7a9eff70f Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 9 Apr 2013 17:24:16 +0200 Subject: [PATCH 057/183] Correctly execute code in console when there is something in console (PY-9428). --- .../testSrc/com/jetbrains/env/python/console/PyConsoleTask.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 69cb927c37cb..ff69bfe0e019 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -344,7 +344,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { UIUtil.invokeAndWaitIfNeeded(new Runnable() { @Override public void run() { - getConsoleView().getLanguageConsole().addTextToConsoleEditor(text); + getConsoleView().getLanguageConsole().setTextToEditor(text); PsiDocumentManager.getInstance(getProject()).commitAllDocuments(); } } From 189bcd57446fab77e2dc1c4a8aba52c6d51acde2 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 23 Apr 2013 12:41:06 +0200 Subject: [PATCH 058/183] Run console progresses from EDT. --- .../env/python/console/PyConsoleTask.java | 28 +++++++++++++------ 1 file changed, 19 insertions(+), 9 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index ff69bfe0e019..468e35705d7a 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -97,13 +97,18 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { private void disposeConsole() throws InterruptedException { if (myCommunication != null) { - try { - myCommunication.close(); - } - catch (Exception e) { - e.printStackTrace(); - } - myCommunication = null; + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + try { + myCommunication.close(); + } + catch (Exception e) { + e.printStackTrace(); + } + myCommunication = null; + } + }); } disposeConsoleProcess(); @@ -331,8 +336,13 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { waitFor(mySemaphore); } - protected void execNoWait(String command) { - myConsoleView.executeCode(command, null); + protected void execNoWait(final String command) { + UIUtil.invokeLaterIfNeeded(new Runnable() { + @Override + public void run() { + myConsoleView.executeCode(command, null); + } + }); } protected void interrupt() { From b3c4eefd93459a6b228c5cba1169aec79ceeaf78 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 23 Apr 2013 16:54:02 +0200 Subject: [PATCH 059/183] site->mysite --- python/testSrc/com/jetbrains/env/django/DjangoPathTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java index f53062ca4a7b..558208e8f08d 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java @@ -82,7 +82,7 @@ public class DjangoPathTest extends PyEnvTestCase { @Override protected void configure(AbstractPythonRunConfiguration config) { - ((DjangoTestsRunConfiguration)config).setTarget("site.SimpleTest"); + ((DjangoTestsRunConfiguration)config).setTarget("mysite.SimpleTest"); } public void testing() throws Exception { From 6c2c132d2cd329f11224cacf9a854f56ef8032c7 Mon Sep 17 00:00:00 2001 From: Roman Shevchenko Date: Tue, 23 Apr 2013 19:59:28 +0200 Subject: [PATCH 060/183] Command line API cleaned --- .../jetbrains/env/python/debug/PyRemoteDebuggerTask.java | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java index 676ad580d5d0..82c7b28aaabf 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java @@ -166,12 +166,9 @@ public class PyRemoteDebuggerTask extends PyBaseDebuggerTask { } } - ProcessOutput output = - PySdkUtil - .getProcessOutput(getWorkingFolder(), new String[]{sdkHome, getScriptPath(), Integer.toString(serverSocket.getLocalPort())}, - new String[]{ - PythonEnvUtil.PYTHONUNBUFFERED + "=x", - PythonEnvUtil.PYTHONPATH + "=" + PythonHelpersLocator.getHelpersRoot()}, 0); + String[] cmd = {sdkHome, getScriptPath(), Integer.toString(serverSocket.getLocalPort())}; + String[] env = {PythonEnvUtil.PYTHONUNBUFFERED + "=1", PythonEnvUtil.PYTHONPATH + "=" + PythonHelpersLocator.getHelpersRoot()}; + ProcessOutput output = PySdkUtil.getProcessOutput(getWorkingFolder(), cmd, env, 0); checkOutput(output); } }).start(); From 9cafd0403c17c0e674768896bbf76dfd1af9b2a7 Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Wed, 24 Apr 2013 16:56:02 +0400 Subject: [PATCH 061/183] do not add already presented path to sys.path --- .../testSrc/com/jetbrains/env/django/DjangoManageTestTask.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java index 931e08295412..85d5e97f89cd 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java @@ -29,6 +29,7 @@ import com.intellij.xdebugger.XDebuggerTestUtil; import com.jetbrains.django.facet.DjangoFacet; import com.jetbrains.django.fixtures.DjangoTestCase; import com.jetbrains.django.manage.DjangoManageTask; +import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; import com.jetbrains.django.ui.DjangoBundle; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; import com.jetbrains.python.PythonHelpersLocator; @@ -177,6 +178,8 @@ public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { RunManager.getInstance(project).createRunConfiguration("test", factory); final AbstractPythonRunConfiguration config = (AbstractPythonRunConfiguration)settings.getConfiguration(); + config.addSourceRoots(DjangoTestsConfigurationType.getInstance().getDjangoTestsFactory().equals(factory)); + config.addContentRoots(DjangoTestsConfigurationType.getInstance().getDjangoTestsFactory().equals(factory)); config.setSdkHome(sdkHome); config.setWorkingDirectory(getWorkingFolder()); configure(config); From 73bd7a7e82b5bef592a5a5fbd58435bdcc7dda09 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Wed, 24 Apr 2013 17:35:18 +0200 Subject: [PATCH 062/183] Package requirements and skeletons tests should use fixture from test task as it is recreated every run. --- .../env/PyTestRemoteSdkProvider.java | 4 + .../env/django/DjangoEnvTestTask.java | 4 +- .../env/django/DjangoManageTestTask.java | 4 +- .../PyPackageRequirementsInspectionTest.java | 51 +++----- .../env/python/PythonSkeletonsTest.java | 121 +++++++++++------- .../env/python/console/PyConsoleTask.java | 4 +- .../env/python/debug/PyBaseDebuggerTask.java | 7 +- .../env/python/debug/PyEnvTestCase.java | 9 +- .../debug/PyExecutionFixtureTestTask.java | 18 +-- .../env/python/debug/PyTestTask.java | 2 +- .../com/jetbrains/env/ut/PyUnitTestTask.java | 6 +- 11 files changed, 124 insertions(+), 106 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java index cb0ff2c0ef0a..3b7be60dbac9 100644 --- a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java +++ b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java @@ -95,6 +95,10 @@ public class PyTestRemoteSdkProvider { return !StringUtils.isEmpty(System.getenv(LOCAL_SSH_WITHOUT_PASSWORD)) || !StringUtils.isEmpty(getPassword()); } + public static boolean shouldFailWhenCantRunRemote() { + return !StringUtils.isEmpty(System.getenv("FAIL_WHEN_CANT_RUN_REMOTE")) || PyEnvSufficiencyTest.IS_UNDER_TEAMCITY; + } + private static String getHelpersPath(PyRemoteSdkAdditionalData data) throws IOException { final File dir = new File("/tmp"); diff --git a/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java index c9ea32ec5473..e8a0c3e5cb34 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java @@ -38,8 +38,8 @@ public class DjangoEnvTestTask extends PyDebuggerTask { } @Override - public void setUp() throws Exception { - super.setUp(); + public void setUp(String testName) throws Exception { + super.setUp(testName); UIUtil.invokeAndWaitIfNeeded(new Runnable() { public void run() { Module module = myFixture.getModule(); diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java index 931e08295412..41f19d88ab2c 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java @@ -60,8 +60,8 @@ public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { protected abstract String getTestDataPath(); @Override - public void setUp() throws Exception { - super.setUp(); + public void setUp(String testName) throws Exception { + super.setUp(testName); UIUtil.invokeAndWaitIfNeeded(new Runnable() { public void run() { Module module = myFixture.getModule(); diff --git a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java index 56eb3d4f4be2..676a5ebb39df 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java @@ -2,19 +2,14 @@ package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; import com.intellij.openapi.module.Module; -import com.intellij.openapi.module.ModuleManager; -import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; -import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil; import com.intellij.openapi.roots.ModuleRootModificationUtil; -import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.testFramework.PsiTestUtil; import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.env.python.debug.PyTestTask; -import com.jetbrains.python.fixtures.PyTestCase; +import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; +import com.jetbrains.python.PythonTestUtil; import com.jetbrains.python.inspections.PyPackageRequirementsInspection; -import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.NotNull; import java.util.Set; @@ -22,7 +17,7 @@ import java.util.Set; /** * @author vlan */ -public class PyPackageRequirementsInspectionTest extends PyTestCase { +public class PyPackageRequirementsInspectionTest extends PyEnvTestCase { public static final ImmutableSet TAGS = ImmutableSet.of("requirements"); public void testPartiallySatisfiedRequirementsTxt() { @@ -38,21 +33,31 @@ public class PyPackageRequirementsInspectionTest extends PyTestCase { } private void doTest(@NotNull final String filename) { - final String dir = String.format("inspections/PyPackageRequirementsInspection/%s", getTestName(false)); - myFixture.enableInspections(PyPackageRequirementsInspection.class); - PyEnvTestCase.runTest(new PyTestTask() { + final String dir = getTestName(false); + runPythonTest(new PyExecutionFixtureTestTask() { + @Override + protected String getTestDataPath() { + return PythonTestUtil.getTestDataPath() + "/inspections/PyPackageRequirementsInspection"; + } + @Override public void runTestOn(String sdkHome) throws Exception { - final Sdk sdk = createTempSdk(sdkHome); + myFixture.enableInspections(PyPackageRequirementsInspection.class); + final Sdk sdk = PythonSkeletonsTest.createTempSdk(sdkHome); final String perSdkDir = Integer.toHexString(System.identityHashCode(sdk)); final VirtualFile root = myFixture.copyDirectoryToProject(dir, perSdkDir); assertNotNull(root); - final Module module = getSingleModule(myFixture.getProject()); + final Module module = myFixture.getModule(); setupModuleSdk(module, sdk, root); try { final VirtualFile file = root.findFileByRelativePath(filename); assertNotNull(file); - myFixture.testHighlighting(true, true, true, file); + edt(new Runnable() { + @Override + public void run() { + myFixture.testHighlighting(true, true, true, file); + } + }); } finally { PsiTestUtil.removeAllRoots(module, sdk); @@ -63,27 +68,11 @@ public class PyPackageRequirementsInspectionTest extends PyTestCase { public Set getTags() { return TAGS; } - }, getTestName(false)); - } - - @NotNull - private static Module getSingleModule(@NotNull Project project) { - Module[] modules = ModuleManager.getInstance(project).getModules(); - assertEquals(1, modules.length); - return modules[0]; + }); } private static void setupModuleSdk(@NotNull Module module, @NotNull Sdk sdk, @NotNull VirtualFile root) { ModuleRootModificationUtil.setModuleSdk(module, sdk); PsiTestUtil.addContentRoot(module, root); } - - @NotNull - private static Sdk createTempSdk(@NotNull String sdkHome) { - final VirtualFile binary = LocalFileSystem.getInstance().findFileByPath(sdkHome); - assertNotNull("Interpreter file not found: " + sdkHome, binary); - final Sdk sdk = SdkConfigurationUtil.setupSdk(new Sdk[0], binary, PythonSdkType.getInstance(), true, null, null); - assertNotNull(sdk); - return sdk; - } } diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index 200e3fdbc347..28ed0a9628c2 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -1,8 +1,8 @@ package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; +import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.module.Module; -import com.intellij.openapi.module.ModuleManager; import com.intellij.openapi.module.ModuleUtil; import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; @@ -10,20 +10,20 @@ import com.intellij.openapi.projectRoots.SdkModificator; import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil; import com.intellij.openapi.roots.ModuleRootModificationUtil; import com.intellij.openapi.roots.OrderRootType; +import com.intellij.openapi.roots.ProjectRootManager; +import com.intellij.openapi.util.Ref; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; -import com.intellij.psi.PsiReference; +import com.intellij.testFramework.fixtures.CodeInsightTestFixture; import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; import com.jetbrains.env.python.debug.PyTestTask; -import com.jetbrains.python.fixtures.PyTestCase; +import com.jetbrains.python.PythonTestUtil; import com.jetbrains.python.inspections.PyUnresolvedReferencesInspection; import com.jetbrains.python.psi.LanguageLevel; -import com.jetbrains.python.psi.PyExpression; import com.jetbrains.python.psi.PyFile; -import com.jetbrains.python.psi.PyFunction; import com.jetbrains.python.psi.impl.PyBuiltinCache; import com.jetbrains.python.psi.resolve.PythonSdkPathCache; import com.jetbrains.python.sdk.InvalidSdkException; @@ -39,13 +39,13 @@ import java.util.Set; /** * Heavyweight integration tests of skeletons of Python binary modules. - * + *

* An environment test environment must have a 'skeletons' tag in order to be compatible with this test case. No specific packages are * required currently. Both Python 2 and Python 3 are OK. All platforms are OK. At least one Python 2.6+ environment is required. * * @author vlan */ -public class PythonSkeletonsTest extends PyTestCase { +public class PythonSkeletonsTest extends PyEnvTestCase { public static final ImmutableSet TAGS = ImmutableSet.of("skeletons"); public void testBuiltins() { @@ -66,13 +66,14 @@ public class PythonSkeletonsTest extends PyTestCase { assertTrue("Header version must be > 0, currently it is " + version, version > 0); assertEquals(SkeletonVersionChecker.BUILTIN_NAME, header.getBinaryFile()); - // Resolve a single reference to built-ins - myFixture.configureByText("a.py", "len('foo')"); - final PyExpression expr = myFixture.findElementByText("len", PyExpression.class); - assertNotNull(expr); + // Run inspections on a file that uses builtins + myFixture.configureByFile(getTestName(false) + ".py"); + + + PsiFile expr = myFixture.getFile(); + + final Module module = ModuleUtil.findModuleForPsiElement(expr); - final Module module = ModuleUtil.findModuleForPsiElement(expr.getContainingFile()); - assertEquals(getSingleModule(project), module); final Sdk sdkFromModule = PythonSdkType.findPythonSdk(module); assertNotNull(sdkFromModule); @@ -85,20 +86,13 @@ public class PythonSkeletonsTest extends PyTestCase { assertNotNull(builtinsFromPsi); assertEquals(builtins, builtinsFromPsi); - final PsiReference ref = expr.getReference(); - assertNotNull(ref); - final PsiElement resolved = ref.resolve(); - assertNotNull(resolved); - assertInstanceOf(resolved, PyFunction.class); - final PyFunction len = (PyFunction)resolved; - assertEquals("len", len.getName()); - final PsiFile file = resolved.getContainingFile(); - assertEquals(builtins, file); - - // Run inspections on a file that uses builtins - myFixture.configureByFile("skeletons/" + getTestName(false) + ".py"); myFixture.enableInspections(PyUnresolvedReferencesInspection.class); - myFixture.checkHighlighting(true, false, false); + edt(new Runnable() { + @Override + public void run() { + myFixture.checkHighlighting(true, false, false); + } + }); } }); } @@ -115,16 +109,35 @@ public class PythonSkeletonsTest extends PyTestCase { } // Run inspections on code that uses named tuples - myFixture.configureByFile("skeletons/" + getTestName(false) + ".py"); + myFixture.configureByFile(getTestName(false) + ".py"); myFixture.enableInspections(PyUnresolvedReferencesInspection.class); - myFixture.checkHighlighting(true, false, false); + + edt(new Runnable() { + @Override + public void run() { + myFixture.checkHighlighting(true, false, false); + } + }); } }); } - private void generateTempSkeletons(@NotNull Sdk sdk) throws InvalidSdkException, IOException { - final Project project = myFixture.getProject(); - ModuleRootModificationUtil.setModuleSdk(getSingleModule(project), sdk); + private void generateTempSkeletons(CodeInsightTestFixture fixture, final @NotNull Sdk sdk) throws InvalidSdkException, IOException { + final Project project = fixture.getProject(); + ModuleRootModificationUtil.setModuleSdk(fixture.getModule(), sdk); + + edt(new Runnable() { + @Override + public void run() { + ApplicationManager.getApplication().runWriteAction(new Runnable() { + @Override + public void run() { + ProjectRootManager.getInstance(project).setProjectSdk(sdk); + } + }); + } + }); + final SdkModificator modificator = sdk.getSdkModificator(); modificator.removeRoots(OrderRootType.CLASSES); @@ -136,7 +149,13 @@ public class PythonSkeletonsTest extends PyTestCase { FileUtil.createDirectory(skeletonsDir); final String skeletonsPath = skeletonsDir.toString(); PythonSdkType.addSdkRoot(modificator, skeletonsPath); - modificator.commitChanges(); + + edt(new Runnable() { + @Override + public void run() { + modificator.commitChanges(); + } + }); final SkeletonVersionChecker checker = new SkeletonVersionChecker(0); final PySkeletonRefresher refresher = new PySkeletonRefresher(project, null, sdk, skeletonsPath, null); @@ -144,31 +163,39 @@ public class PythonSkeletonsTest extends PyTestCase { assertEmpty(errors); } - @NotNull - private static Module getSingleModule(@NotNull Project project) { - Module[] modules = ModuleManager.getInstance(project).getModules(); - assertEquals(1, modules.length); - return modules[0]; - } - private void runTest(@NotNull PyTestTask task) { - PyEnvTestCase.runTest(task, getTestName(false)); + runPythonTest(task); } @NotNull - private static Sdk createTempSdk(@NotNull String sdkHome) { + public static Sdk createTempSdk(@NotNull String sdkHome) { final VirtualFile binary = LocalFileSystem.getInstance().findFileByPath(sdkHome); assertNotNull("Interpreter file not found: " + sdkHome, binary); - final Sdk sdk = SdkConfigurationUtil.setupSdk(new Sdk[0], binary, PythonSdkType.getInstance(), true, null, null); - assertNotNull(sdk); - return sdk; + final Ref ref = Ref.create(); + edt(new Runnable() { + + @Override + public void run() { + final Sdk sdk = SdkConfigurationUtil.setupSdk(new Sdk[0], binary, PythonSdkType.getInstance(), true, null, null); + assertNotNull(sdk); + ref.set(sdk); + } + }); + + return ref.get(); } - private abstract class SkeletonsTask extends PyTestTask { + + private abstract class SkeletonsTask extends PyExecutionFixtureTestTask { + @Override + protected String getTestDataPath() { + return PythonTestUtil.getTestDataPath() + "/skeletons/"; + } + @Override public void runTestOn(String sdkHome) throws Exception { final Sdk sdk = createTempSdk(sdkHome); - generateTempSkeletons(sdk); + generateTempSkeletons(myFixture, sdk); runTestOn(sdk); } diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 468e35705d7a..4704564e8254 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -49,13 +49,13 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { } @Override - public void setUp() throws Exception { + public void setUp(final String testName) throws Exception { UIUtil.invokeAndWaitIfNeeded(new Runnable() { @Override public void run() { try { if (myFixture == null) { - PyConsoleTask.super.setUp(); + PyConsoleTask.super.setUp(testName); } } catch (Exception e) { diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java index eac187606c88..39ffba6abe1a 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java @@ -1,12 +1,9 @@ package com.jetbrains.env.python.debug; import com.google.common.collect.Sets; -import com.intellij.openapi.application.Application; -import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.application.Result; import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.project.Project; -import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.Pair; import com.intellij.openapi.vfs.JarFileSystem; import com.intellij.openapi.vfs.VirtualFile; @@ -215,13 +212,13 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { } @Override - public void setUp() throws Exception { + public void setUp(final String testName) throws Exception { UIUtil.invokeAndWaitIfNeeded(new Runnable() { @Override public void run() { try { if (myFixture == null) { - PyBaseDebuggerTask.super.setUp(); + PyBaseDebuggerTask.super.setUp(testName); } } catch (Exception e) { diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index a1ec5fe8c69c..d1d1ed38d76b 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -11,7 +11,6 @@ import com.intellij.openapi.util.text.StringUtil; import com.intellij.testFramework.UsefulTestCase; import com.intellij.util.ui.UIUtil; import com.jetbrains.env.PyTestRemoteSdkProvider; -import com.jetbrains.env.RemoteSdkTestable; import com.jetbrains.python.fixtures.PyTestCase; import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; import com.jetbrains.python.sdk.PythonSdkType; @@ -71,7 +70,7 @@ public abstract class PyEnvTestCase extends UsefulTestCase { runTest(testTask, getTestName(false)); } - public static void runTest(@NotNull PyTestTask testTask, @NotNull String testName) { + public void runTest(@NotNull PyTestTask testTask, @NotNull String testName) { if (notEnvConfiguration()) { fail("Running under teamcity but not by Env configuration. Skipping."); return; @@ -102,7 +101,9 @@ public abstract class PyEnvTestCase extends UsefulTestCase { taskRunner.runTask(testTask, testName); } else { - fail("Cant run with remote sdk: password isn't set"); + if (PyTestRemoteSdkProvider.shouldFailWhenCantRunRemote()) { + fail("Cant run with remote sdk: password isn't set"); + } } } } @@ -127,7 +128,7 @@ public abstract class PyEnvTestCase extends UsefulTestCase { } try { - testTask.setUp(); + testTask.setUp(testName); wasExecuted = true; if (isJython(root)) { testTask.useLongTimeout(); diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java index a223ed66a13e..95116e1f69b4 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java @@ -7,10 +7,7 @@ import com.intellij.openapi.module.ModuleTypeManager; import com.intellij.openapi.project.Project; import com.intellij.testFramework.LightProjectDescriptor; import com.intellij.testFramework.builders.ModuleFixtureBuilder; -import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; -import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory; -import com.intellij.testFramework.fixtures.ModuleFixture; -import com.intellij.testFramework.fixtures.TestFixtureBuilder; +import com.intellij.testFramework.fixtures.*; import com.intellij.testFramework.fixtures.impl.ModuleFixtureBuilderImpl; import com.intellij.testFramework.fixtures.impl.ModuleFixtureImpl; import com.intellij.util.ui.UIUtil; @@ -29,7 +26,7 @@ public abstract class PyExecutionFixtureTestTask extends PyTestTask { public static final int NORMAL_TIMEOUT = 30000; public static final int LONG_TIMEOUT = 120000; private int myTimeout = NORMAL_TIMEOUT; - protected IdeaProjectTestFixture myFixture; + protected CodeInsightTestFixture myFixture; public Project getProject() { return myFixture.getProject(); @@ -43,24 +40,27 @@ public abstract class PyExecutionFixtureTestTask extends PyTestTask { myTimeout = LONG_TIMEOUT; } - public void setUp() throws Exception { + public void setUp(final String testName) throws Exception { initFixtureBuilder(); - IdeaTestFixtureFactory factory = IdeaTestFixtureFactory.getFixtureFactory(); - final TestFixtureBuilder fixtureBuilder = factory.createFixtureBuilder(); + final TestFixtureBuilder fixtureBuilder = IdeaTestFixtureFactory.getFixtureFactory().createFixtureBuilder( + testName); - myFixture = fixtureBuilder.getFixture(); + myFixture = IdeaTestFixtureFactory.getFixtureFactory().createCodeInsightFixture(fixtureBuilder.getFixture()); UIUtil.invokeAndWaitIfNeeded( new Runnable() { @Override public void run() { ModuleFixtureBuilder moduleFixtureBuilder = fixtureBuilder.addModule(MyModuleFixtureBuilder.class); + moduleFixtureBuilder.addSourceContentRoot(myFixture.getTempDirPath()); moduleFixtureBuilder.addSourceContentRoot(getTestDataPath()); } }); + myFixture.setUp(); + myFixture.setTestDataPath(getTestDataPath()); } protected String getTestDataPath() { diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java index 8987dbafc24e..9cbbb0b3b94a 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java @@ -25,7 +25,7 @@ public abstract class PyTestTask { myScriptParameters = scriptParameters; } - public void setUp() throws Exception { + public void setUp(String testName) throws Exception { } public void tearDown() throws Exception { diff --git a/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java b/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java index 46140f8e6ecd..45bf40d93bb4 100644 --- a/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java +++ b/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java @@ -22,8 +22,8 @@ import com.intellij.openapi.util.Key; import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.XDebuggerTestUtil; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; -import com.jetbrains.python.sdk.flavors.JythonSdkFlavor; import com.jetbrains.python.sdk.PythonEnvUtil; +import com.jetbrains.python.sdk.flavors.JythonSdkFlavor; import com.jetbrains.python.sdk.flavors.PythonSdkFlavor; import com.jetbrains.python.testing.AbstractPythonTestRunConfiguration; import com.jetbrains.python.testing.PythonTestConfigurationType; @@ -57,13 +57,13 @@ public abstract class PyUnitTestTask extends PyExecutionFixtureTestTask { } @Override - public void setUp() throws Exception { + public void setUp(final String testName) throws Exception { UIUtil.invokeAndWaitIfNeeded(new Runnable() { @Override public void run() { try { if (myFixture == null) { - PyUnitTestTask.super.setUp(); + PyUnitTestTask.super.setUp(testName); mySetUp = true; } } From 19d2d0e440c94e72cf76062817894073b668d28e Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Wed, 24 Apr 2013 17:52:56 +0200 Subject: [PATCH 063/183] Stacktrace should be preserved. --- .../testSrc/com/jetbrains/env/python/PyPackagingTest.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index b1377c58c4d7..f99bc1db67e3 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -12,8 +12,8 @@ import com.intellij.util.Processor; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.python.fixtures.PyTestCase; import com.jetbrains.python.packaging.*; -import com.jetbrains.python.sdk.flavors.PythonSdkFlavor; import com.jetbrains.python.sdk.PythonSdkType; +import com.jetbrains.python.sdk.flavors.PythonSdkFlavor; import com.jetbrains.python.sdk.flavors.VirtualEnvSdkFlavor; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -84,7 +84,7 @@ public class PyPackagingTest extends PyTestCase { throw new RuntimeException(e); } catch (PyExternalProcessException e) { - fail(String.format("Error for interpreter '%s': %s", sdk.getHomePath(), e.getMessage())); + throw new RuntimeException(String.format("Error for interpreter '%s': %s", sdk.getHomePath(), e.getMessage()), e); } return true; } @@ -120,7 +120,7 @@ public class PyPackagingTest extends PyTestCase { assertNull(pip2); } catch (PyExternalProcessException e) { - fail(String.format("Error for interpreter '%s': %s", sdk.getHomePath(), e.getMessage())); + new RuntimeException(String.format("Error for interpreter '%s': %s", sdk.getHomePath(), e.getMessage()), e); } catch (IOException e) { throw new RuntimeException(e); From 0501f6ed631af7ddb5392adb0fc3deea0fd833a7 Mon Sep 17 00:00:00 2001 From: Roman Shevchenko Date: Wed, 24 Apr 2013 20:24:36 +0200 Subject: [PATCH 064/183] Command line API cleaned, take 2 --- .../jetbrains/env/python/debug/PyRemoteDebuggerTask.java | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java index 82c7b28aaabf..676ad580d5d0 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java @@ -166,9 +166,12 @@ public class PyRemoteDebuggerTask extends PyBaseDebuggerTask { } } - String[] cmd = {sdkHome, getScriptPath(), Integer.toString(serverSocket.getLocalPort())}; - String[] env = {PythonEnvUtil.PYTHONUNBUFFERED + "=1", PythonEnvUtil.PYTHONPATH + "=" + PythonHelpersLocator.getHelpersRoot()}; - ProcessOutput output = PySdkUtil.getProcessOutput(getWorkingFolder(), cmd, env, 0); + ProcessOutput output = + PySdkUtil + .getProcessOutput(getWorkingFolder(), new String[]{sdkHome, getScriptPath(), Integer.toString(serverSocket.getLocalPort())}, + new String[]{ + PythonEnvUtil.PYTHONUNBUFFERED + "=x", + PythonEnvUtil.PYTHONPATH + "=" + PythonHelpersLocator.getHelpersRoot()}, 0); checkOutput(output); } }).start(); From 828cd18d9c621f34ab65282dc762f93c6d3b900a Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 25 Apr 2013 19:36:34 +0200 Subject: [PATCH 065/183] Remove code duplication and fixed. --- .../jetbrains/env/python/PyPackagingTest.java | 93 ++++++++----------- 1 file changed, 38 insertions(+), 55 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index f99bc1db67e3..8d8a7028e815 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -10,6 +10,8 @@ import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.util.Processor; import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; +import com.jetbrains.python.PythonTestUtil; import com.jetbrains.python.fixtures.PyTestCase; import com.jetbrains.python.packaging.*; import com.jetbrains.python.sdk.PythonSdkType; @@ -23,22 +25,24 @@ import java.io.IOException; import java.util.Arrays; import java.util.Collections; import java.util.List; +import java.util.Set; /** * @author vlan */ -public class PyPackagingTest extends PyTestCase { +public class PyPackagingTest extends PyEnvTestCase { private static final Logger LOG = Logger.getInstance(PyEnvTestCase.class.getName()); public static final String PIP_VERSION = "1.1"; public static final String DISTRIBUTE_VERSION = "0.6.27"; public void testGetPackages() { - forAllPythonEnvs(getTestName(false), new Processor() { + runPythonTest(new PyPackagingTestTask() { @Override - public boolean process(Sdk sdk) { + public void runPackageTestOn(String sdkHome) throws Exception { + final Sdk sdk = PythonSkeletonsTest.createTempSdk(sdkHome); List packages = null; try { - packages = ((PyPackageManagerImpl) PyPackageManager.getInstance(sdk)).getPackages(); + packages = ((PyPackageManagerImpl)PyPackageManager.getInstance(sdk)).getPackages(); } catch (PyExternalProcessException e) { final int retcode = e.getRetcode(); @@ -52,25 +56,25 @@ public class PyPackagingTest extends PyTestCase { assertTrue(pkg.getName().length() > 0); } } - return true; } }); } public void testCreateVirtualEnv() { - forAllPythonEnvs(getTestName(false), new Processor() { + runPythonTest(new PyPackagingTestTask() { @Override - public boolean process(Sdk sdk) { + public void runPackageTestOn(String sdkHome) throws Exception { + final Sdk sdk = PythonSkeletonsTest.createTempSdk(sdkHome); try { final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); final File venvDir = new File(tempDir, "venv"); - final String venvSdkHome = ((PyPackageManagerImpl) PyPackageManagerImpl.getInstance(sdk)).createVirtualEnv(venvDir.toString(), - false); - final Sdk venvSdk = createTempSdk(venvSdkHome); + final String venvSdkHome = ((PyPackageManagerImpl)PyPackageManagerImpl.getInstance(sdk)).createVirtualEnv(venvDir.toString(), + false); + final Sdk venvSdk = PythonSkeletonsTest.createTempSdk(venvSdkHome); assertNotNull(venvSdk); assertTrue(PythonSdkType.isVirtualEnv(venvSdk)); assertInstanceOf(PythonSdkFlavor.getPlatformIndependentFlavor(venvSdk.getHomePath()), VirtualEnvSdkFlavor.class); - final List packages = ((PyPackageManagerImpl) PyPackageManagerImpl.getInstance(venvSdk)).getPackages(); + final List packages = ((PyPackageManagerImpl)PyPackageManagerImpl.getInstance(venvSdk)).getPackages(); final PyPackage distribute = findPackage("distribute", packages); assertNotNull(distribute); assertEquals("distribute", distribute.getName()); @@ -86,20 +90,21 @@ public class PyPackagingTest extends PyTestCase { catch (PyExternalProcessException e) { throw new RuntimeException(String.format("Error for interpreter '%s': %s", sdk.getHomePath(), e.getMessage()), e); } - return true; } }); } public void testInstallPackage() { - forAllPythonEnvs(getTestName(false), new Processor() { + runPythonTest(new PyPackagingTestTask() { + @Override - public boolean process(final Sdk sdk) { + public void runPackageTestOn(String sdkHome) throws Exception { + final Sdk sdk = PythonSkeletonsTest.createTempSdk(sdkHome); try { final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); final File venvDir = new File(tempDir, "venv"); final String venvSdkHome = ((PyPackageManagerImpl)PyPackageManager.getInstance(sdk)).createVirtualEnv(venvDir.getPath(), false); - final Sdk venvSdk = createTempSdk(venvSdkHome); + final Sdk venvSdk = PythonSkeletonsTest.createTempSdk(venvSdkHome); assertNotNull(venvSdk); final PyPackageManagerImpl manager = (PyPackageManagerImpl)PyPackageManager.getInstance(venvSdk); final List packages1 = manager.getPackages(); @@ -125,7 +130,6 @@ public class PyPackagingTest extends PyTestCase { catch (IOException e) { throw new RuntimeException(e); } - return true; } }); } @@ -140,46 +144,25 @@ public class PyPackagingTest extends PyTestCase { return null; } - public static void forAllPythonEnvs(@NotNull String testName, @NotNull Processor processor) { - final List roots = PyEnvTestCase.getPythonRoots(); - - if (PyEnvTestCase.notEnvConfiguration()) { - LOG.info("Running under teamcity but not by Env configuration. Skipping."); - return; - } - - if (PyEnvTestCase.IS_UNDER_TEAMCITY && SystemInfo.isWindows) { - return; //Don't run under Windows as after deleting from created virtualenvs original interpreter got spoiled - } - - if (roots.size() == 0) { - String msg = testName + ": environments are not defined. Skipping."; - LOG.warn(msg); - System.out.println(msg); - return; - } - for (String root : roots) { - if (!PyEnvTestCase.isSuitableForTags(PyEnvTestCase.loadEnvTags(root), Sets.newHashSet("packaging"))) { - continue; // Run only on special test-envs as because of downloading packages on every run is is too heavy to run it on all envs - } - final String sdkHome = PythonSdkType.getPythonExecutable(root); - assertNotNull(sdkHome); - final Sdk sdk = createTempSdk(sdkHome); - assertNotNull(sdk); - processor.process(sdk); - } - } - - @Nullable - private static Sdk createTempSdk(@NotNull String sdkHome) { - final VirtualFile binary = LocalFileSystem.getInstance().findFileByPath(sdkHome); - if (binary != null) { - return SdkConfigurationUtil.setupSdk(new Sdk[0], binary, PythonSdkType.getInstance(), true, null, null); - } - return null; - } - private static List list(T... xs) { return Arrays.asList(xs); } + + + private abstract static class PyPackagingTestTask extends PyExecutionFixtureTestTask { + @Override + public Set getTags() { + return Sets.newHashSet("packaging"); + } + + @Override + public void runTestOn(String sdkHome) throws Exception { + if (PyEnvTestCase.IS_UNDER_TEAMCITY && SystemInfo.isWindows) { + return; //Don't run under Windows as after deleting from created virtualenvs original interpreter got spoiled + } + runPackageTestOn(sdkHome); + } + + protected abstract void runPackageTestOn(String sdkHome) throws Exception; + } } From 49c9e95825ac614272a6d8bb4cab6f854720dc38 Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Fri, 26 Apr 2013 12:49:32 +0400 Subject: [PATCH 066/183] added bunch of tests for django test runner --- .../env/django/DjangoTestRunnerTest.java | 108 ++++++++++++++++++ .../env/django/DjangoTestRunnerTestTask.java | 21 ++++ .../debug/PyExecutionFixtureTestTask.java | 8 ++ 3 files changed, 137 insertions(+) create mode 100644 python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java create mode 100644 python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTestTask.java diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java new file mode 100644 index 000000000000..9b69cb9b6bf1 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java @@ -0,0 +1,108 @@ +package com.jetbrains.env.django; + +import com.google.common.collect.Lists; +import com.intellij.execution.configurations.ConfigurationFactory; +import com.intellij.openapi.module.Module; +import com.intellij.openapi.util.io.FileUtil; +import com.intellij.util.ui.UIUtil; +import com.jetbrains.django.facet.DjangoFacet; +import com.jetbrains.django.facet.DjangoFacetConfiguration; +import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; +import com.jetbrains.django.testRunner.DjangoTestsRunConfiguration; +import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.python.run.AbstractPythonRunConfiguration; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.List; + +/** + * User : ktisha + */ +public class DjangoTestRunnerTest extends PyEnvTestCase { + + private static void doTest(@NotNull final String output, @NotNull final String testDataPath) { + final String[] splittedOutput = output.split("\\n"); + final ArrayList outputList = Lists.newArrayList(); + for (String s : splittedOutput) { + outputList.add(norm(s)); + } + assertEquals(outputList.indexOf(testDataPath), + outputList.lastIndexOf(testDataPath)); + } + + private static String norm(String testDataPath) { + return FileUtil.toSystemIndependentName(testDataPath); + } + + private void doTest(final String name, @Nullable final String projectRoot, @Nullable final String settings, + @Nullable final String markAsSource) { + runPythonTest(new DjangoTestRunnerTestTask() { + @Override + public ConfigurationFactory getFactory() { + return DjangoTestsConfigurationType.getInstance().getConfigurationFactories()[0]; + } + + @Override + protected void configure(AbstractPythonRunConfiguration config) { + ((DjangoTestsRunConfiguration)config).setTarget("myapp.SimpleTest"); + } + + @Override + protected List getContentRoots() { + return markAsSource == null ? Lists.newArrayList() : Lists.newArrayList(markAsSource); + } + + @Override + public void before() throws Exception { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + public void run() { + final Module module = myFixture.getModule(); + final DjangoFacet djangoFacet = DjangoFacet.getInstance(module); + if (djangoFacet != null && projectRoot != null && settings != null) { + final DjangoFacetConfiguration configuration = djangoFacet.getConfiguration(); + configuration.setProjectRootPath(getTestDataPath() + projectRoot); + configuration.setSettingsFilePath(settings); + } + } + }); + } + + public void testing() throws Exception { + waitForOutput("Process finished with exit code 0"); + doTest(output(), norm(getTestDataPath())); + } + + @Override + String getTestName() { + return name; + } + }); + } + + public void testDjango13() { + doTest(getTestName(false), null, null, null); + } + + public void testDjango14() { + doTest(getTestName(false), "", "Django14/settings.py", null); + } + + public void testDjango15() { + doTest(getTestName(false), "", "Django15/settings.py", null); + } + + public void testRoot13() { + doTest(getTestName(false), "/Django13", "settings.py", null); + } + + public void testRoot() { + doTest(getTestName(false), "/DjangoRoot", "DjangoRoot/settings.py", null); + } + + public void testRootMarked() { + doTest(getTestName(false), "/DjangoRoot", "DjangoRoot/settings.py", "/DjangoRoot"); + } + +} diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTestTask.java new file mode 100644 index 000000000000..a3f37b1b9c27 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTestTask.java @@ -0,0 +1,21 @@ +package com.jetbrains.env.django; + +import com.jetbrains.python.PythonTestUtil; + +/** + * User : ktisha + */ +public abstract class DjangoTestRunnerTestTask extends DjangoManageTestTask { + + @Override + protected String getTestDataPath() { + return PythonTestUtil.getTestDataPath() + "/django/testRunner/" + getTestName(); + } + + abstract String getTestName(); + + @Override + protected String getSubcommand() { + return "validate"; + } +} diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java index 95116e1f69b4..db6265c4bbbb 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java @@ -1,5 +1,6 @@ package com.jetbrains.env.python.debug; +import com.google.common.collect.Lists; import com.intellij.execution.process.ProcessHandler; import com.intellij.ide.util.projectWizard.EmptyModuleBuilder; import com.intellij.openapi.module.ModuleType; @@ -16,6 +17,7 @@ import com.jetbrains.python.PythonTestUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.List; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; @@ -55,6 +57,10 @@ public abstract class PyExecutionFixtureTestTask extends PyTestTask { ModuleFixtureBuilder moduleFixtureBuilder = fixtureBuilder.addModule(MyModuleFixtureBuilder.class); moduleFixtureBuilder.addSourceContentRoot(myFixture.getTempDirPath()); moduleFixtureBuilder.addSourceContentRoot(getTestDataPath()); + final List contentRoots = getContentRoots(); + for (String contentRoot : contentRoots) { + moduleFixtureBuilder.addContentRoot(getTestDataPath() + contentRoot); + } } }); @@ -63,6 +69,8 @@ public abstract class PyExecutionFixtureTestTask extends PyTestTask { myFixture.setTestDataPath(getTestDataPath()); } + protected List getContentRoots() { return Lists.newArrayList();} + protected String getTestDataPath() { return PythonTestUtil.getTestDataPath(); } From 36488093e55b5412db35166dd98b67a054dba349 Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Fri, 26 Apr 2013 13:25:37 +0400 Subject: [PATCH 067/183] added test for custom settings file for django tests --- .../env/django/DjangoTestRunnerTest.java | 28 +++++++++++++------ 1 file changed, 20 insertions(+), 8 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java index 9b69cb9b6bf1..b0d98ef97666 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java @@ -36,8 +36,9 @@ public class DjangoTestRunnerTest extends PyEnvTestCase { return FileUtil.toSystemIndependentName(testDataPath); } - private void doTest(final String name, @Nullable final String projectRoot, @Nullable final String settings, - @Nullable final String markAsSource) { + private void doTest(@Nullable final String projectRoot, @Nullable final String settings, + @Nullable final String markAsSource, @Nullable final String customSettings) { + final String name = getTestName(false); runPythonTest(new DjangoTestRunnerTestTask() { @Override public ConfigurationFactory getFactory() { @@ -47,6 +48,9 @@ public class DjangoTestRunnerTest extends PyEnvTestCase { @Override protected void configure(AbstractPythonRunConfiguration config) { ((DjangoTestsRunConfiguration)config).setTarget("myapp.SimpleTest"); + if (customSettings != null) + ((DjangoTestsRunConfiguration)config).setSettingsFile(getTestDataPath() + customSettings); + ((DjangoTestsRunConfiguration)config).useCustomSettings(true); } @Override @@ -82,27 +86,35 @@ public class DjangoTestRunnerTest extends PyEnvTestCase { } public void testDjango13() { - doTest(getTestName(false), null, null, null); + doTest(); + } + + private void doTest() { + doTest(null, null, null, null); } public void testDjango14() { - doTest(getTestName(false), "", "Django14/settings.py", null); + doTest("", "Django14/settings.py", null, null); } public void testDjango15() { - doTest(getTestName(false), "", "Django15/settings.py", null); + doTest("", "Django15/settings.py", null, null); } public void testRoot13() { - doTest(getTestName(false), "/Django13", "settings.py", null); + doTest("/Django13", "settings.py", null, null); } public void testRoot() { - doTest(getTestName(false), "/DjangoRoot", "DjangoRoot/settings.py", null); + doTest("/DjangoRoot", "DjangoRoot/settings.py", null, null); } public void testRootMarked() { - doTest(getTestName(false), "/DjangoRoot", "DjangoRoot/settings.py", "/DjangoRoot"); + doTest("/DjangoRoot", "DjangoRoot/settings.py", "/DjangoRoot", null); + } + + public void testCustomSettings() { + doTest(null, null, null, "/custom_settings.py"); } } From 9a7b08401d0b6b78bf9fa48e9c6d5e18270de31a Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Fri, 26 Apr 2013 13:29:33 +0400 Subject: [PATCH 068/183] added test for the same named dirs in Django Project (PY-7731) --- .../com/jetbrains/env/django/DjangoTestRunnerTest.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java index b0d98ef97666..3154e5cdd9e9 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java @@ -113,6 +113,10 @@ public class DjangoTestRunnerTest extends PyEnvTestCase { doTest("/DjangoRoot", "DjangoRoot/settings.py", "/DjangoRoot", null); } + public void testSameNamedDir() { + doTest("/web/SameNamedDir", "settings.py", null, null); + } + public void testCustomSettings() { doTest(null, null, null, "/custom_settings.py"); } From 0202233e619a6ccb67011f7eaa502de2883a5564 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Fri, 26 Apr 2013 14:00:11 +0200 Subject: [PATCH 069/183] Don't run packaging tests on Windows. --- .../jetbrains/env/python/PyPackagingTest.java | 33 ++++++++----------- 1 file changed, 13 insertions(+), 20 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index 8d8a7028e815..d5f6e17d2a2f 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -3,21 +3,15 @@ package com.jetbrains.env.python; import com.google.common.collect.Sets; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.projectRoots.Sdk; -import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; -import com.intellij.openapi.vfs.LocalFileSystem; -import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.util.Processor; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; -import com.jetbrains.python.PythonTestUtil; -import com.jetbrains.python.fixtures.PyTestCase; +import com.jetbrains.env.python.debug.PyTestTask; import com.jetbrains.python.packaging.*; import com.jetbrains.python.sdk.PythonSdkType; import com.jetbrains.python.sdk.flavors.PythonSdkFlavor; import com.jetbrains.python.sdk.flavors.VirtualEnvSdkFlavor; -import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.io.File; @@ -35,10 +29,19 @@ public class PyPackagingTest extends PyEnvTestCase { public static final String PIP_VERSION = "1.1"; public static final String DISTRIBUTE_VERSION = "0.6.27"; + @Override + public void runPythonTest(PyTestTask testTask) { + if (PyEnvTestCase.IS_UNDER_TEAMCITY && SystemInfo.isWindows) { + return; //Don't run under Windows as after deleting from created virtualenvs original interpreter got spoiled + } + + super.runPythonTest(testTask); + } + public void testGetPackages() { runPythonTest(new PyPackagingTestTask() { @Override - public void runPackageTestOn(String sdkHome) throws Exception { + public void runTestOn(String sdkHome) throws Exception { final Sdk sdk = PythonSkeletonsTest.createTempSdk(sdkHome); List packages = null; try { @@ -63,7 +66,7 @@ public class PyPackagingTest extends PyEnvTestCase { public void testCreateVirtualEnv() { runPythonTest(new PyPackagingTestTask() { @Override - public void runPackageTestOn(String sdkHome) throws Exception { + public void runTestOn(String sdkHome) throws Exception { final Sdk sdk = PythonSkeletonsTest.createTempSdk(sdkHome); try { final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); @@ -98,7 +101,7 @@ public class PyPackagingTest extends PyEnvTestCase { runPythonTest(new PyPackagingTestTask() { @Override - public void runPackageTestOn(String sdkHome) throws Exception { + public void runTestOn(String sdkHome) throws Exception { final Sdk sdk = PythonSkeletonsTest.createTempSdk(sdkHome); try { final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); @@ -154,15 +157,5 @@ public class PyPackagingTest extends PyEnvTestCase { public Set getTags() { return Sets.newHashSet("packaging"); } - - @Override - public void runTestOn(String sdkHome) throws Exception { - if (PyEnvTestCase.IS_UNDER_TEAMCITY && SystemInfo.isWindows) { - return; //Don't run under Windows as after deleting from created virtualenvs original interpreter got spoiled - } - runPackageTestOn(sdkHome); - } - - protected abstract void runPackageTestOn(String sdkHome) throws Exception; } } From f71e601cc2cd7892ea8ba6e80d6efd8588789311 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Fri, 26 Apr 2013 14:02:47 +0200 Subject: [PATCH 070/183] IronPython 2.7.2 is more compatible, so we can allow previously unsupported debugger tests to run on it. --- .../testSrc/com/jetbrains/env/python/PythonDebuggerTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index 6570ad00ba1d..04f311e80be8 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -347,7 +347,7 @@ public class PythonDebuggerTest extends PyEnvTestCase { @Override public Set getTags() { - return ImmutableSet.of("-pypy", "-iron"); //TODO: fix it for Pypy and ironpython + return ImmutableSet.of("-pypy"); //TODO: fix it for Pypy } }); } @@ -394,7 +394,7 @@ public class PythonDebuggerTest extends PyEnvTestCase { @Override public Set getTags() { - return ImmutableSet.of("-pypy", "-iron"); //TODO: fix that for PyPy and IronPython + return ImmutableSet.of("-pypy"); //TODO: fix that for PyPy } }); } From 75acff462c84c66b3b6d98871e52c847f2f377b4 Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Sat, 27 Apr 2013 17:13:39 +0400 Subject: [PATCH 071/183] added test for Django11 and Django12 projects --- .../com/jetbrains/env/django/DjangoTestRunnerTest.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java index 3154e5cdd9e9..6e8adc7ddffe 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java @@ -85,6 +85,14 @@ public class DjangoTestRunnerTest extends PyEnvTestCase { }); } + public void testDjango11() { + doTest(); + } + + public void testDjango12() { + doTest("", "settings.py", "", null); + } + public void testDjango13() { doTest(); } From a586d867c8fdef9f02ee7937c847052748cbe5bd Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Mon, 13 May 2013 16:49:14 +0400 Subject: [PATCH 072/183] removed duplicate test (for ManageLibraryTest..) --- .../env/django/DjangoManageTest.java | 65 ------------------- 1 file changed, 65 deletions(-) delete mode 100644 python/testSrc/com/jetbrains/env/django/DjangoManageTest.java diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTest.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTest.java deleted file mode 100644 index 29622d1dd4f3..000000000000 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTest.java +++ /dev/null @@ -1,65 +0,0 @@ -package com.jetbrains.env.django; - -import com.intellij.execution.ExecutionException; -import com.intellij.execution.configurations.ConfigurationFactory; -import com.jetbrains.django.manage.BaseCommand; -import com.jetbrains.django.manage.ManageTasksModel; -import com.jetbrains.django.util.ManagePyUtil; -import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.python.PythonTestUtil; -import org.apache.commons.lang.builder.ToStringBuilder; -import org.apache.commons.lang.builder.ToStringStyle; -import org.jetbrains.annotations.Nullable; - -import java.io.IOException; -import java.util.Set; - -/** - * User : ktisha - */ -public class DjangoManageTest extends PyEnvTestCase { - - public void testTaskListCompleteness() throws IOException { - runPythonTest(new DjangoManageTestTask() { - @Override - protected String getTestDataPath() { - return PythonTestUtil.getTestDataPath() + "/django/manage/completeness"; - } - - public void testing() throws Exception { - waitForOutput("Process finished with exit code"); - - Set defCommands = getCommands(); - String allCommands = ToStringBuilder.reflectionToString(defCommands.toArray(), ToStringStyle.SIMPLE_STYLE); - for (BaseCommand task : ManageTasksModel.getTasks(null)) { - assertTrue(String.format("'%s' not found in a list of possible commands :%s", task.getCommand(), allCommands), - defCommands.remove(task.getCommand())); - } - defCommands.remove("startproject"); - assertEmpty( - "Not all possible commands was listed:" + ToStringBuilder.reflectionToString(defCommands.toArray(), ToStringStyle.SIMPLE_STYLE), - defCommands); - } - - public Set getCommands() throws ExecutionException { - Set result = ManagePyUtil.extractAvailableCommands(stdout() + stderr()); - assertFalse(stdout() + stderr(), result.isEmpty()); - result.add("createsuperuser"); - result.add("changepassword"); - - return result; - } - - @Nullable - @Override - public ConfigurationFactory getFactory() { - return null; - } - - @Override - protected String getSubcommand() { - return ""; - } - }); - } -} From aa04145899a5053e966cd2692e10ce19adc567c4 Mon Sep 17 00:00:00 2001 From: Alexey Kudravtsev Date: Tue, 21 May 2013 14:08:00 +0400 Subject: [PATCH 073/183] removed apache commons library usage --- .../com/jetbrains/env/PyTestRemoteSdkProvider.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java index 3b7be60dbac9..6cccd3d43d87 100644 --- a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java +++ b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java @@ -9,12 +9,12 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; +import com.intellij.openapi.util.text.StringUtil; import com.intellij.remotesdk.RemoteInterpreterException; import com.intellij.util.ui.UIUtil; import com.jetbrains.env.python.debug.PyTestTask; import com.jetbrains.python.remote.PyRemoteInterpreterManagerImpl; import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; -import org.apache.commons.lang.StringUtils; import java.io.File; import java.io.IOException; @@ -92,11 +92,11 @@ public class PyTestRemoteSdkProvider { } private static boolean isPasswordSpecified() { - return !StringUtils.isEmpty(System.getenv(LOCAL_SSH_WITHOUT_PASSWORD)) || !StringUtils.isEmpty(getPassword()); + return !StringUtil.isEmpty(System.getenv(LOCAL_SSH_WITHOUT_PASSWORD)) || !StringUtil.isEmpty(getPassword()); } public static boolean shouldFailWhenCantRunRemote() { - return !StringUtils.isEmpty(System.getenv("FAIL_WHEN_CANT_RUN_REMOTE")) || PyEnvSufficiencyTest.IS_UNDER_TEAMCITY; + return !StringUtil.isEmpty(System.getenv("FAIL_WHEN_CANT_RUN_REMOTE")) || PyEnvSufficiencyTest.IS_UNDER_TEAMCITY; } private static String getHelpersPath(PyRemoteSdkAdditionalData data) throws IOException { @@ -109,7 +109,7 @@ public class PyTestRemoteSdkProvider { public static String getUserName() { String userName = System.getenv(SSH_USER_NAME); - return StringUtils.isEmpty(userName) ? System.getProperty("user.name") : userName; + return StringUtil.isEmpty(userName) ? System.getProperty("user.name") : userName; } public static String getPassword() { From 1f4b29712cd4c5785c0e090e5746fbbef0013199 Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Wed, 17 Jul 2013 18:47:54 +0400 Subject: [PATCH 074/183] Fixed duplicate requirements if several requires args are specified (PY-10297) --- .../env/python/PyPackageRequirementsInspectionTest.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java index 676a5ebb39df..d4501e4d3b7b 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java @@ -32,6 +32,10 @@ public class PyPackageRequirementsInspectionTest extends PyEnvTestCase { doTest("test1.py"); } + public void testDuplicateInstallAndTests() { + doTest("test1.py"); + } + private void doTest(@NotNull final String filename) { final String dir = getTestName(false); runPythonTest(new PyExecutionFixtureTestTask() { From 2b3ef441d257e4a1884c5435fb400a593bee39c2 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Wed, 24 Jul 2013 17:57:44 +0200 Subject: [PATCH 075/183] store Executor instance in ExecutionEnvironment; don't pass it to ProgramRunner.execute() separately --- .../com/jetbrains/env/django/DjangoManageTestTask.java | 4 ++-- .../com/jetbrains/env/python/debug/PyDebuggerTask.java | 2 +- .../com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java | 2 +- python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java | 4 ++-- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java index a8f07f7e1a36..c59b13b99c5f 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java @@ -197,13 +197,13 @@ public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { Assert.assertTrue(runner.canRun(DefaultRunExecutor.EXECUTOR_ID, config)); - final ExecutionEnvironment env = new ExecutionEnvironment(runner, settings, project); final Executor executor = DefaultRunExecutor.getRunExecutorInstance(); + final ExecutionEnvironment env = new ExecutionEnvironment(executor, runner, settings, project); UIUtil.invokeAndWaitIfNeeded(new Runnable() { public void run() { try { - runner.execute(executor, env, new ProgramRunner.Callback() { + runner.execute(env, new ProgramRunner.Callback() { @Override public void processStarted(RunContentDescriptor descriptor) { myDescriptor = descriptor; diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index 24408a72dc8c..e84e8ec5f02c 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -76,8 +76,8 @@ public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTesta final PyDebugRunner runner = (PyDebugRunner)ProgramRunnerUtil.getRunner(DefaultDebugExecutor.EXECUTOR_ID, settings); Assert.assertTrue(runner.canRun(DefaultDebugExecutor.EXECUTOR_ID, myRunConfiguration)); - final ExecutionEnvironment env = new ExecutionEnvironment(runner, settings, project); final Executor executor = DefaultDebugExecutor.getDebugExecutorInstance(); + final ExecutionEnvironment env = new ExecutionEnvironment(executor, runner, settings, project); final PythonCommandLineState pyState = (PythonCommandLineState)myRunConfiguration.getState(executor, env); diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java index 676ad580d5d0..a9fae7bf0cbf 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java @@ -71,8 +71,8 @@ public class PyRemoteDebuggerTask extends PyBaseDebuggerTask { final PyRemoteDebugRunner runner = (PyRemoteDebugRunner)ProgramRunnerUtil.getRunner(DefaultDebugExecutor.EXECUTOR_ID, settings); Assert.assertTrue(runner.canRun(DefaultDebugExecutor.EXECUTOR_ID, config)); - final ExecutionEnvironment env = new ExecutionEnvironment(runner, settings, project); final Executor executor = DefaultDebugExecutor.getDebugExecutorInstance(); + final ExecutionEnvironment env = new ExecutionEnvironment(executor, runner, settings, project); final PyRemoteDebugCommandLineState pyState = (PyRemoteDebugCommandLineState)config.getState(executor, env); diff --git a/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java b/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java index 45bf40d93bb4..c98f0f1c2786 100644 --- a/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java +++ b/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java @@ -152,8 +152,8 @@ public abstract class PyUnitTestTask extends PyExecutionFixtureTestTask { Assert.assertTrue(runner.canRun(DefaultRunExecutor.EXECUTOR_ID, config)); - final ExecutionEnvironment env = new ExecutionEnvironment(runner, settings, project); final Executor executor = DefaultRunExecutor.getRunExecutorInstance(); + final ExecutionEnvironment env = new ExecutionEnvironment(executor, runner, settings, project); before(); @@ -165,7 +165,7 @@ public abstract class PyUnitTestTask extends PyExecutionFixtureTestTask { UIUtil.invokeAndWaitIfNeeded(new Runnable() { public void run() { try { - runner.execute(executor, env, new ProgramRunner.Callback() { + runner.execute(env, new ProgramRunner.Callback() { @Override public void processStarted(RunContentDescriptor descriptor) { myDescriptor = descriptor; From 371f2f57867840d864d9f2e7ceb2e2e06ba07046 Mon Sep 17 00:00:00 2001 From: Alexey Kudravtsev Date: Fri, 2 Aug 2013 12:26:13 +0400 Subject: [PATCH 076/183] notnull --- .../jetbrains/env/python/debug/PyExecutionFixtureTestTask.java | 1 + 1 file changed, 1 insertion(+) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java index db6265c4bbbb..059a4c8d283a 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java @@ -128,6 +128,7 @@ public abstract class PyExecutionFixtureTestTask extends PyTestTask { } + @NotNull @Override public EmptyModuleBuilder createModuleBuilder() { return new EmptyModuleBuilder() { From aac5859415c01bd6ebe3decc20ab6ef8cc26e2b7 Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Mon, 26 Aug 2013 17:38:05 +0400 Subject: [PATCH 077/183] Types for known stdlib properties in skeletons --- .../env/python/PythonSkeletonsTest.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index 28ed0a9628c2..cf0658194ef4 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -20,12 +20,17 @@ import com.intellij.testFramework.fixtures.CodeInsightTestFixture; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; import com.jetbrains.env.python.debug.PyTestTask; +import com.jetbrains.python.PythonFileType; import com.jetbrains.python.PythonTestUtil; +import com.jetbrains.python.documentation.PythonDocumentationProvider; import com.jetbrains.python.inspections.PyUnresolvedReferencesInspection; import com.jetbrains.python.psi.LanguageLevel; +import com.jetbrains.python.psi.PyExpression; import com.jetbrains.python.psi.PyFile; import com.jetbrains.python.psi.impl.PyBuiltinCache; import com.jetbrains.python.psi.resolve.PythonSdkPathCache; +import com.jetbrains.python.psi.types.PyType; +import com.jetbrains.python.psi.types.TypeEvalContext; import com.jetbrains.python.sdk.InvalidSdkException; import com.jetbrains.python.sdk.PythonSdkType; import com.jetbrains.python.sdk.skeletons.PySkeletonRefresher; @@ -122,6 +127,21 @@ public class PythonSkeletonsTest extends PyEnvTestCase { }); } + public void testKnownPropertiesTypes() { + runTest(new SkeletonsTask() { + @Override + protected void runTestOn(@NotNull Sdk sdk) { + myFixture.configureByText(PythonFileType.INSTANCE, + "expr = slice(1, 2).start\n"); + final PyExpression expr = myFixture.findElementByText("expr", PyExpression.class); + final TypeEvalContext context = TypeEvalContext.codeAnalysis(myFixture.getFile()); + final PyType type = context.getType(expr); + final String actualType = PythonDocumentationProvider.getTypeName(type, context); + assertEquals("int", actualType); + } + }); + } + private void generateTempSkeletons(CodeInsightTestFixture fixture, final @NotNull Sdk sdk) throws InvalidSdkException, IOException { final Project project = fixture.getProject(); ModuleRootModificationUtil.setModuleSdk(fixture.getModule(), sdk); From c080f3da01e8ede9151c7f3c4d90abba5712acef Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Mon, 26 Aug 2013 19:13:47 +0400 Subject: [PATCH 078/183] Skeleton properties have read-write-delete access by default (PY-9797) --- .../env/python/PythonSkeletonsTest.java | 30 +++++++++++++++++-- 1 file changed, 27 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index cf0658194ef4..854c6b85c4da 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -24,9 +24,7 @@ import com.jetbrains.python.PythonFileType; import com.jetbrains.python.PythonTestUtil; import com.jetbrains.python.documentation.PythonDocumentationProvider; import com.jetbrains.python.inspections.PyUnresolvedReferencesInspection; -import com.jetbrains.python.psi.LanguageLevel; -import com.jetbrains.python.psi.PyExpression; -import com.jetbrains.python.psi.PyFile; +import com.jetbrains.python.psi.*; import com.jetbrains.python.psi.impl.PyBuiltinCache; import com.jetbrains.python.psi.resolve.PythonSdkPathCache; import com.jetbrains.python.psi.types.PyType; @@ -35,6 +33,7 @@ import com.jetbrains.python.sdk.InvalidSdkException; import com.jetbrains.python.sdk.PythonSdkType; import com.jetbrains.python.sdk.skeletons.PySkeletonRefresher; import com.jetbrains.python.sdk.skeletons.SkeletonVersionChecker; +import com.jetbrains.python.toolbox.Maybe; import org.jetbrains.annotations.NotNull; import java.io.File; @@ -142,6 +141,31 @@ public class PythonSkeletonsTest extends PyEnvTestCase { }); } + // PY-9797 + public void testReadWriteDeletePropertyDefault() { + runTest(new SkeletonsTask() { + @Override + protected void runTestOn(@NotNull Sdk sdk) { + final Project project = myFixture.getProject(); + final PyFile builtins = PyBuiltinCache.getBuiltinsForSdk(project, sdk); + assertNotNull(builtins); + final PyClass cls = builtins.findTopLevelClass("int"); + assertNotNull(cls); + final Property prop = cls.findProperty("real"); + assertNotNull(prop); + assertIsNotNull(prop.getGetter()); + assertIsNotNull(prop.getSetter()); + assertIsNotNull(prop.getDeleter()); + } + + private void assertIsNotNull(Maybe accessor) { + if (accessor.isDefined()) { + assertNotNull(accessor.valueOrNull()); + } + } + }); + } + private void generateTempSkeletons(CodeInsightTestFixture fixture, final @NotNull Sdk sdk) throws InvalidSdkException, IOException { final Project project = fixture.getProject(); ModuleRootModificationUtil.setModuleSdk(fixture.getModule(), sdk); From 2b7d9a775f303adf6b47098b35b9eb14579a61dc Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Sun, 1 Sep 2013 14:22:58 +0200 Subject: [PATCH 079/183] Asynchronous call to debugger in consoleExec command. --- .../env/python/PythonDebuggerTest.java | 25 ++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index 04f311e80be8..520c41d85fac 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -9,8 +9,10 @@ import com.jetbrains.env.python.debug.PyDebuggerTask; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.ut.PyUnitTestTask; import com.jetbrains.python.console.pydev.PydevCompletionVariant; +import com.jetbrains.python.debugger.PyDebuggerException; import com.jetbrains.python.debugger.PyExceptionBreakpointProperties; import com.jetbrains.python.debugger.PyExceptionBreakpointType; +import com.jetbrains.python.debugger.pydev.ProcessDebugger; import com.jetbrains.python.sdk.flavors.PythonSdkFlavor; import java.util.List; @@ -109,23 +111,40 @@ public class PythonDebuggerTest extends PyEnvTestCase { waitForPause(); - myDebugProcess.consoleExec("'i=%d'%i"); + consoleExec("'i=%d'%i"); waitForOutput("'i=1'"); - myDebugProcess.consoleExec("x"); + consoleExec("x"); waitForOutput("name 'x' is not defined"); - myDebugProcess.consoleExec("1-;"); + consoleExec("1-;"); waitForOutput("SyntaxError"); resume(); } + + private void consoleExec(String command) { + myDebugProcess.consoleExec(command, new ProcessDebugger.DebugCallback() { + @Override + public void ok(String value) { + + } + + @Override + public void error(PyDebuggerException exception) { + } + }); + } }); + + } + + public void testDebugCompletion() throws Exception { runPythonTest(new PyDebuggerTask("/debug", "test4.py") { @Override From 79263066f8035258dbda4075a79e26eaf457f6a3 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 3 Sep 2013 14:48:54 +0200 Subject: [PATCH 080/183] Variable view in Python Console. --- .../com/jetbrains/env/python/console/PyConsoleTask.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 4704564e8254..91100f8e71ef 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -1,6 +1,7 @@ package com.jetbrains.env.python.console; import com.google.common.collect.Lists; +import com.intellij.execution.console.LanguageConsoleView; import com.intellij.execution.console.LanguageConsoleViewImpl; import com.intellij.execution.process.ProcessAdapter; import com.intellij.execution.process.ProcessEvent; @@ -138,7 +139,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { consoleRunner.addConsoleListener(new PydevConsoleRunner.ConsoleListener() { @Override - public void handleConsoleInitialized(LanguageConsoleViewImpl consoleView) { + public void handleConsoleInitialized(LanguageConsoleView consoleView) { mySemaphore0.release(); } }); From 1943e9006f281a9119cdb130808ec51575643dc7 Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Tue, 3 Sep 2013 20:20:19 +0400 Subject: [PATCH 081/183] Turned off skeleton property access test for older Pyhtons --- .../com/jetbrains/env/python/PythonSkeletonsTest.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index 854c6b85c4da..c1ca819f086b 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -146,6 +146,11 @@ public class PythonSkeletonsTest extends PyEnvTestCase { runTest(new SkeletonsTask() { @Override protected void runTestOn(@NotNull Sdk sdk) { + final LanguageLevel languageLevel = PythonSdkType.getLanguageLevelForSdk(sdk); + // We rely on int.real property that is not explicitly annotated in the skeletons generator + if (languageLevel.isOlderThan(LanguageLevel.PYTHON26)) { + return; + } final Project project = myFixture.getProject(); final PyFile builtins = PyBuiltinCache.getBuiltinsForSdk(project, sdk); assertNotNull(builtins); From 01e12018316080becc61cc0ae7b00417b01c1bcd Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Sat, 7 Sep 2013 18:19:34 +0400 Subject: [PATCH 082/183] improved django test runner tests --- .../com/jetbrains/env/django/DjangoTestRunnerTest.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java index 6e8adc7ddffe..4e2dff7e9cbf 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java @@ -25,8 +25,11 @@ public class DjangoTestRunnerTest extends PyEnvTestCase { private static void doTest(@NotNull final String output, @NotNull final String testDataPath) { final String[] splittedOutput = output.split("\\n"); final ArrayList outputList = Lists.newArrayList(); + boolean add = false; for (String s : splittedOutput) { - outputList.add(norm(s)); + if ("sys.path end".equals(s)) add = false; + if (add) outputList.add(norm(s)); + if ("sys.path start".equals(s)) add = true; } assertEquals(outputList.indexOf(testDataPath), outputList.lastIndexOf(testDataPath)); From 22b10611f2eabbf7ce913ea200631f3ef610ae4c Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Fri, 13 Sep 2013 18:21:01 +0200 Subject: [PATCH 083/183] Test console variable value retrieval. --- .../env/python/PythonConsoleTest.java | 15 ++++++++++++ .../env/python/console/PyConsoleTask.java | 24 +++++++++++++++++++ 2 files changed, 39 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java index f9fcf52220df..726e3b10fbe8 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java @@ -74,4 +74,19 @@ public class PythonConsoleTest extends PyEnvTestCase { } }); } + + + public void testVariablesView() throws Exception { + runPythonTest(new PyConsoleTask() { + @Override + public void testing() throws Exception { + exec("x = 1"); + exec("print(x)"); + waitForOutput("1"); + + assertTrue("Variable has wrong value", + hasValue("x", "1")); + } + }); + } } diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 91100f8e71ef..7ac66f1a0b7a 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -14,13 +14,21 @@ import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiDocumentManager; import com.intellij.util.ui.UIUtil; +import com.intellij.xdebugger.frame.XValue; +import com.intellij.xdebugger.frame.XValueChildrenList; +import com.intellij.xdebugger.frame.XValueGroup; +import com.intellij.xdebugger.impl.ui.tree.nodes.XStackFrameNode; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; import com.jetbrains.python.console.*; import com.jetbrains.python.console.pydev.ConsoleCommunicationListener; +import com.jetbrains.python.debugger.PyDebugValue; +import com.jetbrains.python.debugger.PyDebuggerException; import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.NotNull; import org.junit.Assert; +import javax.swing.tree.TreeNode; +import java.util.Enumeration; import java.util.List; import java.util.concurrent.Semaphore; @@ -329,6 +337,22 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { //waitForOutput(">>> " + command); } + protected boolean hasValue(String varName, String value) throws PyDebuggerException { + XValueChildrenList l = myCommunication.loadFrame(); + + if (l == null) { + return false; + } + for (int i = 0; i < l.size(); i++) { + String name = l.getName(i); + if (varName.equals(name)) { + return value.equals(((PyDebugValue)l.getValue(i)).getValue()); + } + } + + return false; + } + protected void input(String text) { myConsoleView.executeInConsole(text); } From 2e3260c611dd029807f3f01d6322aa3359b8dad7 Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Fri, 13 Sep 2013 21:04:01 +0400 Subject: [PATCH 084/183] Updated Python package management tools (PY-9700, PY-8681) --- .../jetbrains/env/python/PyPackagingTest.java | 19 +++++++------------ 1 file changed, 7 insertions(+), 12 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index d5f6e17d2a2f..78ed64c782c8 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -1,7 +1,6 @@ package com.jetbrains.env.python; import com.google.common.collect.Sets; -import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; @@ -25,10 +24,6 @@ import java.util.Set; * @author vlan */ public class PyPackagingTest extends PyEnvTestCase { - private static final Logger LOG = Logger.getInstance(PyEnvTestCase.class.getName()); - public static final String PIP_VERSION = "1.1"; - public static final String DISTRIBUTE_VERSION = "0.6.27"; - @Override public void runPythonTest(PyTestTask testTask) { if (PyEnvTestCase.IS_UNDER_TEAMCITY && SystemInfo.isWindows) { @@ -49,7 +44,7 @@ public class PyPackagingTest extends PyEnvTestCase { } catch (PyExternalProcessException e) { final int retcode = e.getRetcode(); - if (retcode != PyPackageManagerImpl.ERROR_NO_PIP && retcode != PyPackageManagerImpl.ERROR_NO_DISTRIBUTE) { + if (retcode != PyPackageManagerImpl.ERROR_NO_PIP && retcode != PyPackageManagerImpl.ERROR_NO_SETUPTOOLS) { fail(String.format("Error for interpreter '%s': %s", sdk.getHomePath(), e.getMessage())); } } @@ -78,14 +73,14 @@ public class PyPackagingTest extends PyEnvTestCase { assertTrue(PythonSdkType.isVirtualEnv(venvSdk)); assertInstanceOf(PythonSdkFlavor.getPlatformIndependentFlavor(venvSdk.getHomePath()), VirtualEnvSdkFlavor.class); final List packages = ((PyPackageManagerImpl)PyPackageManagerImpl.getInstance(venvSdk)).getPackages(); - final PyPackage distribute = findPackage("distribute", packages); - assertNotNull(distribute); - assertEquals("distribute", distribute.getName()); - assertEquals(DISTRIBUTE_VERSION, distribute.getVersion()); + final PyPackage setuptools = findPackage("setuptools", packages); + assertNotNull(setuptools); + assertEquals("setuptools", setuptools.getName()); + assertEquals(PyPackageManagerImpl.SETUPTOOLS_VERSION, setuptools.getVersion()); final PyPackage pip = findPackage("pip", packages); assertNotNull(pip); assertEquals("pip", pip.getName()); - assertEquals(PIP_VERSION, pip.getVersion()); + assertEquals(PyPackageManagerImpl.PIP_VERSION, pip.getVersion()); } catch (IOException e) { throw new RuntimeException(e); @@ -121,7 +116,7 @@ public class PyPackagingTest extends PyEnvTestCase { final PyPackage pip1 = findPackage("pip", packages1); assertNotNull(pip1); assertEquals("pip", pip1.getName()); - assertEquals(PIP_VERSION, pip1.getVersion()); + assertEquals(PyPackageManagerImpl.PIP_VERSION, pip1.getVersion()); manager.uninstall(list(pip1)); final List packages3 = manager.getPackages(); final PyPackage pip2 = findPackage("pip", packages3); From 939ec1953135c92a80b3526e01878b3d24148178 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Sun, 15 Sep 2013 20:52:30 +0200 Subject: [PATCH 085/183] Test for get variable in console variables view. --- .../env/python/PythonConsoleTest.java | 18 +++++++++++++++ .../env/python/console/PyConsoleTask.java | 23 +++++++++++++++---- 2 files changed, 37 insertions(+), 4 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java index 726e3b10fbe8..63da37dd88af 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java @@ -1,10 +1,13 @@ package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; +import com.intellij.xdebugger.frame.XValueChildrenList; import com.jetbrains.env.python.console.PyConsoleTask; import com.jetbrains.env.python.debug.PyEnvTestCase; import org.junit.Assert; +import java.util.Collections; +import java.util.List; import java.util.Set; /** @@ -89,4 +92,19 @@ public class PythonConsoleTest extends PyEnvTestCase { } }); } + + public void testCompoundVariable() throws Exception { + runPythonTest(new PyConsoleTask() { + @Override + public void testing() throws Exception { + exec("x = [1, 2, 3]"); + exec("print(x)"); + waitForOutput("[1, 2, 3]"); + + List values = getCompoundValueChildren(getValue("x")); + Collections.sort(values); + assertContainsElements(values, "1", "2", "3", "3"); + } + }); + } } diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 7ac66f1a0b7a..62b7ab2657e1 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -28,6 +28,7 @@ import org.jetbrains.annotations.NotNull; import org.junit.Assert; import javax.swing.tree.TreeNode; +import java.util.ArrayList; import java.util.Enumeration; import java.util.List; import java.util.concurrent.Semaphore; @@ -338,19 +339,33 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { } protected boolean hasValue(String varName, String value) throws PyDebuggerException { + PyDebugValue val = getValue(varName); + return val != null && value.equals(val.getValue()); + } + + protected PyDebugValue getValue(String varName) throws PyDebuggerException { XValueChildrenList l = myCommunication.loadFrame(); if (l == null) { - return false; + return null; } for (int i = 0; i < l.size(); i++) { String name = l.getName(i); if (varName.equals(name)) { - return value.equals(((PyDebugValue)l.getValue(i)).getValue()); + return (PyDebugValue)l.getValue(i); } } - - return false; + + return null; + } + + protected List getCompoundValueChildren(PyDebugValue value) throws PyDebuggerException { + XValueChildrenList list = myCommunication.loadVariable(value); + List result = Lists.newArrayList(); + for (int i = 0; i Date: Sun, 15 Sep 2013 21:13:57 +0200 Subject: [PATCH 086/183] Add change variable env-test. --- .../jetbrains/env/python/PythonConsoleTest.java | 16 ++++++++++++++++ .../env/python/console/PyConsoleTask.java | 5 +++++ 2 files changed, 21 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java index 63da37dd88af..366d196337e7 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java @@ -107,4 +107,20 @@ public class PythonConsoleTest extends PyEnvTestCase { } }); } + + public void testChangeVariable() throws Exception { + runPythonTest(new PyConsoleTask() { + @Override + public void testing() throws Exception { + exec("x = 1"); + exec("print(x)"); + waitForOutput("1"); + + setValue("x", "2"); + + assertTrue("Variable has wrong value", + hasValue("x", "2")); + } + }); + } } diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 62b7ab2657e1..4003b1a971b1 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -342,6 +342,11 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { PyDebugValue val = getValue(varName); return val != null && value.equals(val.getValue()); } + + protected void setValue(String varName, String value) throws PyDebuggerException { + PyDebugValue val = getValue(varName); + myCommunication.changeVariable(val, value); + } protected PyDebugValue getValue(String varName) throws PyDebuggerException { XValueChildrenList l = myCommunication.loadFrame(); From a22d642a2454b01a0442e5d12f38e095848f75ac Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Tue, 17 Sep 2013 19:23:27 +0400 Subject: [PATCH 087/183] fixed PY-10814 Django test runner fails to run as it cannot import settings. EAP 131.91 --- .../com/jetbrains/env/django/DjangoTestRunnerTest.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java index 4e2dff7e9cbf..56470e5d2627 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java @@ -132,4 +132,8 @@ public class DjangoTestRunnerTest extends PyEnvTestCase { doTest(null, null, null, "/custom_settings.py"); } + public void testInstalledApps() { + doTest("/InstalledApps", "/config/settings/installedapps.py", null, "/config/settings/installedapps.py"); + } + } From ce1899ad1f72dbbabc99dd1aca74550192bf2b6a Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Wed, 18 Sep 2013 16:34:18 +0200 Subject: [PATCH 088/183] Method renamed. --- .../testSrc/com/jetbrains/env/python/console/PyConsoleTask.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 4003b1a971b1..80c3c22a9ac6 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -168,7 +168,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { myCommunication.addCommunicationListener(new ConsoleCommunicationListener() { @Override - public void executionFinished() { + public void commandExecuted() { mySemaphore.release(); } From c3f00a43a04c941205059bdd73af9a5d44702606 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 24 Sep 2013 18:11:41 +0200 Subject: [PATCH 089/183] Fix multiprocess debug for Python 3.3 on Windows (PY-8258). --- .../env/python/PythonDebuggerTest.java | 31 +++++++++++++++++++ .../env/python/debug/PyDebuggerTask.java | 6 ++++ 2 files changed, 37 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index 520c41d85fac..23d38b0ebb6d 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -2,6 +2,7 @@ package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; +import com.google.common.collect.Sets; import com.intellij.openapi.application.PathManager; import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; import com.intellij.xdebugger.XDebuggerTestUtil; @@ -460,6 +461,36 @@ public class PythonDebuggerTest extends PyEnvTestCase { }); } + public void testMultiprocess() throws Exception { + runPythonTest(new PyDebuggerTask("/debug", "test_multiprocess.py") { + @Override + protected void init() { + setMultiprocessDebug(true); + } + + @Override + public void before() throws Exception { + toggleBreakpoint(getScriptPath(), 9); + } + + @Override + public void testing() throws Exception { + waitForPause(); + + eval("i").hasValue("'Result:OK'"); + + resume(); + + waitForOutput("Result:OK"); + } + + @Override + public Set getTags() { + return Sets.newHashSet("python3"); + } + }); + } + //TODO: fix me as I don't work properly sometimes (something connected with process termination on agent) //public void testResume() throws Exception { diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index e84e8ec5f02c..016ddfe2f992 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -36,18 +36,24 @@ public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTesta private PythonRunConfiguration myRunConfiguration; public PyDebuggerTask() { + init(); } public PyDebuggerTask(String workingFolder, String scriptName, String scriptParameters) { setWorkingFolder(getTestDataPath() + workingFolder); setScriptName(scriptName); setScriptParameters(scriptParameters); + init(); } public PyDebuggerTask(String workingFolder, String scriptName) { this(workingFolder, scriptName, null); } + protected void init() { + + } + public void runTestOn(String sdkHome) throws Exception { final Project project = getProject(); From ab32b0dea7456231f1a074ba8d8e0c92d3ac5688 Mon Sep 17 00:00:00 2001 From: nik Date: Tue, 1 Oct 2013 19:24:26 +0400 Subject: [PATCH 090/183] xdebugger: some usages of impl methods replace by API calls --- .../com/jetbrains/env/python/debug/PyBaseDebuggerTask.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java index 39ffba6abe1a..ab0456a6286a 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java @@ -10,7 +10,6 @@ import com.intellij.openapi.vfs.VirtualFile; import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.*; import com.intellij.xdebugger.frame.XValue; -import com.intellij.xdebugger.impl.XSourcePositionImpl; import com.jetbrains.django.util.VirtualFileUtil; import com.jetbrains.python.console.PythonDebugLanguageConsoleView; import com.jetbrains.python.debugger.PyDebugProcess; @@ -55,7 +54,7 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { XSourcePosition position = currentSession.getCurrentPosition(); - currentSession.runToPosition(XSourcePositionImpl.create(position.getFile(), line), false); + currentSession.runToPosition(XDebuggerUtil.getInstance().createPosition(position.getFile(), line), false); waitForPause(); } From 508248351ef3cdb7fa8daf5511cbd305e48e900a Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Thu, 3 Oct 2013 13:33:24 +0400 Subject: [PATCH 091/183] fixed test data paths --- python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java | 2 +- .../testSrc/com/jetbrains/env/python/PythonGeneratorTest.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index 23d38b0ebb6d..7e92cac69bdd 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -56,7 +56,7 @@ public class PythonDebuggerTest extends PyEnvTestCase { runPythonTest(new PyUnitTestTask("", "test_debug.py") { @Override protected String getTestDataPath() { - return PathManager.getHomePath() + "/python/helpers/pydev"; + return PathManager.getHomePath() + "/python/community/helpers/pydev"; } @Override diff --git a/python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java b/python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java index 16213984e919..a5f86b5da752 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java @@ -12,7 +12,7 @@ public class PythonGeneratorTest extends PyEnvTestCase{ runPythonTest(new PyUnitTestTask("", "test_generator.py") { @Override protected String getTestDataPath() { - return PathManager.getHomePath() + "/python/helpers"; + return PathManager.getHomePath() + "/python/community/helpers"; } @Override From ec9ef83fdb4797d431643fb3d8fe0818afc35049 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Thu, 10 Oct 2013 12:47:08 +0200 Subject: [PATCH 092/183] move testdata to community --- .../jetbrains/env/django/DjangoTemplateBreakpointsTest.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTemplateBreakpointsTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTemplateBreakpointsTest.java index db7e75668733..c9260dfece65 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTemplateBreakpointsTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTemplateBreakpointsTest.java @@ -4,7 +4,6 @@ import com.intellij.openapi.vfs.VirtualFile; import com.intellij.testFramework.fixtures.CodeInsightTestFixture; import com.intellij.xdebugger.XDebuggerUtil; import com.jetbrains.django.fixtures.DjangoTestCase; -import com.jetbrains.python.PythonTestUtil; import junit.framework.Assert; /** @@ -13,7 +12,7 @@ import junit.framework.Assert; public class DjangoTemplateBreakpointsTest extends DjangoTestCase { @Override protected String getTestDataPath() { - return PythonTestUtil.getTestDataPath() + "/django/debug/"; + return super.getTestDataPath() + "/django/debug/"; } public void testCanSetBreakpoints() { From e70e2eb10f3a8112aabd6a9747cf3dabba0c5270 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Mon, 21 Oct 2013 12:56:50 +0200 Subject: [PATCH 093/183] allow env tests to find their testdata --- .../env/django/DjangoEnvTestTask.java | 4 +- .../env/django/DjangoPathTestTask.java | 45 +------------------ .../env/django/DjangoTestRunnerTestTask.java | 4 +- .../env/python/PythonDebuggerTest.java | 4 +- .../env/python/PythonGeneratorTest.java | 4 +- 5 files changed, 10 insertions(+), 51 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java index e8a0c3e5cb34..9a0a38c4aaab 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java @@ -10,7 +10,7 @@ import com.intellij.util.ui.UIUtil; import com.jetbrains.django.facet.DjangoFacet; import com.jetbrains.django.fixtures.DjangoTestCase; import com.jetbrains.env.python.debug.PyDebuggerTask; -import com.jetbrains.python.PythonTestUtil; +import com.jetbrains.python.fixtures.PyProfessionalTestCase; import com.jetbrains.python.templateLanguages.TemplatesService; import org.junit.Assert; @@ -27,7 +27,7 @@ public class DjangoEnvTestTask extends PyDebuggerTask { protected final int myPort; protected String getTestDataPath() { - return PythonTestUtil.getTestDataPath() + "/django/debug"; + return PyProfessionalTestCase.getProfessionalTestDataPath() + "/django/debug"; } public DjangoEnvTestTask(String workingFolder, String scriptName, String scriptParameters, int port) { diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java index c63b37ed9c02..6df0f0a19309 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTestTask.java @@ -1,47 +1,6 @@ package com.jetbrains.env.django; -import com.google.common.collect.ImmutableList; -import com.google.common.collect.ImmutableSet; -import com.intellij.execution.*; -import com.intellij.execution.configurations.ConfigurationFactory; -import com.intellij.execution.executors.DefaultRunExecutor; -import com.intellij.execution.process.ProcessAdapter; -import com.intellij.execution.process.ProcessEvent; -import com.intellij.execution.process.ProcessHandler; -import com.intellij.execution.runners.ExecutionEnvironment; -import com.intellij.execution.runners.ProgramRunner; -import com.intellij.execution.ui.ExecutionConsole; -import com.intellij.execution.ui.RunContentDescriptor; -import com.intellij.openapi.application.Result; -import com.intellij.openapi.application.WriteAction; -import com.intellij.openapi.module.Module; -import com.intellij.openapi.project.Project; -import com.intellij.openapi.projectRoots.Sdk; -import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil; -import com.intellij.openapi.util.Disposer; -import com.intellij.openapi.util.Key; -import com.intellij.openapi.vfs.LocalFileSystem; -import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.util.concurrency.Semaphore; -import com.intellij.util.ui.UIUtil; -import com.intellij.xdebugger.XDebuggerTestUtil; -import com.jetbrains.django.facet.DjangoFacet; -import com.jetbrains.django.fixtures.DjangoTestCase; -import com.jetbrains.django.manage.DjangoManageTask; -import com.jetbrains.django.ui.DjangoBundle; -import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; -import com.jetbrains.python.PythonHelpersLocator; -import com.jetbrains.python.PythonTestUtil; -import com.jetbrains.python.run.AbstractPythonRunConfiguration; -import com.jetbrains.python.run.PythonTracebackFilter; -import com.jetbrains.python.sdk.PythonSdkType; -import com.jetbrains.python.templateLanguages.TemplatesService; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.junit.Assert; - -import java.io.IOException; -import java.util.Set; +import com.jetbrains.python.fixtures.PyProfessionalTestCase; /** * User : catherine @@ -50,7 +9,7 @@ public abstract class DjangoPathTestTask extends DjangoManageTestTask { @Override protected String getTestDataPath() { - return PythonTestUtil.getTestDataPath() + "/django/path/djangoPath"; + return PyProfessionalTestCase.getProfessionalTestDataPath() + "/django/path/djangoPath"; } @Override diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTestTask.java index a3f37b1b9c27..7b6fe8b9f6c2 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTestTask.java @@ -1,6 +1,6 @@ package com.jetbrains.env.django; -import com.jetbrains.python.PythonTestUtil; +import com.jetbrains.python.fixtures.PyProfessionalTestCase; /** * User : ktisha @@ -9,7 +9,7 @@ public abstract class DjangoTestRunnerTestTask extends DjangoManageTestTask { @Override protected String getTestDataPath() { - return PythonTestUtil.getTestDataPath() + "/django/testRunner/" + getTestName(); + return PyProfessionalTestCase.getProfessionalTestDataPath() + "/django/testRunner/" + getTestName(); } abstract String getTestName(); diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index 7e92cac69bdd..812a8ef51108 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -3,12 +3,12 @@ package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; import com.google.common.collect.Sets; -import com.intellij.openapi.application.PathManager; import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; import com.intellij.xdebugger.XDebuggerTestUtil; import com.jetbrains.env.python.debug.PyDebuggerTask; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.ut.PyUnitTestTask; +import com.jetbrains.python.PythonHelpersLocator; import com.jetbrains.python.console.pydev.PydevCompletionVariant; import com.jetbrains.python.debugger.PyDebuggerException; import com.jetbrains.python.debugger.PyExceptionBreakpointProperties; @@ -56,7 +56,7 @@ public class PythonDebuggerTest extends PyEnvTestCase { runPythonTest(new PyUnitTestTask("", "test_debug.py") { @Override protected String getTestDataPath() { - return PathManager.getHomePath() + "/python/community/helpers/pydev"; + return PythonHelpersLocator.getPythonCommunityPath() + "/helpers/pydev"; } @Override diff --git a/python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java b/python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java index a5f86b5da752..e9a227a4fdc4 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java @@ -1,8 +1,8 @@ package com.jetbrains.env.python; -import com.intellij.openapi.application.PathManager; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.ut.PyUnitTestTask; +import com.jetbrains.python.PythonHelpersLocator; /** * @author traff @@ -12,7 +12,7 @@ public class PythonGeneratorTest extends PyEnvTestCase{ runPythonTest(new PyUnitTestTask("", "test_generator.py") { @Override protected String getTestDataPath() { - return PathManager.getHomePath() + "/python/community/helpers"; + return PythonHelpersLocator.getPythonCommunityPath() + "/helpers"; } @Override From 9c5dd83f513b59493cec33214e374c5cdc95280d Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Mon, 21 Oct 2013 14:23:28 +0200 Subject: [PATCH 094/183] one more fix for path to testdata --- .../env/python/debug/PyExecutionFixtureTestTask.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java index 059a4c8d283a..d31894eff557 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java @@ -13,7 +13,7 @@ import com.intellij.testFramework.fixtures.impl.ModuleFixtureBuilderImpl; import com.intellij.testFramework.fixtures.impl.ModuleFixtureImpl; import com.intellij.util.ui.UIUtil; import com.jetbrains.python.PythonModuleTypeBase; -import com.jetbrains.python.PythonTestUtil; +import com.jetbrains.python.fixtures.PyProfessionalTestCase; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -72,7 +72,7 @@ public abstract class PyExecutionFixtureTestTask extends PyTestTask { protected List getContentRoots() { return Lists.newArrayList();} protected String getTestDataPath() { - return PythonTestUtil.getTestDataPath(); + return PyProfessionalTestCase.getProfessionalTestDataPath(); } protected void initFixtureBuilder() { From 9e6a11f42245047876c64ab4f0f8742cec9b6b1b Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 21 Nov 2013 13:14:41 +0100 Subject: [PATCH 095/183] Multiline execution ends with double empty lines. --- python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java index 366d196337e7..aee042458ea8 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java @@ -1,7 +1,6 @@ package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; -import com.intellij.xdebugger.frame.XValueChildrenList; import com.jetbrains.env.python.console.PyConsoleTask; import com.jetbrains.env.python.debug.PyEnvTestCase; import org.junit.Assert; @@ -73,6 +72,7 @@ public class PythonConsoleTest extends PyEnvTestCase { exec(""); exec(" print(x)"); exec(""); + exec(""); waitForOutput("97"); } }); From b32e440c88ba309873359728761c7374f7e6293c Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 21 Nov 2013 13:17:21 +0100 Subject: [PATCH 096/183] If command executed but is incomplete and more lines are needed prompt shouldn't be changed to ordinary one in this case. --- .../com/jetbrains/env/python/console/PyConsoleTask.java | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 80c3c22a9ac6..d5a931a5dfce 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -2,7 +2,6 @@ package com.jetbrains.env.python.console; import com.google.common.collect.Lists; import com.intellij.execution.console.LanguageConsoleView; -import com.intellij.execution.console.LanguageConsoleViewImpl; import com.intellij.execution.process.ProcessAdapter; import com.intellij.execution.process.ProcessEvent; import com.intellij.openapi.application.Result; @@ -14,10 +13,7 @@ import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiDocumentManager; import com.intellij.util.ui.UIUtil; -import com.intellij.xdebugger.frame.XValue; import com.intellij.xdebugger.frame.XValueChildrenList; -import com.intellij.xdebugger.frame.XValueGroup; -import com.intellij.xdebugger.impl.ui.tree.nodes.XStackFrameNode; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; import com.jetbrains.python.console.*; import com.jetbrains.python.console.pydev.ConsoleCommunicationListener; @@ -27,9 +23,6 @@ import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.NotNull; import org.junit.Assert; -import javax.swing.tree.TreeNode; -import java.util.ArrayList; -import java.util.Enumeration; import java.util.List; import java.util.concurrent.Semaphore; @@ -168,7 +161,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { myCommunication.addCommunicationListener(new ConsoleCommunicationListener() { @Override - public void commandExecuted() { + public void commandExecuted(boolean more) { mySemaphore.release(); } From 51787f72806accfa51b168e90f6046d8c9e4652e Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Mon, 9 Dec 2013 18:48:22 +0100 Subject: [PATCH 097/183] Fix test for Iron Python. --- python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java index aee042458ea8..5a5b0d4fe30e 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java @@ -34,7 +34,7 @@ public class PythonConsoleTest extends PyEnvTestCase { " x=1\n" + "y=x+100\n" + "for i in range(1):\n" + - " print(y)"); + " print(y)\n"); waitForOutput("101"); } }); From 69bae55deac45948915574abe80b9e0a60c72968 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 10 Dec 2013 03:46:37 +0100 Subject: [PATCH 098/183] Don't run test on jython: it doesn't support multiline execution: http://bugs.jython.org/issue2106 --- .../testSrc/com/jetbrains/env/python/PythonConsoleTest.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java index 5a5b0d4fe30e..f45240f24fef 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java @@ -1,6 +1,7 @@ package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Sets; import com.jetbrains.env.python.console.PyConsoleTask; import com.jetbrains.env.python.debug.PyEnvTestCase; import org.junit.Assert; @@ -37,6 +38,11 @@ public class PythonConsoleTest extends PyEnvTestCase { " print(y)\n"); waitForOutput("101"); } + + @Override + public Set getTags() { + return Sets.newHashSet("jython"); //jython doesn't support multiline execution: http://bugs.jython.org/issue2106 + } }); } From faafac5d95bd251ca0ca796e54c8e5371f0a972b Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 10 Dec 2013 14:05:10 +0100 Subject: [PATCH 099/183] Don't run on Jython. --- python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java index f45240f24fef..b344e0e2d702 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java @@ -41,7 +41,7 @@ public class PythonConsoleTest extends PyEnvTestCase { @Override public Set getTags() { - return Sets.newHashSet("jython"); //jython doesn't support multiline execution: http://bugs.jython.org/issue2106 + return Sets.newHashSet("-jython"); //jython doesn't support multiline execution: http://bugs.jython.org/issue2106 } }); } From a89286a7126b6b6a9698b7e078fef8cb9e96345b Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 10 Dec 2013 15:14:13 +0100 Subject: [PATCH 100/183] Fix of test: unnecessary empty line after if --- python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java | 1 - 1 file changed, 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java index b344e0e2d702..d81726b2fd70 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java @@ -75,7 +75,6 @@ public class PythonConsoleTest extends PyEnvTestCase { exec("x = 96"); exec("x +=1"); exec("if True:"); - exec(""); exec(" print(x)"); exec(""); exec(""); From dd352825e77715aa71f52b2f4ccc3a2fc6f05dcc Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 10 Dec 2013 15:31:13 +0100 Subject: [PATCH 101/183] One more test is not for jython. --- python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java index d81726b2fd70..992346973a9a 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java @@ -63,7 +63,7 @@ public class PythonConsoleTest extends PyEnvTestCase { @Override public Set getTags() { - return new ImmutableSet.Builder().addAll(super.getTags()).add("-iron").build(); + return Sets.newHashSet("-iron", "-jython"); } }); } From d0a4966163d0a744f4e24d71b6a401fb9af15bea Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 10 Dec 2013 20:00:35 +0100 Subject: [PATCH 102/183] PYTHONDONTWRITEBYTECODE=1 for debugger env tests. --- .../testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java | 1 + 1 file changed, 1 insertion(+) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index 016ddfe2f992..cbeb567b7ed9 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -69,6 +69,7 @@ public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTesta myRunConfiguration.setScriptName(getScriptPath()); myRunConfiguration.setWorkingDirectory(getWorkingFolder()); myRunConfiguration.setScriptParameters(getScriptParameters()); + myRunConfiguration.getEnvs().put("PYTHONDONTWRITEBYTECODE", "1"); //Don't write 'pyc' files as they can't be loaded by other versions new WriteAction() { @Override From 595b645a7c190987dc26416cbfc3cbb820555166 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 10 Dec 2013 22:08:53 +0100 Subject: [PATCH 103/183] Delete *.pyc files before test. --- .../env/python/debug/PyDebuggerTask.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index cbeb567b7ed9..1aca558025ac 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -15,6 +15,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Key; import com.intellij.xdebugger.*; import com.jetbrains.env.RemoteSdkTestable; +import com.jetbrains.python.PythonHelpersLocator; import com.jetbrains.python.debugger.PyDebugProcess; import com.jetbrains.python.debugger.PyDebugRunner; import com.jetbrains.python.run.PythonCommandLineState; @@ -23,6 +24,8 @@ import com.jetbrains.python.run.PythonRunConfiguration; import org.jetbrains.annotations.NotNull; import org.junit.Assert; +import java.io.File; +import java.io.FilenameFilter; import java.io.IOException; import java.net.ServerSocket; import java.util.concurrent.Semaphore; @@ -87,6 +90,9 @@ public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTesta final ExecutionEnvironment env = new ExecutionEnvironment(executor, runner, settings, project); + deletePycFiles(); + + final PythonCommandLineState pyState = (PythonCommandLineState)myRunConfiguration.getState(executor, env); assert pyState != null; @@ -169,6 +175,17 @@ public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTesta doTest(myOutputPrinter); } + private static void deletePycFiles() { + for (File f: PythonHelpersLocator.getHelpersRoot().listFiles(new FilenameFilter() { + @Override + public boolean accept(File dir, String name) { + return name.endsWith(".pyc"); + } + })) { + f.delete(); + } + } + public PythonRunConfiguration getRunConfiguration() { return myRunConfiguration; } From da665cd5200c1dc513808e754c3b0f66a476f36f Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Wed, 11 Dec 2013 15:35:21 +0100 Subject: [PATCH 104/183] Delete __pycache__ --- .../com/jetbrains/env/python/debug/PyDebuggerTask.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index 1aca558025ac..4c7a591117dc 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -13,6 +13,7 @@ import com.intellij.openapi.application.Result; import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Key; +import com.intellij.openapi.util.io.FileUtil; import com.intellij.xdebugger.*; import com.jetbrains.env.RemoteSdkTestable; import com.jetbrains.python.PythonHelpersLocator; @@ -179,10 +180,10 @@ public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTesta for (File f: PythonHelpersLocator.getHelpersRoot().listFiles(new FilenameFilter() { @Override public boolean accept(File dir, String name) { - return name.endsWith(".pyc"); + return name.endsWith(".pyc") || name.equals("__pycache__"); } })) { - f.delete(); + FileUtil.delete(f); } } From 2f0b4812ff9ea1d8ec764b389d7b5fa8e681b53b Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Thu, 19 Dec 2013 16:57:25 +0400 Subject: [PATCH 105/183] Don't run the virtualenv creation test for Python < 2.6 --- .../testSrc/com/jetbrains/env/python/PyPackagingTest.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index 78ed64c782c8..2085e1589d58 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -8,6 +8,7 @@ import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; import com.jetbrains.env.python.debug.PyTestTask; import com.jetbrains.python.packaging.*; +import com.jetbrains.python.psi.LanguageLevel; import com.jetbrains.python.sdk.PythonSdkType; import com.jetbrains.python.sdk.flavors.PythonSdkFlavor; import com.jetbrains.python.sdk.flavors.VirtualEnvSdkFlavor; @@ -64,6 +65,11 @@ public class PyPackagingTest extends PyEnvTestCase { public void runTestOn(String sdkHome) throws Exception { final Sdk sdk = PythonSkeletonsTest.createTempSdk(sdkHome); try { + final LanguageLevel languageLevel = PythonSdkType.getLanguageLevelForSdk(sdk); + // virtualenv >= 0.10 supports Python >= 2.6 + if (languageLevel.isOlderThan(LanguageLevel.PYTHON26)) { + return; + } final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); final File venvDir = new File(tempDir, "venv"); final String venvSdkHome = ((PyPackageManagerImpl)PyPackageManagerImpl.getInstance(sdk)).createVirtualEnv(venvDir.toString(), From 35ac1d68da7c79a63808f7255572c07caf28c381 Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Thu, 16 Jan 2014 17:52:40 +0400 Subject: [PATCH 106/183] Added 'inherited' parameter to PyClass.findProperty() --- .../testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index c1ca819f086b..bdcc15d9029d 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -156,7 +156,7 @@ public class PythonSkeletonsTest extends PyEnvTestCase { assertNotNull(builtins); final PyClass cls = builtins.findTopLevelClass("int"); assertNotNull(cls); - final Property prop = cls.findProperty("real"); + final Property prop = cls.findProperty("real", true); assertNotNull(prop); assertIsNotNull(prop.getGetter()); assertIsNotNull(prop.getSetter()); From 003d4dd8c182fc72d41bcc75933cd6e4f4570fc0 Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Fri, 7 Feb 2014 14:58:28 +0400 Subject: [PATCH 107/183] Test verbosity increased --- .../env/python/IPythonConsoleTest.java | 24 ++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java index a9c8a1327a48..3f12bc8b6c29 100644 --- a/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java @@ -1,12 +1,20 @@ package com.jetbrains.env.python; +import com.google.common.base.Function; +import com.google.common.collect.Collections2; import com.google.common.collect.ImmutableSet; import com.intellij.psi.PsiDocumentManager; +import com.intellij.psi.PsiErrorElement; import com.intellij.psi.PsiFile; import com.intellij.psi.util.PsiTreeUtil; import com.jetbrains.env.python.console.PyConsoleTask; import com.jetbrains.env.python.debug.PyEnvTestCase; +import org.hamcrest.Matchers; +import org.jetbrains.annotations.NotNull; +import org.junit.Assert; +import java.util.Collection; +import java.util.Collections; import java.util.Set; /** @@ -32,7 +40,21 @@ public class IPythonConsoleTest extends PyEnvTestCase { addTextToEditor("sys?"); PsiFile psi = PsiDocumentManager.getInstance(getProject()).getPsiFile(getConsoleView().getLanguageConsole().getConsoleEditor().getDocument()); - assertFalse(PsiTreeUtil.hasErrorElements(psi)); + Assert.assertThat("No errors expected", getErrors(psi), Matchers.empty()); + } + }); + } + + @NotNull + private static Collection getErrors(PsiFile psi) { //TODO: NotNull? + if (!PsiTreeUtil.hasErrorElements(psi)) { + return Collections.emptyList(); + } + + return Collections2.transform(PsiTreeUtil.findChildrenOfType(psi, PsiErrorElement.class), new Function() { + @Override + public String apply(PsiErrorElement input) { + return input.getErrorDescription(); } }); } From 2e27e2a443e462a1b89d3a9e652ffdcd4e399979 Mon Sep 17 00:00:00 2001 From: Alexey Kudravtsev Date: Wed, 12 Feb 2014 15:41:47 +0400 Subject: [PATCH 108/183] annotated by SafeVarargs. The stub of SaveVarargs is put into util module for those old stumps clutching to their precious JDK1.6 --- python/testSrc/com/jetbrains/env/python/PyPackagingTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index 2085e1589d58..7edf6c25aa22 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -148,6 +148,7 @@ public class PyPackagingTest extends PyEnvTestCase { return null; } + @SafeVarargs private static List list(T... xs) { return Arrays.asList(xs); } From 892df5d47056679b96deb66c9c4166c24567071b Mon Sep 17 00:00:00 2001 From: Alexey Kudravtsev Date: Thu, 13 Feb 2014 13:07:19 +0400 Subject: [PATCH 109/183] reverted SafeVarargs because of Oracle license restrictions --- python/testSrc/com/jetbrains/env/python/PyPackagingTest.java | 1 - 1 file changed, 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index 7edf6c25aa22..2085e1589d58 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -148,7 +148,6 @@ public class PyPackagingTest extends PyEnvTestCase { return null; } - @SafeVarargs private static List list(T... xs) { return Arrays.asList(xs); } From 5a22be2f72c664bcfbac5b3c87af6e44a2e86fa9 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 13 Feb 2014 23:50:33 +0100 Subject: [PATCH 110/183] Fix multi-process debugger test on win. --- .../com/jetbrains/env/python/debug/PyDebuggerTask.java | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index 4c7a591117dc..95eaa0900563 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -13,6 +13,7 @@ import com.intellij.openapi.application.Result; import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Key; +import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; import com.intellij.xdebugger.*; import com.jetbrains.env.RemoteSdkTestable; @@ -91,7 +92,9 @@ public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTesta final ExecutionEnvironment env = new ExecutionEnvironment(executor, runner, settings, project); - deletePycFiles(); + if (SystemInfo.isWindows) { //fix the problem with pydevd.py that can't be imported because of caches in multi-process debug test + deletePycFiles(); + } final PythonCommandLineState pyState = (PythonCommandLineState)myRunConfiguration.getState(executor, env); @@ -177,7 +180,8 @@ public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTesta } private static void deletePycFiles() { - for (File f: PythonHelpersLocator.getHelpersRoot().listFiles(new FilenameFilter() { + File root = PythonHelpersLocator.getHelpersRoot(); + for (File f : new File(root, "pydev").listFiles(new FilenameFilter() { @Override public boolean accept(File dir, String name) { return name.endsWith(".pyc") || name.equals("__pycache__"); From 866c13548d330166ee8584aac088eb269e7939ff Mon Sep 17 00:00:00 2001 From: Vladimir Krivosheev Date: Thu, 20 Feb 2014 13:10:54 +0100 Subject: [PATCH 111/183] deprecate setTextToEditor --- .../testSrc/com/jetbrains/env/python/console/PyConsoleTask.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index d5a931a5dfce..bd093c0ce350 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -392,7 +392,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { UIUtil.invokeAndWaitIfNeeded(new Runnable() { @Override public void run() { - getConsoleView().getLanguageConsole().setTextToEditor(text); + getConsoleView().getLanguageConsole().setInputText(text); PsiDocumentManager.getInstance(getProject()).commitAllDocuments(); } } From f4a35f37d416aaea99a53c2e3b0a75559235e520 Mon Sep 17 00:00:00 2001 From: Vladimir Krivosheev Date: Thu, 20 Feb 2014 13:13:23 +0100 Subject: [PATCH 112/183] cleanup --- .../env/python/console/PyConsoleTask.java | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index bd093c0ce350..78e19bff37f8 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -73,10 +73,6 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { return myConsoleView.getConsole().getHistoryViewer().getDocument().getText(); } - private void outputContains(String substring) { - Assert.assertTrue(output().contains(substring)); - } - public void setProcessCanTerminate(boolean processCanTerminate) { myProcessCanTerminate = processCanTerminate; } @@ -84,6 +80,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { @Override public void tearDown() throws Exception { UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override public void run() { try { if (myConsoleView != null) { @@ -118,7 +115,8 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { if (myConsoleView != null) { new WriteAction() { - protected void run(Result result) throws Throwable { + @Override + protected void run(@NotNull Result result) throws Throwable { Disposer.dispose(myConsoleView); myConsoleView = null; } @@ -126,6 +124,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { } } + @Override public void runTestOn(final String sdkHome) throws Exception { final Project project = getProject(); @@ -202,7 +201,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { } } - private Sdk getSdk(final String sdkHome) { + private static Sdk getSdk(final String sdkHome) { Sdk sdk = PythonSdkType.findSdkByPath(sdkHome); return sdk != null ? sdk : new ProjectJdkImpl("Python Test Sdk " + sdkHome, PythonSdkType.getInstance()) { @@ -235,7 +234,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { /** * Waits until all passed strings appear in output. - * If they don't appear in timelimit, then exception is raised. + * If they don't appear in time limit, then exception is raised. * * @param string * @throws InterruptedException @@ -305,7 +304,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { Thread.sleep(500); } } - catch (Exception e) { + catch (Exception ignored) { } } From 6ee55b84f36ed6bb9b7a313d3f9c12842e15b212 Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Fri, 21 Feb 2014 16:17:11 +0400 Subject: [PATCH 113/183] fixed env tests according django 1.6 --- .../jetbrains/env/django/DjangoPathTest.java | 28 +++++++++++++++---- .../env/django/DjangoTestRunnerTest.java | 20 ++++++++++++- 2 files changed, 42 insertions(+), 6 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java index 558208e8f08d..b5b3175a70d6 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java @@ -3,17 +3,23 @@ package com.jetbrains.env.django; import com.google.common.collect.Lists; import com.intellij.execution.configurations.ConfigurationFactory; import com.intellij.openapi.util.io.FileUtil; +import com.intellij.openapi.util.text.StringUtil; import com.jetbrains.django.run.DjangoServerRunConfiguration; import com.jetbrains.django.run.DjangoServerRunConfigurationType; import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; import com.jetbrains.django.testRunner.DjangoTestsRunConfiguration; import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.python.packaging.PyExternalProcessException; +import com.jetbrains.python.packaging.PyPackage; +import com.jetbrains.python.packaging.PyPackageManager; +import com.jetbrains.python.packaging.PyPackageManagerImpl; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import junit.framework.Assert; import org.jetbrains.annotations.Nullable; import java.io.IOException; import java.util.ArrayList; +import java.util.List; /** * User : catherine @@ -42,7 +48,7 @@ public class DjangoPathTest extends PyEnvTestCase { public void testing() throws Exception { - waitForOutput("Development server is running"); + waitForOutput(THE_END_OF_SYS_PATH); doTest(output(), getTestDataPath()); } @@ -82,11 +88,23 @@ public class DjangoPathTest extends PyEnvTestCase { @Override protected void configure(AbstractPythonRunConfiguration config) { - ((DjangoTestsRunConfiguration)config).setTarget("mysite.SimpleTest"); + String target = "mysite.SimpleTest"; + try { + final PyPackage django = ((PyPackageManagerImpl)PyPackageManager.getInstance(config.getSdk())).findPackage("django"); + if (django != null) { + final List version = StringUtil.split(django.getVersion(), "."); + if (Integer.parseInt(version.get(1)) >= 6) + target = "mysite.tests.SimpleTest"; + } + } + catch (PyExternalProcessException ignored) { + } + + ((DjangoTestsRunConfiguration)config).setTarget(target); } public void testing() throws Exception { - waitForOutput("The end of sys.path"); + waitForOutput(THE_END_OF_SYS_PATH); doTest(output(), getTestDataPath()); } }); @@ -102,12 +120,12 @@ public class DjangoPathTest extends PyEnvTestCase { } public void testing() throws Exception { - waitForOutput("The end of sys.path"); + waitForOutput(THE_END_OF_SYS_PATH); final String[] splittedOutput = output().split("\\n"); final ArrayList outputList = Lists.newArrayList(); for (String s : splittedOutput) { - if (s.equals("The end of sys.path")) { + if (s.equals(THE_END_OF_SYS_PATH)) { break; } outputList.add(s); diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java index 56470e5d2627..2d15c591a6aa 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java @@ -4,12 +4,18 @@ import com.google.common.collect.Lists; import com.intellij.execution.configurations.ConfigurationFactory; import com.intellij.openapi.module.Module; import com.intellij.openapi.util.io.FileUtil; +import com.intellij.openapi.util.text.StringUtil; import com.intellij.util.ui.UIUtil; import com.jetbrains.django.facet.DjangoFacet; import com.jetbrains.django.facet.DjangoFacetConfiguration; import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; import com.jetbrains.django.testRunner.DjangoTestsRunConfiguration; +import com.jetbrains.django.util.DjangoUtil; import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.python.packaging.PyExternalProcessException; +import com.jetbrains.python.packaging.PyPackage; +import com.jetbrains.python.packaging.PyPackageManager; +import com.jetbrains.python.packaging.PyPackageManagerImpl; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -50,7 +56,19 @@ public class DjangoTestRunnerTest extends PyEnvTestCase { @Override protected void configure(AbstractPythonRunConfiguration config) { - ((DjangoTestsRunConfiguration)config).setTarget("myapp.SimpleTest"); + String target = "mysite.SimpleTest"; + try { + final PyPackage django = ((PyPackageManagerImpl)PyPackageManager.getInstance(config.getSdk())).findPackage("django"); + if (django != null) { + final List version = StringUtil.split(django.getVersion(), "."); + if (Integer.parseInt(version.get(1)) >= 6) + target = "mysite.tests.SimpleTest"; + } + } + catch (PyExternalProcessException ignored) { + } + + ((DjangoTestsRunConfiguration)config).setTarget(target); if (customSettings != null) ((DjangoTestsRunConfiguration)config).setSettingsFile(getTestDataPath() + customSettings); ((DjangoTestsRunConfiguration)config).useCustomSettings(true); From 60bbef5fff38708c22a1d455fe5443dd53c97a56 Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Fri, 21 Feb 2014 16:17:40 +0400 Subject: [PATCH 114/183] fixed PY-12147 Can't rerun failed tests if using Django 1.6 and django_nose --- .../testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java | 1 - 1 file changed, 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java index 2d15c591a6aa..6baa00a3645e 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java @@ -10,7 +10,6 @@ import com.jetbrains.django.facet.DjangoFacet; import com.jetbrains.django.facet.DjangoFacetConfiguration; import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; import com.jetbrains.django.testRunner.DjangoTestsRunConfiguration; -import com.jetbrains.django.util.DjangoUtil; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.python.packaging.PyExternalProcessException; import com.jetbrains.python.packaging.PyPackage; From 5159299f3b7dd247931a04a1d7462a878de053dd Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Mon, 24 Feb 2014 14:05:36 +0400 Subject: [PATCH 115/183] fixed tests --- .../com/jetbrains/env/django/DjangoTestRunnerTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java index 6baa00a3645e..bea955732add 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java @@ -55,13 +55,13 @@ public class DjangoTestRunnerTest extends PyEnvTestCase { @Override protected void configure(AbstractPythonRunConfiguration config) { - String target = "mysite.SimpleTest"; + String target = "myapp.SimpleTest"; try { final PyPackage django = ((PyPackageManagerImpl)PyPackageManager.getInstance(config.getSdk())).findPackage("django"); if (django != null) { final List version = StringUtil.split(django.getVersion(), "."); if (Integer.parseInt(version.get(1)) >= 6) - target = "mysite.tests.SimpleTest"; + target = "myapp.tests.SimpleTest"; } } catch (PyExternalProcessException ignored) { From a46d4bd0cc1123805291a85bede06cbad261f6f7 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Mon, 24 Feb 2014 18:20:14 +0100 Subject: [PATCH 116/183] RemoteSdkCredentials retrieval extracted from RemoteSdkAdditionalData. --- .../env/PyTestRemoteSdkProvider.java | 33 ++++++++++++++----- .../env/python/debug/PyEnvTestCase.java | 4 +-- 2 files changed, 26 insertions(+), 11 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java index 6cccd3d43d87..27400ba68a70 100644 --- a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java +++ b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java @@ -11,10 +11,10 @@ import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; import com.intellij.remotesdk.RemoteInterpreterException; +import com.intellij.util.Consumer; import com.intellij.util.ui.UIUtil; import com.jetbrains.env.python.debug.PyTestTask; -import com.jetbrains.python.remote.PyRemoteInterpreterManagerImpl; -import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; +import com.jetbrains.python.remote.*; import java.io.File; import java.io.IOException; @@ -51,7 +51,8 @@ public class PyTestRemoteSdkProvider { public Sdk load(String key) throws Exception { return createSdk(key); } - }); + } + ); public Sdk getSdk(Project project, String sdkPath) throws ExecutionException { myProject = project; @@ -60,7 +61,7 @@ public class PyTestRemoteSdkProvider { private Sdk createSdk(String interpreterPath) throws RemoteInterpreterException { try { - PyRemoteSdkAdditionalData data = createRemoteSdkData(interpreterPath); + PyRemoteSdkAdditionalData2 data = createRemoteSdkData(interpreterPath); final Sdk sdk = myInterpreterManager.createRemoteSdk(myProject, data, null, Lists.newArrayList()); UIUtil.invokeAndWaitIfNeeded(new Runnable() { @@ -77,16 +78,30 @@ public class PyTestRemoteSdkProvider { } } - private PyRemoteSdkAdditionalData createRemoteSdkData(String path) throws IOException { - PyRemoteSdkAdditionalData data = new PyRemoteSdkAdditionalData(path); + private static PyRemoteSdkCredentialsHolder getTestSdkCredentials(String path) { + PyRemoteSdkCredentialsHolder data = new PyRemoteSdkCredentialsHolder(); data.setHost("localhost"); data.setPort(22); data.setUserName(getUserName()); data.setPassword(getPassword()); - data.setHelpersPath(getHelpersPath(data)); + + data.setInterpreterPath(path); + try { + data.setHelpersPath(getTempHelpersPath(data)); + } + catch (IOException e) { + throw new IllegalStateException(e); + } return data; } + private static PyRemoteSdkAdditionalData2 createRemoteSdkData(final String path) throws IOException { + PyRemoteSdkAdditionalData2 res = new PyRemoteSdkAdditionalData2(path); + res.setSshCredentials(getTestSdkCredentials(path)); + return res; + + } + public static boolean canRunRemoteSdk() { return isPasswordSpecified(); } @@ -99,11 +114,11 @@ public class PyTestRemoteSdkProvider { return !StringUtil.isEmpty(System.getenv("FAIL_WHEN_CANT_RUN_REMOTE")) || PyEnvSufficiencyTest.IS_UNDER_TEAMCITY; } - private static String getHelpersPath(PyRemoteSdkAdditionalData data) throws IOException { + private static String getTempHelpersPath(PyRemoteSdkCredentials data) throws IOException { final File dir = new File("/tmp"); File tmpDir = FileUtil.createTempDirectory(dir, "pycharm_helpers_", "_" + Math.abs( - Hashing.md5().hashString(data.getFullInterpreterPath()).asInt()), true); + Hashing.md5().hashString(data.getInterpreterPath()).asInt()), true); return tmpDir.getPath(); } diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index d1d1ed38d76b..af502ced3aab 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -12,7 +12,7 @@ import com.intellij.testFramework.UsefulTestCase; import com.intellij.util.ui.UIUtil; import com.jetbrains.env.PyTestRemoteSdkProvider; import com.jetbrains.python.fixtures.PyTestCase; -import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; +import com.jetbrains.python.remote.PyRemoteSdkAdditionalData2; import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -204,7 +204,7 @@ public abstract class PyEnvTestCase extends UsefulTestCase { }); } - return ((PyRemoteSdkAdditionalData)sdk.getSdkAdditionalData()).getFullInterpreterPath(); + return ((PyRemoteSdkAdditionalData2)sdk.getSdkAdditionalData()).getRemoteSdkCredentials().getFullInterpreterPath(); } catch (Exception e) { throw new RuntimeException(e); From a507204d14efbe8e4a328714a891d6ec3e330ebf Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 25 Feb 2014 20:17:21 +0100 Subject: [PATCH 117/183] Code clean. --- python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java index 27400ba68a70..3c59200ef8b6 100644 --- a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java +++ b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java @@ -13,6 +13,7 @@ import com.intellij.openapi.util.text.StringUtil; import com.intellij.remotesdk.RemoteInterpreterException; import com.intellij.util.Consumer; import com.intellij.util.ui.UIUtil; +import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.python.debug.PyTestTask; import com.jetbrains.python.remote.*; @@ -111,7 +112,7 @@ public class PyTestRemoteSdkProvider { } public static boolean shouldFailWhenCantRunRemote() { - return !StringUtil.isEmpty(System.getenv("FAIL_WHEN_CANT_RUN_REMOTE")) || PyEnvSufficiencyTest.IS_UNDER_TEAMCITY; + return !StringUtil.isEmpty(System.getenv("FAIL_WHEN_CANT_RUN_REMOTE")) || PyEnvTestCase.IS_UNDER_TEAMCITY; } private static String getTempHelpersPath(PyRemoteSdkCredentials data) throws IOException { From 59205beef5c54bd0275f1e1a6533b9c1bcc48c6f Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Wed, 26 Feb 2014 13:54:38 +0100 Subject: [PATCH 118/183] UI to create remote interpreter based on Vagrant. --- .../testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index af502ced3aab..9ed4f3c39e08 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -204,7 +204,7 @@ public abstract class PyEnvTestCase extends UsefulTestCase { }); } - return ((PyRemoteSdkAdditionalData2)sdk.getSdkAdditionalData()).getRemoteSdkCredentials().getFullInterpreterPath(); + return ((PyRemoteSdkAdditionalData2)sdk.getSdkAdditionalData()).getRemoteSdkCredentials().getSdkId(); } catch (Exception e) { throw new RuntimeException(e); From f2ae1dd9d02c8e9c265d2b1801b147b7f118ff73 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Fri, 28 Feb 2014 12:58:20 +0100 Subject: [PATCH 119/183] remove all breakpoints before settings new ones. --- .../com/jetbrains/env/python/PythonDebuggerTest.java | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index 812a8ef51108..eb12ce2c1543 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -4,7 +4,10 @@ import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; import com.google.common.collect.Sets; import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; +import com.intellij.xdebugger.XDebuggerManager; import com.intellij.xdebugger.XDebuggerTestUtil; +import com.intellij.xdebugger.breakpoints.XBreakpoint; +import com.intellij.xdebugger.breakpoints.XBreakpointManager; import com.jetbrains.env.python.debug.PyDebuggerTask; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.ut.PyUnitTestTask; @@ -140,11 +143,8 @@ public class PythonDebuggerTest extends PyEnvTestCase { }); } }); - - } - public void testDebugCompletion() throws Exception { runPythonTest(new PyDebuggerTask("/debug", "test4.py") { @@ -334,6 +334,8 @@ public class PythonDebuggerTest extends PyEnvTestCase { boolean notifyOnTerminate, boolean notifyAlways, boolean notifyOnFirst) { + XDebuggerTestUtil.removeAllBreakpoints(fixture.getProject()); + PyExceptionBreakpointProperties properties = new PyExceptionBreakpointProperties("exceptions.ZeroDivisionError"); properties.setNotifyOnTerminate(notifyOnTerminate); properties.setNotifyAlways(notifyAlways); @@ -428,7 +430,8 @@ public class PythonDebuggerTest extends PyEnvTestCase { PythonSdkFlavor flavor = PythonSdkFlavor.getFlavor(getRunConfiguration().getSdkHome()); if (flavor != null) { flavor.initPythonPath(Lists.newArrayList(egg), getRunConfiguration().getEnvs()); - } else { + } + else { getRunConfiguration().getEnvs().put("PYTHONPATH", egg); } } From fea837f4a541f5ed283a53a304e4651ad4282ab8 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Fri, 28 Feb 2014 16:50:34 +0100 Subject: [PATCH 120/183] Don't delete pyc and do write python byte code in debugger tests. --- .../env/python/debug/PyDebuggerTask.java | 19 ------------------- 1 file changed, 19 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index 95eaa0900563..44e27a524491 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -74,7 +74,6 @@ public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTesta myRunConfiguration.setScriptName(getScriptPath()); myRunConfiguration.setWorkingDirectory(getWorkingFolder()); myRunConfiguration.setScriptParameters(getScriptParameters()); - myRunConfiguration.getEnvs().put("PYTHONDONTWRITEBYTECODE", "1"); //Don't write 'pyc' files as they can't be loaded by other versions new WriteAction() { @Override @@ -91,12 +90,6 @@ public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTesta final Executor executor = DefaultDebugExecutor.getDebugExecutorInstance(); final ExecutionEnvironment env = new ExecutionEnvironment(executor, runner, settings, project); - - if (SystemInfo.isWindows) { //fix the problem with pydevd.py that can't be imported because of caches in multi-process debug test - deletePycFiles(); - } - - final PythonCommandLineState pyState = (PythonCommandLineState)myRunConfiguration.getState(executor, env); assert pyState != null; @@ -179,18 +172,6 @@ public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTesta doTest(myOutputPrinter); } - private static void deletePycFiles() { - File root = PythonHelpersLocator.getHelpersRoot(); - for (File f : new File(root, "pydev").listFiles(new FilenameFilter() { - @Override - public boolean accept(File dir, String name) { - return name.endsWith(".pyc") || name.equals("__pycache__"); - } - })) { - FileUtil.delete(f); - } - } - public PythonRunConfiguration getRunConfiguration() { return myRunConfiguration; } From 2e0e37910f610c15bc0b9223a4c08349ec9be914 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 4 Mar 2014 13:46:05 +0100 Subject: [PATCH 121/183] Deprecated remote sdk api. Old legacy classes leaved for compatibility. --- .../com/jetbrains/env/PyTestRemoteSdkProvider.java | 11 +++++------ .../com/jetbrains/env/python/debug/PyEnvTestCase.java | 4 ++-- 2 files changed, 7 insertions(+), 8 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java index 3c59200ef8b6..418d52c4c513 100644 --- a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java +++ b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java @@ -10,8 +10,7 @@ import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; -import com.intellij.remotesdk.RemoteInterpreterException; -import com.intellij.util.Consumer; +import com.intellij.remote.RemoteSdkException; import com.intellij.util.ui.UIUtil; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.python.debug.PyTestTask; @@ -60,9 +59,9 @@ public class PyTestRemoteSdkProvider { return mySdkTable.get(sdkPath); } - private Sdk createSdk(String interpreterPath) throws RemoteInterpreterException { + private Sdk createSdk(String interpreterPath) throws RemoteSdkException { try { - PyRemoteSdkAdditionalData2 data = createRemoteSdkData(interpreterPath); + PyRemoteSdkAdditionalData data = createRemoteSdkData(interpreterPath); final Sdk sdk = myInterpreterManager.createRemoteSdk(myProject, data, null, Lists.newArrayList()); UIUtil.invokeAndWaitIfNeeded(new Runnable() { @@ -96,8 +95,8 @@ public class PyTestRemoteSdkProvider { return data; } - private static PyRemoteSdkAdditionalData2 createRemoteSdkData(final String path) throws IOException { - PyRemoteSdkAdditionalData2 res = new PyRemoteSdkAdditionalData2(path); + private static PyRemoteSdkAdditionalData createRemoteSdkData(final String path) throws IOException { + PyRemoteSdkAdditionalData res = new PyRemoteSdkAdditionalData(path); res.setSshCredentials(getTestSdkCredentials(path)); return res; diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index 9ed4f3c39e08..f570e150b8be 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -12,7 +12,7 @@ import com.intellij.testFramework.UsefulTestCase; import com.intellij.util.ui.UIUtil; import com.jetbrains.env.PyTestRemoteSdkProvider; import com.jetbrains.python.fixtures.PyTestCase; -import com.jetbrains.python.remote.PyRemoteSdkAdditionalData2; +import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -204,7 +204,7 @@ public abstract class PyEnvTestCase extends UsefulTestCase { }); } - return ((PyRemoteSdkAdditionalData2)sdk.getSdkAdditionalData()).getRemoteSdkCredentials().getSdkId(); + return ((PyRemoteSdkAdditionalData)sdk.getSdkAdditionalData()).getRemoteSdkCredentials().getSdkId(); } catch (Exception e) { throw new RuntimeException(e); From 272dc78556f8f2a022262d258921a667bf07e2a1 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 4 Mar 2014 15:44:38 +0100 Subject: [PATCH 122/183] Fix creation of remote sdk in tests. --- .../env/PyTestRemoteSdkProvider.java | 25 ++++++++++--------- 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java index 418d52c4c513..2b16fe2d85f4 100644 --- a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java +++ b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java @@ -10,11 +10,14 @@ import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; +import com.intellij.remote.RemoteCredentialsHolder; +import com.intellij.remote.RemoteSdkCredentials; import com.intellij.remote.RemoteSdkException; import com.intellij.util.ui.UIUtil; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.python.debug.PyTestTask; import com.jetbrains.python.remote.*; +import org.jetbrains.annotations.NotNull; import java.io.File; import java.io.IOException; @@ -78,16 +81,21 @@ public class PyTestRemoteSdkProvider { } } - private static PyRemoteSdkCredentialsHolder getTestSdkCredentials(String path) { - PyRemoteSdkCredentialsHolder data = new PyRemoteSdkCredentialsHolder(); + private static RemoteCredentialsHolder getTestSdkCredentials(String path) { + RemoteCredentialsHolder data = new RemoteCredentialsHolder(); data.setHost("localhost"); data.setPort(22); data.setUserName(getUserName()); data.setPassword(getPassword()); + return data; + } + private static PyRemoteSdkAdditionalData createRemoteSdkData(final String path) throws IOException { + PyRemoteSdkAdditionalData data = new PyRemoteSdkAdditionalData(path); + data.setSshCredentials(getTestSdkCredentials(path)); data.setInterpreterPath(path); try { - data.setHelpersPath(getTempHelpersPath(data)); + data.setHelpersPath(getTempHelpersPath(path)); } catch (IOException e) { throw new IllegalStateException(e); @@ -95,13 +103,6 @@ public class PyTestRemoteSdkProvider { return data; } - private static PyRemoteSdkAdditionalData createRemoteSdkData(final String path) throws IOException { - PyRemoteSdkAdditionalData res = new PyRemoteSdkAdditionalData(path); - res.setSshCredentials(getTestSdkCredentials(path)); - return res; - - } - public static boolean canRunRemoteSdk() { return isPasswordSpecified(); } @@ -114,11 +115,11 @@ public class PyTestRemoteSdkProvider { return !StringUtil.isEmpty(System.getenv("FAIL_WHEN_CANT_RUN_REMOTE")) || PyEnvTestCase.IS_UNDER_TEAMCITY; } - private static String getTempHelpersPath(PyRemoteSdkCredentials data) throws IOException { + private static String getTempHelpersPath(@NotNull String interpreterPath) throws IOException { final File dir = new File("/tmp"); File tmpDir = FileUtil.createTempDirectory(dir, "pycharm_helpers_", "_" + Math.abs( - Hashing.md5().hashString(data.getInterpreterPath()).asInt()), true); + Hashing.md5().hashString(interpreterPath).asInt()), true); return tmpDir.getPath(); } From 16a9583973693cb6490948fba670797648cbbecf Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 4 Mar 2014 16:00:11 +0100 Subject: [PATCH 123/183] Breakpoint remove should be executed in write action like breakpoint add in XDebuggerTestUtil. --- .../com/jetbrains/env/python/debug/PyBaseDebuggerTask.java | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java index ab0456a6286a..128f323d340c 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java @@ -120,11 +120,7 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { UIUtil.invokeAndWaitIfNeeded(new Runnable() { @Override public void run() { - new WriteAction() { - protected void run(final Result result) { - XDebuggerTestUtil.removeAllBreakpoints(getProject()); - } - }; + XDebuggerTestUtil.removeAllBreakpoints(getProject()); } }); } From df51987137d5c4ba1c45644dd569e1e96369f80a Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 4 Mar 2014 17:24:57 +0100 Subject: [PATCH 124/183] Disable default breakpoints in env debugger tests. --- python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index eb12ce2c1543..b49103c5d5e6 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -335,6 +335,7 @@ public class PythonDebuggerTest extends PyEnvTestCase { boolean notifyAlways, boolean notifyOnFirst) { XDebuggerTestUtil.removeAllBreakpoints(fixture.getProject()); + XDebuggerTestUtil.setDefaultBreakpointEnabled(fixture.getProject(), PyExceptionBreakpointType.class, false); PyExceptionBreakpointProperties properties = new PyExceptionBreakpointProperties("exceptions.ZeroDivisionError"); properties.setNotifyOnTerminate(notifyOnTerminate); From 9f78f8fc6e0e2c6ad0daa9793ed46612990c0e83 Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Tue, 11 Mar 2014 17:15:50 +0400 Subject: [PATCH 125/183] Package method for checking version addded --- python/testSrc/com/jetbrains/env/django/DjangoPathTest.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java index b5b3175a70d6..61a5e3538b99 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java @@ -92,8 +92,7 @@ public class DjangoPathTest extends PyEnvTestCase { try { final PyPackage django = ((PyPackageManagerImpl)PyPackageManager.getInstance(config.getSdk())).findPackage("django"); if (django != null) { - final List version = StringUtil.split(django.getVersion(), "."); - if (Integer.parseInt(version.get(1)) >= 6) + if (django.isVersionAtLeast(1,6)) target = "mysite.tests.SimpleTest"; } } From 701bb988c88bbc63f8cb607d4fecf76858ef140a Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Tue, 11 Mar 2014 18:49:20 +0400 Subject: [PATCH 126/183] Package method for checking version added --- .../com/jetbrains/env/django/DjangoPathTest.java | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java index 61a5e3538b99..dd8825206c6b 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java @@ -3,23 +3,18 @@ package com.jetbrains.env.django; import com.google.common.collect.Lists; import com.intellij.execution.configurations.ConfigurationFactory; import com.intellij.openapi.util.io.FileUtil; -import com.intellij.openapi.util.text.StringUtil; import com.jetbrains.django.run.DjangoServerRunConfiguration; import com.jetbrains.django.run.DjangoServerRunConfigurationType; import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; import com.jetbrains.django.testRunner.DjangoTestsRunConfiguration; import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.python.packaging.PyExternalProcessException; -import com.jetbrains.python.packaging.PyPackage; -import com.jetbrains.python.packaging.PyPackageManager; -import com.jetbrains.python.packaging.PyPackageManagerImpl; +import com.jetbrains.python.packaging.*; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import junit.framework.Assert; import org.jetbrains.annotations.Nullable; import java.io.IOException; import java.util.ArrayList; -import java.util.List; /** * User : catherine @@ -92,8 +87,9 @@ public class DjangoPathTest extends PyEnvTestCase { try { final PyPackage django = ((PyPackageManagerImpl)PyPackageManager.getInstance(config.getSdk())).findPackage("django"); if (django != null) { - if (django.isVersionAtLeast(1,6)) + if (django.matches(PyRequirement.fromStringGuaranteed("django>=1.6a"))) { target = "mysite.tests.SimpleTest"; + } } } catch (PyExternalProcessException ignored) { From 35f7816c3871c7c8e061b67d76c689b99c84c426 Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Tue, 11 Mar 2014 19:04:47 +0400 Subject: [PATCH 127/183] Package method for checking version added --- .../com/jetbrains/env/django/DjangoTestRunnerTest.java | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java index bea955732add..c9d4af479c11 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java @@ -11,10 +11,7 @@ import com.jetbrains.django.facet.DjangoFacetConfiguration; import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; import com.jetbrains.django.testRunner.DjangoTestsRunConfiguration; import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.python.packaging.PyExternalProcessException; -import com.jetbrains.python.packaging.PyPackage; -import com.jetbrains.python.packaging.PyPackageManager; -import com.jetbrains.python.packaging.PyPackageManagerImpl; +import com.jetbrains.python.packaging.*; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -59,9 +56,9 @@ public class DjangoTestRunnerTest extends PyEnvTestCase { try { final PyPackage django = ((PyPackageManagerImpl)PyPackageManager.getInstance(config.getSdk())).findPackage("django"); if (django != null) { - final List version = StringUtil.split(django.getVersion(), "."); - if (Integer.parseInt(version.get(1)) >= 6) + if (django.matches(PyRequirement.fromStringGuaranteed("django>=1.6a"))) { target = "myapp.tests.SimpleTest"; + } } } catch (PyExternalProcessException ignored) { From de3bf78e601a3876668159e81cc8fd9b8eb27637 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 11 Mar 2014 18:27:55 +0100 Subject: [PATCH 128/183] Remove unused parameter. --- .../testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java index 2b16fe2d85f4..7ec1dd30bcbb 100644 --- a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java +++ b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java @@ -11,7 +11,6 @@ import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; import com.intellij.remote.RemoteCredentialsHolder; -import com.intellij.remote.RemoteSdkCredentials; import com.intellij.remote.RemoteSdkException; import com.intellij.util.ui.UIUtil; import com.jetbrains.env.python.debug.PyEnvTestCase; @@ -81,7 +80,7 @@ public class PyTestRemoteSdkProvider { } } - private static RemoteCredentialsHolder getTestSdkCredentials(String path) { + private static RemoteCredentialsHolder getTestSdkCredentials() { RemoteCredentialsHolder data = new RemoteCredentialsHolder(); data.setHost("localhost"); data.setPort(22); @@ -92,7 +91,7 @@ public class PyTestRemoteSdkProvider { private static PyRemoteSdkAdditionalData createRemoteSdkData(final String path) throws IOException { PyRemoteSdkAdditionalData data = new PyRemoteSdkAdditionalData(path); - data.setSshCredentials(getTestSdkCredentials(path)); + data.setSshCredentials(getTestSdkCredentials()); data.setInterpreterPath(path); try { data.setHelpersPath(getTempHelpersPath(path)); From f14a2e80a4cd2963ff1bf3ce366aa1236f53a154 Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Wed, 12 Mar 2014 00:35:05 +0400 Subject: [PATCH 129/183] PY-12118 Pycharm "Run manage.py Task" does not recognize the new django 1.7 "migrate", "squashmigrations", "makemigrations" command's (tests added) --- .../django/DjangoManageTaskActionsTest.java | 114 ++++++++++++++++++ 1 file changed, 114 insertions(+) create mode 100644 python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java new file mode 100644 index 000000000000..502029609a63 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java @@ -0,0 +1,114 @@ +package com.jetbrains.env.django; + +import com.intellij.execution.configurations.ConfigurationFactory; +import com.intellij.openapi.module.Module; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.projectRoots.SdkModificator; +import com.intellij.openapi.roots.ModuleRootModificationUtil; +import com.intellij.openapi.roots.OrderRootType; +import com.intellij.openapi.vfs.LocalFileSystem; +import com.intellij.openapi.vfs.VirtualFile; +import com.jetbrains.django.actions.manage.ManageTaskActions; +import com.jetbrains.django.manage.BaseCommand; +import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; +import com.jetbrains.django.util.DjangoUtil; +import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.python.packaging.PyExternalProcessException; +import com.jetbrains.python.packaging.PyPackage; +import com.jetbrains.python.packaging.PyPackageManager; +import com.jetbrains.python.packaging.PyPackageManagerImpl; +import com.jetbrains.python.run.AbstractPythonRunConfiguration; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.junit.Assert; + +import java.io.IOException; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +/** + * @author Ilya.Kazakevich + */ +public class DjangoManageTaskActionsTest extends PyEnvTestCase { + + /** + * Checks that "manage.py" UI displays correct commands + */ + public void testManageCommands() throws Exception { + runPythonTest(new DjangoManageCommandsTestTask()); + } + + /** + * Fills SDK roots with installed packages + * + * @param sdk package to fill + * @throws PyExternalProcessException if system was not able to run external tools to list installed packages + */ + private static void fillSdkWithInstalledPackages(@NotNull final Sdk sdk) throws PyExternalProcessException { + final List packages = ((PyPackageManagerImpl)PyPackageManager.getInstance(sdk)).getPackages(); + final Set packagePaths = new HashSet(); + for (final PyPackage aPackage : packages) { + final String location = aPackage.getLocation(); + if (location != null) { + packagePaths.add(location); + } + } + + final SdkModificator modificator = sdk.getSdkModificator(); + final LocalFileSystem fileSystem = LocalFileSystem.getInstance(); + for (final String path : packagePaths) { + final VirtualFile virtualFile = fileSystem.findFileByPath(path); + if (virtualFile == null) { + throw new IllegalStateException("Failed to read file " + path); + } + modificator.addRoot(virtualFile, OrderRootType.CLASSES); + } + + + modificator.commitChanges(); + } + + private static class DjangoManageCommandsTestTask extends DjangoPathTestTask { + @Nullable + @Override + public ConfigurationFactory getFactory() { + return DjangoTestsConfigurationType.getInstance().getConfigurationFactories()[0]; + } + + @Override + protected void configure(final AbstractPythonRunConfiguration config) throws IOException { + // Fill SDK with installed packages + super.configure(config); + final Module module = config.getModule(); + assert module != null : "Config has no module"; + try { + fillSdkWithInstalledPackages(config.getSdk()); + } + catch (final PyExternalProcessException e) { + throw new IllegalStateException("Failed to get list of packages", e); + } + ModuleRootModificationUtil.setModuleSdk(module, config.getSdk()); + + + Assert.assertNotNull("Django not found", DjangoUtil.getDjangoPath(config.getSdk())); + + final Collection expectedCommands = new HashSet(); + expectedCommands.add("runserver"); + expectedCommands.add("dbshell"); + expectedCommands.add("syncdb"); + if (DjangoUtil.isDjangoVersionAtLeast(myFixture.getModule(), 7)) { + expectedCommands.add("makemigrations"); + expectedCommands.add("migrate"); + } + + final List commands = ManageTaskActions.getInstance().getCommands(myFixture.getModule()); + + for (final BaseCommand command : commands) { + expectedCommands.remove(command.getCommand()); + } + Assert.assertTrue(String.format("Commands '%s' were not found between %s", expectedCommands, commands), expectedCommands.isEmpty()); + } + } +} From feebd303f7f77072e01d3c1856cb705b17f54093 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Wed, 12 Mar 2014 00:23:54 +0100 Subject: [PATCH 130/183] Fix possible NPE during output check. --- .../jetbrains/env/python/debug/PyBaseDebuggerTask.java | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java index 128f323d340c..2c3cb6333f60 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java @@ -97,10 +97,15 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { @NotNull protected String output() { - return XDebuggerTestUtil.getConsoleText(((PythonDebugLanguageConsoleView)mySession.getConsoleView()).getTextConsole()); + if (mySession != null && mySession.getConsoleView() != null) { + PythonDebugLanguageConsoleView pydevConsoleView = (PythonDebugLanguageConsoleView)mySession.getConsoleView(); + if (pydevConsoleView != null) { + return XDebuggerTestUtil.getConsoleText(pydevConsoleView.getTextConsole()); + } + } + return "Console output not available."; } - @NotNull protected void input(String text) { PrintWriter pw = new PrintWriter(myDebugProcess.getProcessHandler().getProcessInput()); pw.println(text); From 9f536b42081f302fa74b3dc92ed20d08651a2944 Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Wed, 12 Mar 2014 19:19:05 +0400 Subject: [PATCH 131/183] moved doctest tests to env tests --- .../env/python/PythonDocTestingTest.java | 38 +++++++++++++++++-- 1 file changed, 35 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonDocTestingTest.java b/python/testSrc/com/jetbrains/env/python/PythonDocTestingTest.java index 63b53216e0f5..a0730db9e4ac 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDocTestingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDocTestingTest.java @@ -2,7 +2,6 @@ package com.jetbrains.env.python; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.ut.PyDocTestTask; -import junit.framework.Assert; /** * User : catherine @@ -13,13 +12,46 @@ public class PythonDocTestingTest extends PyEnvTestCase{ @Override public void after() { - Assert.assertEquals(3, allTestsCount()); - Assert.assertEquals(3, passedTestsCount()); + assertEquals(3, allTestsCount()); + assertEquals(3, passedTestsCount()); allTestsPassed(); } }); } + public void testClass() { + runPythonTest(new PyDocTestTask("/testRunner/env/doc", "test1.py::FirstGoodTest") { + + @Override + public void after() { + assertEquals(1, allTestsCount()); + assertEquals(1, passedTestsCount()); + } + }); + } + + public void testMethod() { + runPythonTest(new PyDocTestTask("/testRunner/env/doc", "test1.py::SecondGoodTest::test_passes") { + + @Override + public void after() { + assertEquals(1, allTestsCount()); + assertEquals(1, passedTestsCount()); + } + }); + } + + public void testFunction() { + runPythonTest(new PyDocTestTask("/testRunner/env/doc", "test1.py::factorial") { + + @Override + public void after() { + assertEquals(1, allTestsCount()); + assertEquals(1, passedTestsCount()); + } + }); + } + public void testUTRunner2() { runPythonTest(new PyDocTestTask("/testRunner/env/doc", "test2.py") { From 2cf27e297db0afd60f33728c0bacfc25e9632d6d Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Wed, 12 Mar 2014 19:20:55 +0400 Subject: [PATCH 132/183] group env tests related to test runner --- .../env/python/{ => testing}/PythonDocTestingTest.java | 2 +- .../env/{ => python/testing}/PythonNoseTestingTest.java | 2 +- .../jetbrains/env/{ => python/testing}/PythonPyTestingTest.java | 2 +- .../env/{ => python/testing}/PythonUnitTestingTest.java | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) rename python/testSrc/com/jetbrains/env/python/{ => testing}/PythonDocTestingTest.java (97%) rename python/testSrc/com/jetbrains/env/{ => python/testing}/PythonNoseTestingTest.java (94%) rename python/testSrc/com/jetbrains/env/{ => python/testing}/PythonPyTestingTest.java (94%) rename python/testSrc/com/jetbrains/env/{ => python/testing}/PythonUnitTestingTest.java (95%) diff --git a/python/testSrc/com/jetbrains/env/python/PythonDocTestingTest.java b/python/testSrc/com/jetbrains/env/python/testing/PythonDocTestingTest.java similarity index 97% rename from python/testSrc/com/jetbrains/env/python/PythonDocTestingTest.java rename to python/testSrc/com/jetbrains/env/python/testing/PythonDocTestingTest.java index a0730db9e4ac..a710d5a22d1a 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDocTestingTest.java +++ b/python/testSrc/com/jetbrains/env/python/testing/PythonDocTestingTest.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.python; +package com.jetbrains.env.python.testing; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.ut.PyDocTestTask; diff --git a/python/testSrc/com/jetbrains/env/PythonNoseTestingTest.java b/python/testSrc/com/jetbrains/env/python/testing/PythonNoseTestingTest.java similarity index 94% rename from python/testSrc/com/jetbrains/env/PythonNoseTestingTest.java rename to python/testSrc/com/jetbrains/env/python/testing/PythonNoseTestingTest.java index 7c90f7d7b11c..6f5c7567a7cf 100644 --- a/python/testSrc/com/jetbrains/env/PythonNoseTestingTest.java +++ b/python/testSrc/com/jetbrains/env/python/testing/PythonNoseTestingTest.java @@ -1,4 +1,4 @@ -package com.jetbrains.env; +package com.jetbrains.env.python.testing; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.ut.PyNoseTestTask; diff --git a/python/testSrc/com/jetbrains/env/PythonPyTestingTest.java b/python/testSrc/com/jetbrains/env/python/testing/PythonPyTestingTest.java similarity index 94% rename from python/testSrc/com/jetbrains/env/PythonPyTestingTest.java rename to python/testSrc/com/jetbrains/env/python/testing/PythonPyTestingTest.java index 8fe94eb680e0..c503c02ba99f 100644 --- a/python/testSrc/com/jetbrains/env/PythonPyTestingTest.java +++ b/python/testSrc/com/jetbrains/env/python/testing/PythonPyTestingTest.java @@ -1,4 +1,4 @@ -package com.jetbrains.env; +package com.jetbrains.env.python.testing; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.ut.PyTestTestTask; diff --git a/python/testSrc/com/jetbrains/env/PythonUnitTestingTest.java b/python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java similarity index 95% rename from python/testSrc/com/jetbrains/env/PythonUnitTestingTest.java rename to python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java index 528b3a848570..1298b500cd27 100644 --- a/python/testSrc/com/jetbrains/env/PythonUnitTestingTest.java +++ b/python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java @@ -1,4 +1,4 @@ -package com.jetbrains.env; +package com.jetbrains.env.python.testing; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.ut.PyUnitTestTask; From 7935816a66f29450cf87431b997c044f33d4b2e2 Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Wed, 12 Mar 2014 19:31:58 +0400 Subject: [PATCH 133/183] moved unittest tests to env tests --- .../python/testing/PythonUnitTestingTest.java | 48 ++++++++++++++++++- 1 file changed, 46 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java b/python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java index 1298b500cd27..0fba30fea9be 100644 --- a/python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java +++ b/python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java @@ -9,7 +9,7 @@ import junit.framework.Assert; */ public class PythonUnitTestingTest extends PyEnvTestCase{ public void testUTRunner() { - runPythonTest(new PyUnitTestTask("/testRunner/env", "test1.py") { + runPythonTest(new PyUnitTestTask("/testRunner/env/unit", "test1.py") { @Override public void after() { @@ -21,7 +21,7 @@ public class PythonUnitTestingTest extends PyEnvTestCase{ } public void testUTRunner2() { - runPythonTest(new PyUnitTestTask("/testRunner/env", "test2.py") { + runPythonTest(new PyUnitTestTask("/testRunner/env/unit", "test2.py") { @Override public void after() { @@ -31,4 +31,48 @@ public class PythonUnitTestingTest extends PyEnvTestCase{ } }); } + + public void testClass() { + runPythonTest(new PyUnitTestTask("/testRunner/env/unit", "test_file.py::GoodTest") { + + @Override + public void after() { + assertEquals(1, allTestsCount()); + assertEquals(1, passedTestsCount()); + } + }); + } + + public void testMethod() { + runPythonTest(new PyUnitTestTask("/testRunner/env/unit", "test_file.py::GoodTest::test_passes") { + + @Override + public void after() { + assertEquals(1, allTestsCount()); + assertEquals(1, passedTestsCount()); + } + }); + } + + public void testFolder() { + runPythonTest(new PyUnitTestTask("/testRunner/env/unit", "") { + + @Override + public void after() { + assertEquals(9, allTestsCount()); + assertEquals(6, passedTestsCount()); + } + }); + } + + public void testDependent() { + runPythonTest(new PyUnitTestTask("/testRunner/env/unit", "dependentTests/test_my_class.py") { + + @Override + public void after() { + assertEquals(1, allTestsCount()); + assertEquals(1, passedTestsCount()); + } + }); + } } From 889b15890971ca74322447fc8b1eefacc96189da Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Wed, 12 Mar 2014 20:13:58 +0400 Subject: [PATCH 134/183] PY-11948 Run manage.py Task ignores environment variables defined for Django Console (and Python Console) --- .../testSrc/com/jetbrains/env/django/DjangoManageTestTask.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java index c59b13b99c5f..f20d0cf56952 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java @@ -158,7 +158,7 @@ public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { task.setParameters(parametersString.build()); - myProcessHandler = task.createProcess(); + myProcessHandler = task.createProcess(null); myProcessHandler.addProcessListener(createProcessListener()); From 95129f880785df7204dba5e4a482c544db06af27 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Wed, 12 Mar 2014 21:48:08 +0100 Subject: [PATCH 135/183] Terminate semaphore should be initialized before it is used. --- .../com/jetbrains/env/python/debug/PyDebuggerTask.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index 44e27a524491..7f2e6366bab2 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -112,6 +112,8 @@ public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTesta setProcessCanTerminate(false); + myTerminateSemaphore = new Semaphore(0); + ExecutionResult result = new WriteAction() { @Override protected void run(Result result) throws Throwable { @@ -158,7 +160,7 @@ public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTesta myPausedSemaphore = new Semaphore(0); - myTerminateSemaphore = new Semaphore(0); + mySession.addSessionListener(new XDebugSessionAdapter() { @Override From e63caae3e03f7cd1b97d19dd7640f7566f66eca8 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Wed, 12 Mar 2014 21:52:34 +0100 Subject: [PATCH 136/183] Cleanup. --- .../com/jetbrains/env/python/debug/PyDebuggerTask.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index 7f2e6366bab2..a5cd9fe15a7a 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -114,9 +114,9 @@ public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTesta myTerminateSemaphore = new Semaphore(0); - ExecutionResult result = new WriteAction() { + new WriteAction() { @Override - protected void run(Result result) throws Throwable { + protected void run(@NotNull Result result) throws Throwable { final ExecutionResult res = pyState.execute(executor, PyDebugRunner.createCommandLinePatchers(myFixture.getProject(), pyState, profile, serverLocalPort)); From a05cefab54b722fdab9bd407bd94261dfd8bacc9 Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Thu, 13 Mar 2014 13:11:59 +0400 Subject: [PATCH 137/183] fixed tests --- .../jetbrains/env/python/testing/PythonUnitTestingTest.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java b/python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java index 0fba30fea9be..5ab502643398 100644 --- a/python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java +++ b/python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java @@ -55,12 +55,12 @@ public class PythonUnitTestingTest extends PyEnvTestCase{ } public void testFolder() { - runPythonTest(new PyUnitTestTask("/testRunner/env/unit", "") { + runPythonTest(new PyUnitTestTask("/testRunner/env/unit", "test_folder/") { @Override public void after() { - assertEquals(9, allTestsCount()); - assertEquals(6, passedTestsCount()); + assertEquals(5, allTestsCount()); + assertEquals(3, passedTestsCount()); } }); } From e2854adbf33a55294669b36e9a036195af6190c4 Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Tue, 25 Mar 2014 00:26:39 +0400 Subject: [PATCH 138/183] PY-12332 "Generate stubs for binary module" in IronPython with non-Camelcase names not available or presented (TODO: Add env tests) --- .../testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index bdcc15d9029d..41fdf71d06fe 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -207,7 +207,7 @@ public class PythonSkeletonsTest extends PyEnvTestCase { }); final SkeletonVersionChecker checker = new SkeletonVersionChecker(0); - final PySkeletonRefresher refresher = new PySkeletonRefresher(project, null, sdk, skeletonsPath, null); + final PySkeletonRefresher refresher = new PySkeletonRefresher(project, null, sdk, skeletonsPath, null, null); final List errors = refresher.regenerateSkeletons(checker, null); assertEmpty(errors); } From b4f66dfeaa7e9022ec9df53506d27ca45a56865f Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Tue, 25 Mar 2014 20:45:21 +0400 Subject: [PATCH 139/183] PY-12332 "Generate stubs for binary module" in IronPython with non-Camelcase names not available or presented (Env test added) --- .../env/python/console/PyConsoleTask.java | 18 ---- .../debug/PyExecutionFixtureTestTask.java | 25 +++++ .../env/python/dotNet/PyIronPythonTest.java | 17 ++++ .../env/python/dotNet/SkeletonTestTask.java | 97 +++++++++++++++++++ .../env/python/dotNet/package-info.java | 5 + 5 files changed, 144 insertions(+), 18 deletions(-) create mode 100644 python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java create mode 100644 python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java create mode 100644 python/testSrc/com/jetbrains/env/python/dotNet/package-info.java diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 78e19bff37f8..f76f85b78ba7 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -8,7 +8,6 @@ import com.intellij.openapi.application.Result; import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; -import com.intellij.openapi.projectRoots.impl.ProjectJdkImpl; import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiDocumentManager; @@ -19,7 +18,6 @@ import com.jetbrains.python.console.*; import com.jetbrains.python.console.pydev.ConsoleCommunicationListener; import com.jetbrains.python.debugger.PyDebugValue; import com.jetbrains.python.debugger.PyDebuggerException; -import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.NotNull; import org.junit.Assert; @@ -201,22 +199,6 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { } } - private static Sdk getSdk(final String sdkHome) { - Sdk sdk = PythonSdkType.findSdkByPath(sdkHome); - - return sdk != null ? sdk : new ProjectJdkImpl("Python Test Sdk " + sdkHome, PythonSdkType.getInstance()) { - @Override - public String getHomePath() { - return sdkHome; - } - - @Override - public String getVersionString() { - return "Python 2 Mock SDK"; - } - }; - } - private void disposeConsoleProcess() throws InterruptedException { myProcessHandler.destroyProcess(); diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java index d31894eff557..fc61e5a32b3c 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java @@ -6,6 +6,8 @@ import com.intellij.ide.util.projectWizard.EmptyModuleBuilder; import com.intellij.openapi.module.ModuleType; import com.intellij.openapi.module.ModuleTypeManager; import com.intellij.openapi.project.Project; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.projectRoots.impl.ProjectJdkImpl; import com.intellij.testFramework.LightProjectDescriptor; import com.intellij.testFramework.builders.ModuleFixtureBuilder; import com.intellij.testFramework.fixtures.*; @@ -14,6 +16,7 @@ import com.intellij.testFramework.fixtures.impl.ModuleFixtureImpl; import com.intellij.util.ui.UIUtil; import com.jetbrains.python.PythonModuleTypeBase; import com.jetbrains.python.fixtures.PyProfessionalTestCase; +import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -30,6 +33,28 @@ public abstract class PyExecutionFixtureTestTask extends PyTestTask { private int myTimeout = NORMAL_TIMEOUT; protected CodeInsightTestFixture myFixture; + /** + * Creates sdk by SDK path + * @param sdkHome python sdk path + * @return sdk + */ + @NotNull + protected static Sdk getSdk(final String sdkHome) { + Sdk sdk = PythonSdkType.findSdkByPath(sdkHome); + + return sdk != null ? sdk : new ProjectJdkImpl("Python Test Sdk " + sdkHome, PythonSdkType.getInstance()) { + @Override + public String getHomePath() { + return sdkHome; + } + + @Override + public String getVersionString() { + return "Python 2 Mock SDK"; + } + }; + } + public Project getProject() { return myFixture.getProject(); } diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java new file mode 100644 index 000000000000..349ebcc9665c --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java @@ -0,0 +1,17 @@ +package com.jetbrains.env.python.dotNet; + +import com.jetbrains.env.python.debug.PyEnvTestCase; + +/** + * IronPython.NET specific tests + * @author Ilya.Kazakevich + */ +public class PyIronPythonTest extends PyEnvTestCase { + + /** + * Tests skeleton generation + */ + public void testSkeletons() throws Exception { + runPythonTest(new SkeletonTestTask()); + } +} diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java new file mode 100644 index 000000000000..7b8bafd9c548 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java @@ -0,0 +1,97 @@ +package com.jetbrains.env.python.dotNet; + +import com.google.common.collect.Sets; +import com.intellij.openapi.application.PathManager; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.roots.ModuleRootModificationUtil; +import com.intellij.openapi.util.io.FileUtil; +import com.intellij.psi.PsiDocumentManager; +import com.intellij.util.ui.UIUtil; +import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; +import com.jetbrains.python.inspections.PyUnresolvedReferencesInspection; +import com.jetbrains.python.sdk.PythonSdkType; +import org.jetbrains.annotations.NotNull; +import org.junit.Assert; + +import java.io.File; +import java.io.IOException; +import java.util.Collections; +import java.util.Set; + +/** + * Task for test that checks skeleton generation + * + * @author Ilya.Kazakevich + */ +class SkeletonTestTask extends PyExecutionFixtureTestTask { + + /** + * Tag + */ + private static final Set IRON_TAGS = Sets.newHashSet("iron"); + /** + * Number of seconds we wait for skeleton generation external process (should be enouigh) + */ + private static final int SECONDS_TO_WAIT_FOR_SKELETON_GENERATION = 5; + /** + * We check that generated skeleton is exactly as this file + */ + private static final String DOT_NET_EXPECTED_SKELETON_PY = "dotNet/expected.skeleton.py"; + + /** + * @param sdkHome + * @throws com.intellij.util.IncorrectOperationException + */ + @Override + public void runTestOn(@NotNull final String sdkHome) throws IOException { + final Sdk sdk = getSdk(sdkHome); + ModuleRootModificationUtil.setModuleSdk(myFixture.getModule(), sdk); + final File skeletonsPath = new File(PythonSdkType.getSkeletonsPath(PathManager.getSystemPath(), sdkHome)); + final File skeleton = new File(skeletonsPath, "com/just/like/java.py"); // File with module skeleton + + myFixture.copyFileToProject("dotNet/testSkeleton.py", "testSkeleton.py"); // File that uses CLR library + myFixture.copyFileToProject("dotNet/PythonLibs.dll", "PythonLibs.dll"); // Library itself + myFixture.configureByFile("testSkeleton.py"); + myFixture.enableInspections(PyUnresolvedReferencesInspection.class); // This inspection should suggest us to generate stubs + + + + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + PsiDocumentManager.getInstance(myFixture.getProject()).commitAllDocuments(); + myFixture.findSingleIntention("Generate").invoke(myFixture.getProject(), myFixture.getEditor(), myFixture.getFile()); + waitForSkeleton(skeleton); + } + }); + + FileUtil.copy(skeleton, new File(myFixture.getTempDirPath(), skeleton.getName())); + myFixture.checkResultByFile(skeleton.getName(), DOT_NET_EXPECTED_SKELETON_PY, false); + } + + + @Override + public Set getTags() { + return Collections.unmodifiableSet(IRON_TAGS); + } + + // TODO: Doc + private static void waitForSkeleton(@NotNull final File skeletonToWait) { + for (int i = 0; i < SECONDS_TO_WAIT_FOR_SKELETON_GENERATION; i++) { + try { + // Can't sync with external process (no IPC is available for now), so we use busy wait + //noinspection BusyWait + Thread.sleep(1000L); + if (skeletonToWait.exists()) { + return; + } + } + catch (final InterruptedException e) { + throw new IllegalStateException("Interrupted while waiting for skeleton ", e); + } + } + final String message = + String.format("After %s seconds of waiting, skeleton %s still not ready", SECONDS_TO_WAIT_FOR_SKELETON_GENERATION, skeletonToWait); + Assert.assertTrue(message, skeletonToWait.exists()); + } +} diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/package-info.java b/python/testSrc/com/jetbrains/env/python/dotNet/package-info.java new file mode 100644 index 000000000000..e56e6203b98d --- /dev/null +++ b/python/testSrc/com/jetbrains/env/python/dotNet/package-info.java @@ -0,0 +1,5 @@ +/** + * IronPython tests. Install IronPython, .NET and add "iron" to "tags.txt" file. Check for more info: http://confluence.jetbrains.com/display/PYINT/Env+Tests + * @author Ilya.Kazakevich + */ +package com.jetbrains.env.python.dotNet; \ No newline at end of file From 5e98bdf85a9eaf98acbfe781622ae4a952ab1438 Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Tue, 25 Mar 2014 22:08:05 +0400 Subject: [PATCH 140/183] PY-12521 Wrong skeletons generated for static methods in CLR/IronPython (cosmetic changes in tests) --- .../env/python/dotNet/PyIronPythonTest.java | 2 +- .../env/python/dotNet/SkeletonTestTask.java | 19 ++++++++++--------- 2 files changed, 11 insertions(+), 10 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java index 349ebcc9665c..d9efa76a7211 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java @@ -9,7 +9,7 @@ import com.jetbrains.env.python.debug.PyEnvTestCase; public class PyIronPythonTest extends PyEnvTestCase { /** - * Tests skeleton generation + * Tests skeleton generation */ public void testSkeletons() throws Exception { runPythonTest(new SkeletonTestTask()); diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java index 7b8bafd9c548..9b5ef5ce4a80 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java @@ -30,18 +30,15 @@ class SkeletonTestTask extends PyExecutionFixtureTestTask { */ private static final Set IRON_TAGS = Sets.newHashSet("iron"); /** - * Number of seconds we wait for skeleton generation external process (should be enouigh) + * Number of seconds we wait for skeleton generation external process (should be enough) */ - private static final int SECONDS_TO_WAIT_FOR_SKELETON_GENERATION = 5; + private static final int SECONDS_TO_WAIT_FOR_SKELETON_GENERATION = 20; /** * We check that generated skeleton is exactly as this file */ private static final String DOT_NET_EXPECTED_SKELETON_PY = "dotNet/expected.skeleton.py"; + private static final String SKELETON_FILE_TO_TEST = "testSkeleton.py"; - /** - * @param sdkHome - * @throws com.intellij.util.IncorrectOperationException - */ @Override public void runTestOn(@NotNull final String sdkHome) throws IOException { final Sdk sdk = getSdk(sdkHome); @@ -49,9 +46,9 @@ class SkeletonTestTask extends PyExecutionFixtureTestTask { final File skeletonsPath = new File(PythonSdkType.getSkeletonsPath(PathManager.getSystemPath(), sdkHome)); final File skeleton = new File(skeletonsPath, "com/just/like/java.py"); // File with module skeleton - myFixture.copyFileToProject("dotNet/testSkeleton.py", "testSkeleton.py"); // File that uses CLR library + myFixture.copyFileToProject("dotNet/testSkeleton.py", SKELETON_FILE_TO_TEST); // File that uses CLR library myFixture.copyFileToProject("dotNet/PythonLibs.dll", "PythonLibs.dll"); // Library itself - myFixture.configureByFile("testSkeleton.py"); + myFixture.configureByFile(SKELETON_FILE_TO_TEST); myFixture.enableInspections(PyUnresolvedReferencesInspection.class); // This inspection should suggest us to generate stubs @@ -75,7 +72,11 @@ class SkeletonTestTask extends PyExecutionFixtureTestTask { return Collections.unmodifiableSet(IRON_TAGS); } - // TODO: Doc + /** + * Waits {@link #SECONDS_TO_WAIT_FOR_SKELETON_GENERATION} seconds for file to be created. + * Fails test after that. + * @param skeletonToWait file to wait + */ private static void waitForSkeleton(@NotNull final File skeletonToWait) { for (int i = 0; i < SECONDS_TO_WAIT_FOR_SKELETON_GENERATION; i++) { try { From 16d71dd2d0c5b8fe04804cd1d2bb548c7157e8d0 Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Wed, 26 Mar 2014 17:58:05 +0400 Subject: [PATCH 141/183] IronPython env test fix --- .../env/python/debug/PyEnvTestCase.java | 50 +++++++++++++++++-- .../env/python/dotNet/PyIronPythonTest.java | 9 ++++ .../env/python/dotNet/SkeletonTestTask.java | 4 +- 3 files changed, 56 insertions(+), 7 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index f570e150b8be..50d57f74ef12 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -14,14 +14,14 @@ import com.jetbrains.env.PyTestRemoteSdkProvider; import com.jetbrains.python.fixtures.PyTestCase; import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; import com.jetbrains.python.sdk.PythonSdkType; +import org.hamcrest.Matchers; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.junit.Assume; import java.io.File; import java.io.IOException; -import java.util.Collection; -import java.util.List; -import java.util.Set; +import java.util.*; /** * @author traff @@ -37,12 +37,52 @@ public abstract class PyEnvTestCase extends UsefulTestCase { protected static final boolean IS_ENV_CONFIGURATION = System.getProperty("pycharm.env") != null; + /** + * Tags that should exist between all tags, available on all interpreters for test to run. + * See {@link #PyEnvTestCase(String...)} + */ + @Nullable + private final String[] myRequiredTags; + + /** + * @param requiredTags tags that should exist on some interpreter for this test to run. + * if some of these tags do not exist on any interpreter, all test methods would be skipped using + * {@link org.junit.Assume}. + * See Assume manual. + * Check [IDEA-122939] and [IDEA-22193] as well. + * + */ + @SuppressWarnings("JUnitTestCaseWithNonTrivialConstructors") + protected PyEnvTestCase(@NotNull final String... requiredTags) { + myRequiredTags = requiredTags.length > 0 ? requiredTags.clone() : null; - @SuppressWarnings({"JUnitTestCaseWithNonTrivialConstructors"}) - public PyEnvTestCase() { PyTestCase.initPlatformPrefix(); } + @Override + public void setUp() throws Exception { + super.setUp(); + if (myRequiredTags != null) { // Ensure all tags exist between available interpreters + Assume.assumeThat( + "Can't find some tags between all available interpreter, test (all methods) will be skipped", + getAvailableTags(), + Matchers.hasItems(myRequiredTags) + ); + } + } + + /** + * @return all tags available between all interpreters + */ + @NotNull + private static Collection getAvailableTags() { + final Collection allAvailableTags = new HashSet(); + for (final String pythonRoot : getPythonRoots()) { + allAvailableTags.addAll(loadEnvTags(pythonRoot)); + } + return allAvailableTags; + } + @Override protected void invokeTestRunnable(final Runnable runnable) throws Exception { if (runInWriteAction()) { diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java index d9efa76a7211..fcef5ef15072 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java @@ -8,6 +8,15 @@ import com.jetbrains.env.python.debug.PyEnvTestCase; */ public class PyIronPythonTest extends PyEnvTestCase { + /** + * IronPython tag + */ + static final String IRON_TAG = "iron"; + + public PyIronPythonTest() { + super(IRON_TAG); + } + /** * Tests skeleton generation */ diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java index 9b5ef5ce4a80..3e8b1957d7be 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java @@ -26,9 +26,9 @@ import java.util.Set; class SkeletonTestTask extends PyExecutionFixtureTestTask { /** - * Tag + * Tags for this task to run */ - private static final Set IRON_TAGS = Sets.newHashSet("iron"); + private static final Set IRON_TAGS = Sets.newHashSet(PyIronPythonTest.IRON_TAG); /** * Number of seconds we wait for skeleton generation external process (should be enough) */ From a9f6d2fd5f37281f967c040166e7ea06e8bf4af1 Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Thu, 27 Mar 2014 02:11:28 +0400 Subject: [PATCH 142/183] PY-12497 .NET stubs are generated incorrectly when name is imported instead of module --- .../env/python/dotNet/PyIronPythonTest.java | 112 +++++++++++++++++- .../env/python/dotNet/SkeletonTestTask.java | 78 ++++++++++-- 2 files changed, 178 insertions(+), 12 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java index fcef5ef15072..ee41db732c96 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java @@ -1,9 +1,12 @@ package com.jetbrains.env.python.dotNet; import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.python.psi.PyFile; +import org.junit.Assert; /** * IronPython.NET specific tests + * * @author Ilya.Kazakevich */ public class PyIronPythonTest extends PyEnvTestCase { @@ -21,6 +24,113 @@ public class PyIronPythonTest extends PyEnvTestCase { * Tests skeleton generation */ public void testSkeletons() throws Exception { - runPythonTest(new SkeletonTestTask()); + runPythonTest(new SkeletonTestTask( + "dotNet/expected.skeleton.java.py", + "com.just.like.java", + "testSkeleton.py", + null + )); + } + + /** + * Tests skeleton generation with "from" statements + */ + public void testClassFromModule() throws Exception { + runPythonTest(new SkeletonTestTask( + "dotNet/expected.skeleton.java.py", + "com.just.like.java", + "import_class_from_module.py", + null + )); + } + + /** + * Tests skeleton generation when imported as alias + */ + public void testClassFromModuleAlias() throws Exception { + runPythonTest(new SkeletonTestTask( + "dotNet/expected.skeleton.java.py", + "com.just.like.java", + "import_class_from_module_alias.py", + null + )); + } + + /** + * Tests skeleton generation when module is imported + */ + public void testModuleFromPackage() throws Exception { + runPythonTest(new SkeletonTestTask( + "dotNet/expected.skeleton.java.py", + "com.just.like.java", + "import_module_from_package.py", + null + )); + } + + /** + * Tests skeleton generation when several classes are imported + */ + public void testSeveralClasses() throws Exception { + runPythonTest(new SkeletonTestTask( + "dotNet/expected.skeleton.java.py", + "com.just.like.java", + "import_several_classes_from_module.py", + "com.just.like.java.LikeJavaClass" + )); + } + + /** + * Tests skeletons for built-in classes. We can't compare files (CLR class may be changed from version to version), + * but we are sure there should be class System.Web.AspNetHostingPermissionLevel which is part of public API + */ + public void testImportBuiltInSystem() throws Exception { + final SkeletonTestTask task = new SkeletonTestTask( + null, + "System.Web", + "import_system.py", + null + ); + runPythonTest(task); + final PyFile skeleton = task.getGeneratedSkeleton(); + Assert.assertNotNull("System.Web does not contain class AspNetHostingPermissionLevel. Error generating stub? It has classes " + + skeleton.getTopLevelClasses(), + skeleton.findTopLevelClass("AspNetHostingPermissionLevel")); + } + + /** + * Test importing of inner classes + */ + public void testImportInnerClass() throws Exception { + runPythonTest(new SkeletonTestTask( + "dotNet/expected.skeleton.Deep.py", + "SingleNameSpace.Some.Deep", + "inner_class.py", + null + )); + } + + /** + * Test importing of the whole namespace + */ + public void testWholeNameSpace() throws Exception { + runPythonTest(new SkeletonTestTask( + "dotNet/expected.skeleton.SingleNameSpace.py", + "SingleNameSpace", + "whole_namespace.py", + null + )); + } + + /** + * Test importing of single class + */ + public void testSingleClass() throws Exception { + runPythonTest(new SkeletonTestTask( + "dotNet/expected.skeleton.SingleNameSpace.py", + "SingleNameSpace", + "single_class.py", + null + )); } } diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java index 3e8b1957d7be..21617d442d05 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java @@ -8,9 +8,13 @@ import com.intellij.openapi.util.io.FileUtil; import com.intellij.psi.PsiDocumentManager; import com.intellij.util.ui.UIUtil; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; +import com.jetbrains.python.PyBundle; +import com.jetbrains.python.PyNames; import com.jetbrains.python.inspections.PyUnresolvedReferencesInspection; +import com.jetbrains.python.psi.PyFile; import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.junit.Assert; import java.io.File; @@ -33,37 +37,80 @@ class SkeletonTestTask extends PyExecutionFixtureTestTask { * Number of seconds we wait for skeleton generation external process (should be enough) */ private static final int SECONDS_TO_WAIT_FOR_SKELETON_GENERATION = 20; + + @Nullable + private final String myExpectedSkeletonFile; + @NotNull + private final String myModuleNameToBeGenerated; + @NotNull + private final String mySourceFileToRunGenerationOn; + @NotNull + private final String myUseQuickFixWithThisModuleOnly; + private PyFile myGeneratedSkeleton; + /** - * We check that generated skeleton is exactly as this file + * @param expectedSkeletonFile if you want test to compare generated result with some file, provide its name. + * Pass null if you do not want to compare result with anything (you may do it yourself with {@link #getGeneratedSkeleton()}) + * @param moduleNameToBeGenerated name of module you think we should generate in dotted notation (like "System.Web" or "com.myModule"). + * System will wait for skeleton file for this module to be generated + * @param sourceFileToRunGenerationOn Source file where we should run "generate stubs" on. Be sure to place "caret" on appropriate place! + * @param useQuickFixWithThisModuleOnly If there are several quick fixes in code, you may run fix only on this module. + * Pass null if you are sure there would be only one quickfix */ - private static final String DOT_NET_EXPECTED_SKELETON_PY = "dotNet/expected.skeleton.py"; - private static final String SKELETON_FILE_TO_TEST = "testSkeleton.py"; + SkeletonTestTask(@Nullable final String expectedSkeletonFile, + @NotNull final String moduleNameToBeGenerated, + @NotNull final String sourceFileToRunGenerationOn, + @Nullable final String useQuickFixWithThisModuleOnly) { + myExpectedSkeletonFile = expectedSkeletonFile; + myModuleNameToBeGenerated = moduleNameToBeGenerated.replace('.', '/'); + mySourceFileToRunGenerationOn = sourceFileToRunGenerationOn; + myUseQuickFixWithThisModuleOnly = useQuickFixWithThisModuleOnly != null ? useQuickFixWithThisModuleOnly : ""; + } + @Override public void runTestOn(@NotNull final String sdkHome) throws IOException { final Sdk sdk = getSdk(sdkHome); ModuleRootModificationUtil.setModuleSdk(myFixture.getModule(), sdk); final File skeletonsPath = new File(PythonSdkType.getSkeletonsPath(PathManager.getSystemPath(), sdkHome)); - final File skeleton = new File(skeletonsPath, "com/just/like/java.py"); // File with module skeleton + File skeletonFileOrDirectory = new File(skeletonsPath, myModuleNameToBeGenerated); // File with module skeleton - myFixture.copyFileToProject("dotNet/testSkeleton.py", SKELETON_FILE_TO_TEST); // File that uses CLR library + // Module may be stored in "moduleName.py" or "moduleName/__init__.py" + if (skeletonFileOrDirectory.isDirectory()) { + skeletonFileOrDirectory = new File(skeletonFileOrDirectory, PyNames.INIT_DOT_PY); + } + else { + skeletonFileOrDirectory = new File(skeletonFileOrDirectory.getAbsolutePath() + PyNames.DOT_PY); + } + + final File skeletonFile = skeletonFileOrDirectory; + + if (skeletonFile.exists()) { // To make sure we do not reuse it + skeletonFile.delete(); + } + + myFixture.copyFileToProject("dotNet/" + mySourceFileToRunGenerationOn, mySourceFileToRunGenerationOn); // File that uses CLR library myFixture.copyFileToProject("dotNet/PythonLibs.dll", "PythonLibs.dll"); // Library itself - myFixture.configureByFile(SKELETON_FILE_TO_TEST); + myFixture.copyFileToProject("dotNet/SingleNameSpace.dll", "SingleNameSpace.dll"); // Another library + myFixture.configureByFile(mySourceFileToRunGenerationOn); myFixture.enableInspections(PyUnresolvedReferencesInspection.class); // This inspection should suggest us to generate stubs - UIUtil.invokeAndWaitIfNeeded(new Runnable() { @Override public void run() { PsiDocumentManager.getInstance(myFixture.getProject()).commitAllDocuments(); - myFixture.findSingleIntention("Generate").invoke(myFixture.getProject(), myFixture.getEditor(), myFixture.getFile()); - waitForSkeleton(skeleton); + final String intentionName = PyBundle.message("sdk.gen.stubs.for.binary.modules", myUseQuickFixWithThisModuleOnly); + myFixture.findSingleIntention(intentionName).invoke(myFixture.getProject(), myFixture.getEditor(), myFixture.getFile()); + waitForSkeleton(skeletonFile); } }); - FileUtil.copy(skeleton, new File(myFixture.getTempDirPath(), skeleton.getName())); - myFixture.checkResultByFile(skeleton.getName(), DOT_NET_EXPECTED_SKELETON_PY, false); + FileUtil.copy(skeletonFile, new File(myFixture.getTempDirPath(), skeletonFile.getName())); + if (myExpectedSkeletonFile != null) { + myFixture.checkResultByFile(skeletonFile.getName(), myExpectedSkeletonFile, false); + } + myGeneratedSkeleton = (PyFile)myFixture.configureByFile(skeletonFile.getName()); } @@ -75,6 +122,7 @@ class SkeletonTestTask extends PyExecutionFixtureTestTask { /** * Waits {@link #SECONDS_TO_WAIT_FOR_SKELETON_GENERATION} seconds for file to be created. * Fails test after that. + * * @param skeletonToWait file to wait */ private static void waitForSkeleton(@NotNull final File skeletonToWait) { @@ -95,4 +143,12 @@ class SkeletonTestTask extends PyExecutionFixtureTestTask { String.format("After %s seconds of waiting, skeleton %s still not ready", SECONDS_TO_WAIT_FOR_SKELETON_GENERATION, skeletonToWait); Assert.assertTrue(message, skeletonToWait.exists()); } + + /** + * @return File for generated skeleton. Call it after {@link #runTestOn(String)} only! + */ + @NotNull + PyFile getGeneratedSkeleton() { + return myGeneratedSkeleton; + } } From 8bfc370bf483c916141307b910124af8e8480a4e Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Wed, 2 Apr 2014 19:45:46 +0400 Subject: [PATCH 143/183] comment changed --- .../testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index 50d57f74ef12..1dae26dc57ff 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -49,7 +49,7 @@ public abstract class PyEnvTestCase extends UsefulTestCase { * if some of these tags do not exist on any interpreter, all test methods would be skipped using * {@link org.junit.Assume}. * See Assume manual. - * Check [IDEA-122939] and [IDEA-22193] as well. + * Check [IDEA-122939] and [TW-25043] as well. * */ @SuppressWarnings("JUnitTestCaseWithNonTrivialConstructors") From bb1edc36e7aa7ce1bc0e08e499c2d82e31477253 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 10 Apr 2014 02:55:00 +0200 Subject: [PATCH 144/183] Fix editor leak in tests. --- .../com/jetbrains/env/django/DjangoManageTestTask.java | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java index f20d0cf56952..d7b15e9bf0ad 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java @@ -56,6 +56,7 @@ public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { private ProcessHandler myProcessHandler; private ExecutionConsole myConsoleView; private Sdk mySdk; + private RunContentExecutor myRunContentExecutor; @Override protected abstract String getTestDataPath(); @@ -89,6 +90,9 @@ public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { Disposer.dispose(myDescriptor); myDescriptor = null; } + if (myRunContentExecutor != null) { + Disposer.dispose(myRunContentExecutor); + } DjangoManageTestTask.super.tearDown(); } catch (Exception e) { @@ -165,7 +169,8 @@ public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { UIUtil.invokeAndWaitIfNeeded(new Runnable() { public void run() { final Project project = myFixture.getProject(); - new RunContentExecutor(project, myProcessHandler) + myRunContentExecutor = new RunContentExecutor(project, myProcessHandler); + myRunContentExecutor .withFilter(new PythonTracebackFilter(project)) .run(); } From 6dc0b0808504c7e12b1aa87de7b34f061497f654 Mon Sep 17 00:00:00 2001 From: Roman Shevchenko Date: Thu, 10 Apr 2014 20:03:56 +0200 Subject: [PATCH 145/183] tests: common TeamCity detector --- python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java | 3 ++- .../testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java | 4 ++-- .../testSrc/com/jetbrains/env/python/PyPackagingTest.java | 3 ++- .../com/jetbrains/env/python/debug/PyEnvTestCase.java | 6 ++---- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java b/python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java index 8eb886f2965f..a5e261efe25f 100644 --- a/python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java +++ b/python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java @@ -5,6 +5,7 @@ import com.google.common.collect.Lists; import com.google.common.collect.Sets; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.text.StringUtil; +import com.intellij.testFramework.UsefulTestCase; import com.jetbrains.env.python.debug.PyEnvTestCase; import java.util.List; @@ -18,7 +19,7 @@ public class PyEnvSufficiencyTest extends PyEnvTestCase { ImmutableList.builder().add("python3", "django", "jython", "ipython", "ipython011", "ipython012", "nose", "pytest").build(); public void testSufficiency() { - if (IS_UNDER_TEAMCITY && IS_ENV_CONFIGURATION) { + if (UsefulTestCase.IS_UNDER_TEAMCITY && IS_ENV_CONFIGURATION) { Set tags = Sets.newHashSet(); List roots = getPythonRoots(); if (roots.size() == 0) { diff --git a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java index 7ec1dd30bcbb..43c920cab9f7 100644 --- a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java +++ b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java @@ -12,8 +12,8 @@ import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; import com.intellij.remote.RemoteCredentialsHolder; import com.intellij.remote.RemoteSdkException; +import com.intellij.testFramework.UsefulTestCase; import com.intellij.util.ui.UIUtil; -import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.python.debug.PyTestTask; import com.jetbrains.python.remote.*; import org.jetbrains.annotations.NotNull; @@ -111,7 +111,7 @@ public class PyTestRemoteSdkProvider { } public static boolean shouldFailWhenCantRunRemote() { - return !StringUtil.isEmpty(System.getenv("FAIL_WHEN_CANT_RUN_REMOTE")) || PyEnvTestCase.IS_UNDER_TEAMCITY; + return !StringUtil.isEmpty(System.getenv("FAIL_WHEN_CANT_RUN_REMOTE")) || UsefulTestCase.IS_UNDER_TEAMCITY; } private static String getTempHelpersPath(@NotNull String interpreterPath) throws IOException { diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index 2085e1589d58..7239b659329e 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -4,6 +4,7 @@ import com.google.common.collect.Sets; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; +import com.intellij.testFramework.UsefulTestCase; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; import com.jetbrains.env.python.debug.PyTestTask; @@ -27,7 +28,7 @@ import java.util.Set; public class PyPackagingTest extends PyEnvTestCase { @Override public void runPythonTest(PyTestTask testTask) { - if (PyEnvTestCase.IS_UNDER_TEAMCITY && SystemInfo.isWindows) { + if (UsefulTestCase.IS_UNDER_TEAMCITY && SystemInfo.isWindows) { return; //Don't run under Windows as after deleting from created virtualenvs original interpreter got spoiled } diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index 1dae26dc57ff..ba3bdcb0a3e6 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -30,11 +30,9 @@ public abstract class PyEnvTestCase extends UsefulTestCase { private static final Logger LOG = Logger.getInstance(PyEnvTestCase.class.getName()); private static final String TAGS_FILE = "tags.txt"; - public static final String PYCHARM_PYTHON_ENVS = "PYCHARM_PYTHON_ENVS"; + private static final String PYCHARM_PYTHON_ENVS = "PYCHARM_PYTHON_ENVS"; private static final String PYCHARM_PYTHON_VIRTUAL_ENVS = "PYCHARM_PYTHON_VIRTUAL_ENVS"; - public static final boolean IS_UNDER_TEAMCITY = System.getProperty("bootstrap.testcases") != null; - protected static final boolean IS_ENV_CONFIGURATION = System.getProperty("pycharm.env") != null; /** @@ -271,7 +269,7 @@ public abstract class PyEnvTestCase extends UsefulTestCase { } public static boolean notEnvConfiguration() { - return IS_UNDER_TEAMCITY && !IS_ENV_CONFIGURATION; + return UsefulTestCase.IS_UNDER_TEAMCITY && !IS_ENV_CONFIGURATION; } public static List getPythonRoots() { From ea179e2e5863675eec72caf34a1faffa65df8e59 Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Mon, 28 Apr 2014 20:15:11 +0400 Subject: [PATCH 146/183] check sys.path derictly in test --- .../jetbrains/env/django/DjangoPathTest.java | 21 +++++++++---------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java index dd8825206c6b..0e8e14cceb44 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java @@ -24,7 +24,7 @@ public class DjangoPathTest extends PyEnvTestCase { /** * This string is printed after printing sys.path in djangoPath/settings.py */ - public static final String THE_END_OF_SYS_PATH = "The end of sys.path"; + public static final String THE_END_OF_PROCESS = "Process finished with exit code 0"; public void testRunserverPath() throws IOException { runPythonTest(new DjangoPathTestTask() { @@ -43,7 +43,7 @@ public class DjangoPathTest extends PyEnvTestCase { public void testing() throws Exception { - waitForOutput(THE_END_OF_SYS_PATH); + waitForOutput(THE_END_OF_PROCESS); doTest(output(), getTestDataPath()); } @@ -53,16 +53,15 @@ public class DjangoPathTest extends PyEnvTestCase { private static void doTest(String output, String testDataPath) { final String[] splittedOutput = output.split("\\n"); final ArrayList outputList = Lists.newArrayList(); + + boolean add = false; for (String s : splittedOutput) { - if (s.equals(THE_END_OF_SYS_PATH)) { - break; - } - outputList.add(norm(s)); + if ("sys.path end".equals(s)) add = false; + if (add) outputList.add(norm(s)); + if ("sys.path start".equals(s)) add = true; } - testDataPath = norm(testDataPath); - Assert.assertEquals(testDataPath, outputList.get(1)); assertEquals(outputList.indexOf(testDataPath), @@ -99,7 +98,7 @@ public class DjangoPathTest extends PyEnvTestCase { } public void testing() throws Exception { - waitForOutput(THE_END_OF_SYS_PATH); + waitForOutput(THE_END_OF_PROCESS); doTest(output(), getTestDataPath()); } }); @@ -115,12 +114,12 @@ public class DjangoPathTest extends PyEnvTestCase { } public void testing() throws Exception { - waitForOutput(THE_END_OF_SYS_PATH); + waitForOutput(THE_END_OF_PROCESS); final String[] splittedOutput = output().split("\\n"); final ArrayList outputList = Lists.newArrayList(); for (String s : splittedOutput) { - if (s.equals(THE_END_OF_SYS_PATH)) { + if (s.equals(THE_END_OF_PROCESS)) { break; } outputList.add(s); From 6c1e59f307cf307c70b957825564d0d94877b7a4 Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Tue, 29 Apr 2014 12:58:05 +0400 Subject: [PATCH 147/183] removed duplicated test see DjangoTestRunnerTest --- .../jetbrains/env/django/DjangoPathTest.java | 54 ++++--------------- 1 file changed, 10 insertions(+), 44 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java index 0e8e14cceb44..4ac8c45de9fd 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java @@ -5,10 +5,7 @@ import com.intellij.execution.configurations.ConfigurationFactory; import com.intellij.openapi.util.io.FileUtil; import com.jetbrains.django.run.DjangoServerRunConfiguration; import com.jetbrains.django.run.DjangoServerRunConfigurationType; -import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; -import com.jetbrains.django.testRunner.DjangoTestsRunConfiguration; import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.python.packaging.*; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import junit.framework.Assert; import org.jetbrains.annotations.Nullable; @@ -24,7 +21,7 @@ public class DjangoPathTest extends PyEnvTestCase { /** * This string is printed after printing sys.path in djangoPath/settings.py */ - public static final String THE_END_OF_PROCESS = "Process finished with exit code 0"; + public static final String THE_END_OF_SYS_PATH = "The end of sys.path"; public void testRunserverPath() throws IOException { runPythonTest(new DjangoPathTestTask() { @@ -43,7 +40,7 @@ public class DjangoPathTest extends PyEnvTestCase { public void testing() throws Exception { - waitForOutput(THE_END_OF_PROCESS); + waitForOutput(THE_END_OF_SYS_PATH); doTest(output(), getTestDataPath()); } @@ -53,15 +50,16 @@ public class DjangoPathTest extends PyEnvTestCase { private static void doTest(String output, String testDataPath) { final String[] splittedOutput = output.split("\\n"); final ArrayList outputList = Lists.newArrayList(); - - boolean add = false; for (String s : splittedOutput) { - if ("sys.path end".equals(s)) add = false; - if (add) outputList.add(norm(s)); - if ("sys.path start".equals(s)) add = true; + if (s.equals(THE_END_OF_SYS_PATH)) { + break; + } + outputList.add(norm(s)); } + testDataPath = norm(testDataPath); + Assert.assertEquals(testDataPath, outputList.get(1)); assertEquals(outputList.indexOf(testDataPath), @@ -72,38 +70,6 @@ public class DjangoPathTest extends PyEnvTestCase { return FileUtil.toSystemIndependentName(testDataPath); } - public void testTestPath() throws IOException { - runPythonTest(new DjangoPathTestTask() { - - @Override - public ConfigurationFactory getFactory() { - return DjangoTestsConfigurationType.getInstance().getConfigurationFactories()[0]; - } - - @Override - protected void configure(AbstractPythonRunConfiguration config) { - String target = "mysite.SimpleTest"; - try { - final PyPackage django = ((PyPackageManagerImpl)PyPackageManager.getInstance(config.getSdk())).findPackage("django"); - if (django != null) { - if (django.matches(PyRequirement.fromStringGuaranteed("django>=1.6a"))) { - target = "mysite.tests.SimpleTest"; - } - } - } - catch (PyExternalProcessException ignored) { - } - - ((DjangoTestsRunConfiguration)config).setTarget(target); - } - - public void testing() throws Exception { - waitForOutput(THE_END_OF_PROCESS); - doTest(output(), getTestDataPath()); - } - }); - } - public void testManagePath() throws IOException { runPythonTest(new DjangoPathTestTask() { @@ -114,12 +80,12 @@ public class DjangoPathTest extends PyEnvTestCase { } public void testing() throws Exception { - waitForOutput(THE_END_OF_PROCESS); + waitForOutput(THE_END_OF_SYS_PATH); final String[] splittedOutput = output().split("\\n"); final ArrayList outputList = Lists.newArrayList(); for (String s : splittedOutput) { - if (s.equals(THE_END_OF_PROCESS)) { + if (s.equals(THE_END_OF_SYS_PATH)) { break; } outputList.add(s); From bd2586fc922814bdc9895e4fcfde0289456c7ee2 Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Wed, 7 May 2014 18:25:27 +0400 Subject: [PATCH 148/183] Temporary fixed tests (because of [TW-25043]) --- .../env/python/debug/PyEnvTestCase.java | 46 +++++++++++++------ .../env/python/dotNet/PyIronPythonTest.java | 3 ++ 2 files changed, 35 insertions(+), 14 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index ba3bdcb0a3e6..9a5a5d9a3641 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -18,10 +18,14 @@ import org.hamcrest.Matchers; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.junit.Assume; +import org.junit.internal.AssumptionViolatedException; import java.io.File; import java.io.IOException; -import java.util.*; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Set; /** * @author traff @@ -44,11 +48,10 @@ public abstract class PyEnvTestCase extends UsefulTestCase { /** * @param requiredTags tags that should exist on some interpreter for this test to run. - * if some of these tags do not exist on any interpreter, all test methods would be skipped using - * {@link org.junit.Assume}. - * See Assume manual. - * Check [IDEA-122939] and [TW-25043] as well. - * + * if some of these tags do not exist on any interpreter, all test methods would be skipped using + * {@link org.junit.Assume}. + * See Assume manual. + * Check [IDEA-122939] and [TW-25043] as well. */ @SuppressWarnings("JUnitTestCaseWithNonTrivialConstructors") protected PyEnvTestCase(@NotNull final String... requiredTags) { @@ -57,16 +60,28 @@ public abstract class PyEnvTestCase extends UsefulTestCase { PyTestCase.initPlatformPrefix(); } - @Override - public void setUp() throws Exception { - super.setUp(); + /** + * Checks that all required tags exist on interpreter. It should throw {@link org.junit.internal.AssumptionViolatedException}, + * but fixed temporary due to [TW-25043] + * + * @return true of all required tags are met + */ + protected boolean allRequiredTagsExist() { if (myRequiredTags != null) { // Ensure all tags exist between available interpreters - Assume.assumeThat( - "Can't find some tags between all available interpreter, test (all methods) will be skipped", - getAvailableTags(), - Matchers.hasItems(myRequiredTags) + + try { + Assume.assumeThat( + "Can't find some tags between all available interpreter, test (all methods) will be skipped", + getAvailableTags(), + Matchers.hasItems(myRequiredTags) ); + } + catch (final AssumptionViolatedException ignore) { // Because of [TW-25043] + return false; + } } + + return true; } /** @@ -104,7 +119,10 @@ public abstract class PyEnvTestCase extends UsefulTestCase { return false; } - public void runPythonTest(PyTestTask testTask) { + public void runPythonTest(final PyTestTask testTask) { + if (!allRequiredTagsExist()) { + return; + } runTest(testTask, getTestName(false)); } diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java index ee41db732c96..efb560c272e8 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java @@ -91,6 +91,9 @@ public class PyIronPythonTest extends PyEnvTestCase { "import_system.py", null ); + if (! allRequiredTagsExist()) { // Due to [TW-25043] + return; + } runPythonTest(task); final PyFile skeleton = task.getGeneratedSkeleton(); Assert.assertNotNull("System.Web does not contain class AspNetHostingPermissionLevel. Error generating stub? It has classes " + From cac02ab8c05d81d0d6b0e6a8cb99eb4cb4ca9d8c Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Wed, 7 May 2014 21:00:10 +0200 Subject: [PATCH 149/183] Fixed test data to pass on Django 1.6 --- .../env/django/DjangoEnvTestTask.java | 4 ++++ .../env/django/DjangoTemplateDebuggerTest.java | 18 ++++++++++-------- .../env/python/debug/PyBaseDebuggerTask.java | 15 +++++++++++++-- 3 files changed, 27 insertions(+), 10 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java index 9a0a38c4aaab..7e87e9fd8cb2 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java @@ -141,4 +141,8 @@ public class DjangoEnvTestTask extends PyDebuggerTask { public Set getTags() { return ImmutableSet.of("django"); } + + protected void waitForStart() throws InterruptedException { + waitForOutput("Development server is running", "Starting development server"); + } } diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java index 88d5316f50bd..c6a41f6d03f5 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java @@ -38,7 +38,7 @@ public class DjangoTemplateDebuggerTest extends PyEnvTestCase { @Override public void testing() throws Exception { - waitForOutput("Development server is running"); + waitForStart(); DjangoEnvTestTask.LoadingPage page = loadPage(myPort + "/test1"); @@ -78,7 +78,7 @@ public class DjangoTemplateDebuggerTest extends PyEnvTestCase { @Override public void testing() throws Exception { - waitForOutput("Development server is running"); + waitForStart(); LoadingPage page = loadPage(myPort + "/test1"); @@ -107,6 +107,8 @@ public class DjangoTemplateDebuggerTest extends PyEnvTestCase { page.get().contains("templatedjangodebugging"); } + + }); } @@ -121,7 +123,7 @@ public class DjangoTemplateDebuggerTest extends PyEnvTestCase { @Override public void testing() throws Exception { - waitForOutput("Development server is running"); + waitForStart(); LoadingPage page = loadPage(myPort + "/test2"); @@ -164,7 +166,7 @@ public class DjangoTemplateDebuggerTest extends PyEnvTestCase { @Override public void testing() throws Exception { - waitForOutput("Development server is running"); + waitForStart(); LoadingPage page = loadPage(myPort + "/test3"); @@ -193,7 +195,7 @@ public class DjangoTemplateDebuggerTest extends PyEnvTestCase { @Override public void testing() throws Exception { - waitForOutput("Development server is running"); + waitForStart(); LoadingPage page = loadPage(myPort + "/test1"); @@ -229,7 +231,7 @@ public class DjangoTemplateDebuggerTest extends PyEnvTestCase { @Override public void testing() throws Exception { - waitForOutput("Development server is running"); + waitForStart(); loadPage(ports[1] + "/test4"); @@ -268,7 +270,7 @@ public class DjangoTemplateDebuggerTest extends PyEnvTestCase { @Override public void testing() throws Exception { - waitForOutput("Development server is running"); + waitForStart(); loadPage(ports[1] + "/test1"); @@ -295,7 +297,7 @@ public class DjangoTemplateDebuggerTest extends PyEnvTestCase { @Override public void testing() throws Exception { - waitForOutput("Development server is running"); + waitForStart(); loadPage(ports[1] + "/test5"); diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java index 2c3cb6333f60..2515da6da8a1 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java @@ -196,9 +196,9 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { myDebugProcess.changeVariable((PyDebugValue)var, value); } - public void waitForOutput(String string) throws InterruptedException { + public void waitForOutput(String ... string) throws InterruptedException { int count = 0; - while (!output().contains(string)) { + while (!containsOneOf(output(), string)) { if (count > 10) { Assert.fail("'" + string + "'" + " is not present in output.\n" + output()); } @@ -207,6 +207,17 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { } } + protected boolean containsOneOf(String output, String[] strings) { + for (String s: strings) { + if (output.contains(s)) { + return true; + } + } + + return false; + } + + public void setShouldPrintOutput(boolean shouldPrintOutput) { this.shouldPrintOutput = shouldPrintOutput; } From 4cdf55b8103a8d3d58c3068e43c77dcaab2c7ad1 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 8 May 2014 19:09:16 +0200 Subject: [PATCH 150/183] Print correct string. --- .../com/jetbrains/env/python/debug/PyBaseDebuggerTask.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java index 2515da6da8a1..2256aca12ae6 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java @@ -5,6 +5,7 @@ import com.intellij.openapi.application.Result; import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Pair; +import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.JarFileSystem; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.util.ui.UIUtil; @@ -200,7 +201,7 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { int count = 0; while (!containsOneOf(output(), string)) { if (count > 10) { - Assert.fail("'" + string + "'" + " is not present in output.\n" + output()); + Assert.fail("None of '" + StringUtil.join(string, ", ") + "'" + " is not present in output.\n" + output()); } Thread.sleep(2000); count++; From 1ffd4bbbbccaf9ab3010c99d60040d440f2982e4 Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Thu, 15 May 2014 19:33:16 +0400 Subject: [PATCH 151/183] Temporary fix removed because TW-25043 is fixed --- .../env/python/debug/PyEnvTestCase.java | 32 +++++-------------- .../env/python/dotNet/PyIronPythonTest.java | 3 -- 2 files changed, 8 insertions(+), 27 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index 9a5a5d9a3641..eec23e2bf9b7 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -18,7 +18,6 @@ import org.hamcrest.Matchers; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.junit.Assume; -import org.junit.internal.AssumptionViolatedException; import java.io.File; import java.io.IOException; @@ -60,28 +59,16 @@ public abstract class PyEnvTestCase extends UsefulTestCase { PyTestCase.initPlatformPrefix(); } - /** - * Checks that all required tags exist on interpreter. It should throw {@link org.junit.internal.AssumptionViolatedException}, - * but fixed temporary due to [TW-25043] - * - * @return true of all required tags are met - */ - protected boolean allRequiredTagsExist() { + @Override + public void setUp() throws Exception { + super.setUp(); if (myRequiredTags != null) { // Ensure all tags exist between available interpreters - - try { - Assume.assumeThat( - "Can't find some tags between all available interpreter, test (all methods) will be skipped", - getAvailableTags(), - Matchers.hasItems(myRequiredTags) - ); - } - catch (final AssumptionViolatedException ignore) { // Because of [TW-25043] - return false; - } + Assume.assumeThat( + "Can't find some tags between all available interpreter, test (all methods) will be skipped", + getAvailableTags(), + Matchers.hasItems(myRequiredTags) + ); } - - return true; } /** @@ -120,9 +107,6 @@ public abstract class PyEnvTestCase extends UsefulTestCase { } public void runPythonTest(final PyTestTask testTask) { - if (!allRequiredTagsExist()) { - return; - } runTest(testTask, getTestName(false)); } diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java index efb560c272e8..ee41db732c96 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java @@ -91,9 +91,6 @@ public class PyIronPythonTest extends PyEnvTestCase { "import_system.py", null ); - if (! allRequiredTagsExist()) { // Due to [TW-25043] - return; - } runPythonTest(task); final PyFile skeleton = task.getGeneratedSkeleton(); Assert.assertNotNull("System.Web does not contain class AspNetHostingPermissionLevel. Error generating stub? It has classes " + From fe55d47821694e8c1ad74b7a1b2450b852a1d30d Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Fri, 23 May 2014 21:28:39 +0400 Subject: [PATCH 152/183] PyEnv tests were refactored to support easy SDK creation. Scaffolding for Project Creation test was also created --- .../django/DjangoManageTaskActionsTest.java | 48 +----- .../env/django/DjangoManageTestTask.java | 24 +-- .../env/django/DjangoProjectCreationTest.java | 83 ++++++++++ .../env/django/DjangoTestRunnerTest.java | 1 - .../PyPackageRequirementsInspectionTest.java | 2 +- .../jetbrains/env/python/PyPackagingTest.java | 10 +- .../env/python/PythonSkeletonsTest.java | 74 +-------- .../env/python/console/PyConsoleTask.java | 2 +- .../debug/PyExecutionFixtureTestTask.java | 156 +++++++++++++++--- .../env/python/debug/PyTestTask.java | 6 + .../env/python/dotNet/SkeletonTestTask.java | 8 +- 11 files changed, 236 insertions(+), 178 deletions(-) create mode 100644 python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java index 502029609a63..81204ef0cbc2 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java @@ -2,23 +2,13 @@ package com.jetbrains.env.django; import com.intellij.execution.configurations.ConfigurationFactory; import com.intellij.openapi.module.Module; -import com.intellij.openapi.projectRoots.Sdk; -import com.intellij.openapi.projectRoots.SdkModificator; import com.intellij.openapi.roots.ModuleRootModificationUtil; -import com.intellij.openapi.roots.OrderRootType; -import com.intellij.openapi.vfs.LocalFileSystem; -import com.intellij.openapi.vfs.VirtualFile; import com.jetbrains.django.actions.manage.ManageTaskActions; import com.jetbrains.django.manage.BaseCommand; import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; import com.jetbrains.django.util.DjangoUtil; import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.python.packaging.PyExternalProcessException; -import com.jetbrains.python.packaging.PyPackage; -import com.jetbrains.python.packaging.PyPackageManager; -import com.jetbrains.python.packaging.PyPackageManagerImpl; import com.jetbrains.python.run.AbstractPythonRunConfiguration; -import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.junit.Assert; @@ -26,7 +16,6 @@ import java.io.IOException; import java.util.Collection; import java.util.HashSet; import java.util.List; -import java.util.Set; /** * @author Ilya.Kazakevich @@ -40,35 +29,6 @@ public class DjangoManageTaskActionsTest extends PyEnvTestCase { runPythonTest(new DjangoManageCommandsTestTask()); } - /** - * Fills SDK roots with installed packages - * - * @param sdk package to fill - * @throws PyExternalProcessException if system was not able to run external tools to list installed packages - */ - private static void fillSdkWithInstalledPackages(@NotNull final Sdk sdk) throws PyExternalProcessException { - final List packages = ((PyPackageManagerImpl)PyPackageManager.getInstance(sdk)).getPackages(); - final Set packagePaths = new HashSet(); - for (final PyPackage aPackage : packages) { - final String location = aPackage.getLocation(); - if (location != null) { - packagePaths.add(location); - } - } - - final SdkModificator modificator = sdk.getSdkModificator(); - final LocalFileSystem fileSystem = LocalFileSystem.getInstance(); - for (final String path : packagePaths) { - final VirtualFile virtualFile = fileSystem.findFileByPath(path); - if (virtualFile == null) { - throw new IllegalStateException("Failed to read file " + path); - } - modificator.addRoot(virtualFile, OrderRootType.CLASSES); - } - - - modificator.commitChanges(); - } private static class DjangoManageCommandsTestTask extends DjangoPathTestTask { @Nullable @@ -77,18 +37,12 @@ public class DjangoManageTaskActionsTest extends PyEnvTestCase { return DjangoTestsConfigurationType.getInstance().getConfigurationFactories()[0]; } + @Override protected void configure(final AbstractPythonRunConfiguration config) throws IOException { - // Fill SDK with installed packages super.configure(config); final Module module = config.getModule(); assert module != null : "Config has no module"; - try { - fillSdkWithInstalledPackages(config.getSdk()); - } - catch (final PyExternalProcessException e) { - throw new IllegalStateException("Failed to get list of packages", e); - } ModuleRootModificationUtil.setModuleSdk(module, config.getSdk()); diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java index d7b15e9bf0ad..66ad2ba69fcf 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java @@ -18,11 +18,8 @@ import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.module.Module; import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; -import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil; import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.Key; -import com.intellij.openapi.vfs.LocalFileSystem; -import com.intellij.openapi.vfs.VirtualFile; import com.intellij.util.concurrency.Semaphore; import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.XDebuggerTestUtil; @@ -35,7 +32,7 @@ import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; import com.jetbrains.python.PythonHelpersLocator; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import com.jetbrains.python.run.PythonTracebackFilter; -import com.jetbrains.python.sdk.PythonSdkType; +import com.jetbrains.python.sdk.InvalidSdkException; import com.jetbrains.python.templateLanguages.TemplatesService; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -102,28 +99,13 @@ public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { }); } - private void createTempSdk(@NotNull final String sdkHome) { - - mySdk = PythonSdkType.findSdkByPath(sdkHome); - - if (mySdk == null) { - final VirtualFile binary = LocalFileSystem.getInstance().findFileByPath(sdkHome); - if (binary != null) { - UIUtil.invokeAndWaitIfNeeded(new Runnable() { - public void run() { - mySdk = SdkConfigurationUtil.createAndAddSDK(sdkHome, PythonSdkType.getInstance()); - } - }); - } - } - } @Nullable public abstract ConfigurationFactory getFactory(); @Override public void runTestOn(final String sdkHome) throws Exception { - createTempSdk(sdkHome); + mySdk = createTempSdk(sdkHome, SdkCreationType.SDK_PACKAGES_ONLY); before(); final Semaphore s = new Semaphore(); @@ -148,7 +130,7 @@ public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { } } - private void runProcess(final String sdkHome, final Semaphore s) throws ExecutionException, IOException { + private void runProcess(final String sdkHome, final Semaphore s) throws ExecutionException, IOException, InvalidSdkException { final ConfigurationFactory factory = getFactory(); if (factory == null) { // PythonTask (there is no run configuration) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java new file mode 100644 index 000000000000..abab541fa42a --- /dev/null +++ b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java @@ -0,0 +1,83 @@ +package com.jetbrains.env.django; + +import com.intellij.execution.ExecutionException; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.testFramework.UsefulTestCase; +import com.jetbrains.django.DjangoNames; +import com.jetbrains.django.model.DjangoAdmin; +import com.jetbrains.django.util.DjangoUtil; +import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; +import com.jetbrains.python.psi.PyFile; +import com.jetbrains.python.psi.PyUtil; +import com.jetbrains.python.psi.impl.PyBlockEvaluator; +import org.jetbrains.annotations.NotNull; +import org.junit.Assert; + +/** + * Tests projection creation for Django + * + * @author Ilya.Kazakevich + */ +public class DjangoProjectCreationTest extends PyEnvTestCase { + + private static final String ROOT_FOLDER_NAME = "content_root"; + private static final String WEB_SITE_NAME = "myWebSite"; + + public DjangoProjectCreationTest() { + super("django"); + } + + + // TODO: Doc + public void testProjectWithTemplates() throws Exception { + runPythonTest(new MyDjangoProjectCreationTest()); + } + + private static class MyDjangoProjectCreationTest extends PyExecutionFixtureTestTask { + @Override + public void runTestOn(@NotNull final String sdkHome) throws Exception { + final Sdk sdk = createTempSdk(sdkHome, SdkCreationType.SDK_PACKAGES_ONLY); + final String djangoPath = DjangoUtil.getDjangoPath(sdk); + assert djangoPath != null : "No django found under " + sdkHome; + + final VirtualFile contentRoot = myFixture.getTempDirFixture().findOrCreateDir(ROOT_FOLDER_NAME); + final String templatesDir = myFixture.getTempDirFixture().findOrCreateDir(ROOT_FOLDER_NAME + "/templates").getCanonicalPath(); + assert templatesDir != null : "Failed to create template dirs"; + + UsefulTestCase.edt(new Runnable() { + @Override + public void run() { + try { + DjangoAdmin.createProject( + myFixture.getProject(), + sdk, + contentRoot, + WEB_SITE_NAME, + "myMainApp", + templatesDir, + djangoPath, + false, + false + ); + } + catch (final ExecutionException ex) { + Assert.fail(ex.toString()); + } + } + }); + + final PyFile settingsPy = + PyUtil.as(myFixture.configureByFile(ROOT_FOLDER_NAME + '/' + WEB_SITE_NAME + '/' + DjangoNames.SETTINGS_FILE), PyFile.class); + Assert.assertNotNull(DjangoNames.SETTINGS_FILE + " not created", settingsPy); + Assert.assertEquals("Bad file name for settings", DjangoNames.SETTINGS_FILE, settingsPy.getName()); + + final PyBlockEvaluator evaluator = new PyBlockEvaluator(); + evaluator.evaluate(settingsPy); + Object baseDirPath = evaluator.getValue("TEMPLATE_DIRS"); + + // TODO: Finish test + } + } +} diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java index c9d4af479c11..0c09346f39f6 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java @@ -4,7 +4,6 @@ import com.google.common.collect.Lists; import com.intellij.execution.configurations.ConfigurationFactory; import com.intellij.openapi.module.Module; import com.intellij.openapi.util.io.FileUtil; -import com.intellij.openapi.util.text.StringUtil; import com.intellij.util.ui.UIUtil; import com.jetbrains.django.facet.DjangoFacet; import com.jetbrains.django.facet.DjangoFacetConfiguration; diff --git a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java index d4501e4d3b7b..9f82a1830e63 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java @@ -47,7 +47,7 @@ public class PyPackageRequirementsInspectionTest extends PyEnvTestCase { @Override public void runTestOn(String sdkHome) throws Exception { myFixture.enableInspections(PyPackageRequirementsInspection.class); - final Sdk sdk = PythonSkeletonsTest.createTempSdk(sdkHome); + final Sdk sdk = createTempSdk(sdkHome, SdkCreationType.SDK_PACKAGES_ONLY); final String perSdkDir = Integer.toHexString(System.identityHashCode(sdk)); final VirtualFile root = myFixture.copyDirectoryToProject(dir, perSdkDir); assertNotNull(root); diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index 7239b659329e..f0c16c870cb4 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -39,7 +39,7 @@ public class PyPackagingTest extends PyEnvTestCase { runPythonTest(new PyPackagingTestTask() { @Override public void runTestOn(String sdkHome) throws Exception { - final Sdk sdk = PythonSkeletonsTest.createTempSdk(sdkHome); + final Sdk sdk = createTempSdk(sdkHome, SdkCreationType.EMPTY_SDK); List packages = null; try { packages = ((PyPackageManagerImpl)PyPackageManager.getInstance(sdk)).getPackages(); @@ -64,7 +64,7 @@ public class PyPackagingTest extends PyEnvTestCase { runPythonTest(new PyPackagingTestTask() { @Override public void runTestOn(String sdkHome) throws Exception { - final Sdk sdk = PythonSkeletonsTest.createTempSdk(sdkHome); + final Sdk sdk = createTempSdk(sdkHome, SdkCreationType.EMPTY_SDK); try { final LanguageLevel languageLevel = PythonSdkType.getLanguageLevelForSdk(sdk); // virtualenv >= 0.10 supports Python >= 2.6 @@ -75,7 +75,7 @@ public class PyPackagingTest extends PyEnvTestCase { final File venvDir = new File(tempDir, "venv"); final String venvSdkHome = ((PyPackageManagerImpl)PyPackageManagerImpl.getInstance(sdk)).createVirtualEnv(venvDir.toString(), false); - final Sdk venvSdk = PythonSkeletonsTest.createTempSdk(venvSdkHome); + final Sdk venvSdk = createTempSdk(venvSdkHome, SdkCreationType.EMPTY_SDK); assertNotNull(venvSdk); assertTrue(PythonSdkType.isVirtualEnv(venvSdk)); assertInstanceOf(PythonSdkFlavor.getPlatformIndependentFlavor(venvSdk.getHomePath()), VirtualEnvSdkFlavor.class); @@ -104,12 +104,12 @@ public class PyPackagingTest extends PyEnvTestCase { @Override public void runTestOn(String sdkHome) throws Exception { - final Sdk sdk = PythonSkeletonsTest.createTempSdk(sdkHome); + final Sdk sdk = createTempSdk(sdkHome, SdkCreationType.EMPTY_SDK); try { final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); final File venvDir = new File(tempDir, "venv"); final String venvSdkHome = ((PyPackageManagerImpl)PyPackageManager.getInstance(sdk)).createVirtualEnv(venvDir.getPath(), false); - final Sdk venvSdk = PythonSkeletonsTest.createTempSdk(venvSdkHome); + final Sdk venvSdk = createTempSdk(venvSdkHome, SdkCreationType.EMPTY_SDK); assertNotNull(venvSdk); final PyPackageManagerImpl manager = (PyPackageManagerImpl)PyPackageManager.getInstance(venvSdk); final List packages1 = manager.getPackages(); diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index 41fdf71d06fe..7072bfa7a8a8 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -1,22 +1,12 @@ package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; -import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.module.Module; import com.intellij.openapi.module.ModuleUtil; import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; -import com.intellij.openapi.projectRoots.SdkModificator; -import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil; -import com.intellij.openapi.roots.ModuleRootModificationUtil; -import com.intellij.openapi.roots.OrderRootType; -import com.intellij.openapi.roots.ProjectRootManager; -import com.intellij.openapi.util.Ref; -import com.intellij.openapi.util.io.FileUtil; -import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiFile; -import com.intellij.testFramework.fixtures.CodeInsightTestFixture; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; import com.jetbrains.env.python.debug.PyTestTask; @@ -29,7 +19,6 @@ import com.jetbrains.python.psi.impl.PyBuiltinCache; import com.jetbrains.python.psi.resolve.PythonSdkPathCache; import com.jetbrains.python.psi.types.PyType; import com.jetbrains.python.psi.types.TypeEvalContext; -import com.jetbrains.python.sdk.InvalidSdkException; import com.jetbrains.python.sdk.PythonSdkType; import com.jetbrains.python.sdk.skeletons.PySkeletonRefresher; import com.jetbrains.python.sdk.skeletons.SkeletonVersionChecker; @@ -37,8 +26,6 @@ import com.jetbrains.python.toolbox.Maybe; import org.jetbrains.annotations.NotNull; import java.io.File; -import java.io.IOException; -import java.util.List; import java.util.Set; /** @@ -171,69 +158,11 @@ public class PythonSkeletonsTest extends PyEnvTestCase { }); } - private void generateTempSkeletons(CodeInsightTestFixture fixture, final @NotNull Sdk sdk) throws InvalidSdkException, IOException { - final Project project = fixture.getProject(); - ModuleRootModificationUtil.setModuleSdk(fixture.getModule(), sdk); - - edt(new Runnable() { - @Override - public void run() { - ApplicationManager.getApplication().runWriteAction(new Runnable() { - @Override - public void run() { - ProjectRootManager.getInstance(project).setProjectSdk(sdk); - } - }); - } - }); - - - final SdkModificator modificator = sdk.getSdkModificator(); - modificator.removeRoots(OrderRootType.CLASSES); - for (String path : PythonSdkType.getSysPathsFromScript(sdk.getHomePath())) { - PythonSdkType.addSdkRoot(modificator, path); - } - final File tempDir = FileUtil.createTempDirectory(getTestName(false), null); - final File skeletonsDir = new File(tempDir, PythonSdkType.SKELETON_DIR_NAME); - FileUtil.createDirectory(skeletonsDir); - final String skeletonsPath = skeletonsDir.toString(); - PythonSdkType.addSdkRoot(modificator, skeletonsPath); - - edt(new Runnable() { - @Override - public void run() { - modificator.commitChanges(); - } - }); - - final SkeletonVersionChecker checker = new SkeletonVersionChecker(0); - final PySkeletonRefresher refresher = new PySkeletonRefresher(project, null, sdk, skeletonsPath, null, null); - final List errors = refresher.regenerateSkeletons(checker, null); - assertEmpty(errors); - } private void runTest(@NotNull PyTestTask task) { runPythonTest(task); } - @NotNull - public static Sdk createTempSdk(@NotNull String sdkHome) { - final VirtualFile binary = LocalFileSystem.getInstance().findFileByPath(sdkHome); - assertNotNull("Interpreter file not found: " + sdkHome, binary); - final Ref ref = Ref.create(); - edt(new Runnable() { - - @Override - public void run() { - final Sdk sdk = SdkConfigurationUtil.setupSdk(new Sdk[0], binary, PythonSdkType.getInstance(), true, null, null); - assertNotNull(sdk); - ref.set(sdk); - } - }); - - return ref.get(); - } - private abstract class SkeletonsTask extends PyExecutionFixtureTestTask { @Override @@ -243,8 +172,7 @@ public class PythonSkeletonsTest extends PyEnvTestCase { @Override public void runTestOn(String sdkHome) throws Exception { - final Sdk sdk = createTempSdk(sdkHome); - generateTempSkeletons(myFixture, sdk); + final Sdk sdk = createTempSdk(sdkHome, SdkCreationType.SDK_PACKAGES_AND_SKELETONS); runTestOn(sdk); } diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index f76f85b78ba7..02500c6d6122 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -126,7 +126,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { public void runTestOn(final String sdkHome) throws Exception { final Project project = getProject(); - final Sdk sdk = getSdk(sdkHome); + final Sdk sdk = createTempSdk(sdkHome, SdkCreationType.EMPTY_SDK); setProcessCanTerminate(false); diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java index fc61e5a32b3c..cb44c54072e2 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java @@ -3,12 +3,22 @@ package com.jetbrains.env.python.debug; import com.google.common.collect.Lists; import com.intellij.execution.process.ProcessHandler; import com.intellij.ide.util.projectWizard.EmptyModuleBuilder; +import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.module.ModuleType; import com.intellij.openapi.module.ModuleTypeManager; import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; -import com.intellij.openapi.projectRoots.impl.ProjectJdkImpl; +import com.intellij.openapi.projectRoots.SdkModificator; +import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil; +import com.intellij.openapi.roots.ModuleRootModificationUtil; +import com.intellij.openapi.roots.OrderRootType; +import com.intellij.openapi.roots.ProjectRootManager; +import com.intellij.openapi.util.Ref; +import com.intellij.openapi.util.io.FileUtil; +import com.intellij.openapi.vfs.LocalFileSystem; +import com.intellij.openapi.vfs.VirtualFile; import com.intellij.testFramework.LightProjectDescriptor; +import com.intellij.testFramework.UsefulTestCase; import com.intellij.testFramework.builders.ModuleFixtureBuilder; import com.intellij.testFramework.fixtures.*; import com.intellij.testFramework.fixtures.impl.ModuleFixtureBuilderImpl; @@ -16,10 +26,17 @@ import com.intellij.testFramework.fixtures.impl.ModuleFixtureImpl; import com.intellij.util.ui.UIUtil; import com.jetbrains.python.PythonModuleTypeBase; import com.jetbrains.python.fixtures.PyProfessionalTestCase; +import com.jetbrains.python.sdk.InvalidSdkException; import com.jetbrains.python.sdk.PythonSdkType; +import com.jetbrains.python.sdk.skeletons.PySkeletonRefresher; +import com.jetbrains.python.sdk.skeletons.SkeletonVersionChecker; +import org.hamcrest.Matchers; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.junit.Assert; +import java.io.File; +import java.io.IOException; import java.util.List; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; @@ -33,28 +50,6 @@ public abstract class PyExecutionFixtureTestTask extends PyTestTask { private int myTimeout = NORMAL_TIMEOUT; protected CodeInsightTestFixture myFixture; - /** - * Creates sdk by SDK path - * @param sdkHome python sdk path - * @return sdk - */ - @NotNull - protected static Sdk getSdk(final String sdkHome) { - Sdk sdk = PythonSdkType.findSdkByPath(sdkHome); - - return sdk != null ? sdk : new ProjectJdkImpl("Python Test Sdk " + sdkHome, PythonSdkType.getInstance()) { - @Override - public String getHomePath() { - return sdkHome; - } - - @Override - public String getVersionString() { - return "Python 2 Mock SDK"; - } - }; - } - public Project getProject() { return myFixture.getProject(); } @@ -87,14 +82,17 @@ public abstract class PyExecutionFixtureTestTask extends PyTestTask { moduleFixtureBuilder.addContentRoot(getTestDataPath() + contentRoot); } } - }); + } + ); myFixture.setUp(); myFixture.setTestDataPath(getTestDataPath()); } - protected List getContentRoots() { return Lists.newArrayList();} + protected List getContentRoots() { + return Lists.newArrayList(); + } protected String getTestDataPath() { return PyProfessionalTestCase.getProfessionalTestDataPath(); @@ -165,6 +163,114 @@ public abstract class PyExecutionFixtureTestTask extends PyTestTask { } } + + /** + * Creates SDK by its path + * + * @param sdkHome path to sdk (probably obtained by {@link #runTestOn(String)}) + * @param sdkCreationType SDK creation strategy (see {@link com.jetbrains.env.python.debug.PyExecutionFixtureTestTask.SdkCreationType} doc) + * @return sdk + */ + @NotNull + protected Sdk createTempSdk(@NotNull final String sdkHome, @NotNull final SdkCreationType sdkCreationType) + throws InvalidSdkException, IOException { + final VirtualFile binary = LocalFileSystem.getInstance().findFileByPath(sdkHome); + Assert.assertNotNull("Interpreter file not found: " + sdkHome, binary); + final Ref ref = Ref.create(); + UsefulTestCase.edt(new Runnable() { + + @Override + public void run() { + final Sdk sdk = SdkConfigurationUtil.setupSdk(new Sdk[0], binary, PythonSdkType.getInstance(), true, null, null); + Assert.assertNotNull(sdk); + ref.set(sdk); + } + }); + final Sdk sdk = ref.get(); + if (sdkCreationType != SdkCreationType.EMPTY_SDK) { + generateTempSkeletonsOrPackages(sdk, sdkCreationType == SdkCreationType.SDK_PACKAGES_AND_SKELETONS); + } + UsefulTestCase.edt(new Runnable() { + @Override + public void run() { + SdkConfigurationUtil.addSdk(sdk); + } + }); + return sdk; + } + + + // TODO: Doc + private void generateTempSkeletonsOrPackages(@NotNull final Sdk sdk, final boolean addSkeletons) throws InvalidSdkException, IOException { + final Project project = myFixture.getProject(); + ModuleRootModificationUtil.setModuleSdk(myFixture.getModule(), sdk); + + UsefulTestCase.edt(new Runnable() { + @Override + public void run() { + ApplicationManager.getApplication().runWriteAction(new Runnable() { + @Override + public void run() { + ProjectRootManager.getInstance(project).setProjectSdk(sdk); + } + }); + } + }); + + + final SdkModificator modificator = sdk.getSdkModificator(); + modificator.removeRoots(OrderRootType.CLASSES); + + for (final String path : PythonSdkType.getSysPathsFromScript(sdk.getHomePath())) { + PythonSdkType.addSdkRoot(modificator, path); + } + if (!addSkeletons) { + UsefulTestCase.edt(new Runnable() { + @Override + public void run() { + modificator.commitChanges(); + } + }); + return; + } + + final File tempDir = FileUtil.createTempDirectory(getClass().getName(), null); + final File skeletonsDir = new File(tempDir, PythonSdkType.SKELETON_DIR_NAME); + FileUtil.createDirectory(skeletonsDir); + final String skeletonsPath = skeletonsDir.toString(); + PythonSdkType.addSdkRoot(modificator, skeletonsPath); + + UsefulTestCase.edt(new Runnable() { + @Override + public void run() { + modificator.commitChanges(); + } + }); + + final SkeletonVersionChecker checker = new SkeletonVersionChecker(0); + final PySkeletonRefresher refresher = new PySkeletonRefresher(project, null, sdk, skeletonsPath, null, null); + final List errors = refresher.regenerateSkeletons(checker, null); + Assert.assertThat("Errors found", errors, Matchers.empty()); + } + + /** + * SDK creation type + */ + public enum SdkCreationType { + /** + * SDK only (no packages nor skeletons) + */ + EMPTY_SDK, + /** + * SDK + installed packages from syspath + */ + SDK_PACKAGES_ONLY, + /** + * SDK + installed packages from syspath + skeletons + */ + SDK_PACKAGES_AND_SKELETONS + } + public interface MyModuleFixtureBuilder extends ModuleFixtureBuilder { } diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java index 9cbbb0b3b94a..e8aceaa20932 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java @@ -31,6 +31,12 @@ public abstract class PyTestTask { public void tearDown() throws Exception { } + /** + * Run test on certain SDK path. + * To create SDK from path, use {@link com.jetbrains.env.python.debug.PyExecutionFixtureTestTask#createTempSdk(String, com.jetbrains.env.python.debug.PyExecutionFixtureTestTask.SdkCreationType)} + * + * @param sdkHome sdk path + */ public abstract void runTestOn(String sdkHome) throws Exception; public void before() throws Exception { diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java index 21617d442d05..52e9cc00670a 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java @@ -12,6 +12,7 @@ import com.jetbrains.python.PyBundle; import com.jetbrains.python.PyNames; import com.jetbrains.python.inspections.PyUnresolvedReferencesInspection; import com.jetbrains.python.psi.PyFile; +import com.jetbrains.python.sdk.InvalidSdkException; import com.jetbrains.python.sdk.PythonSdkType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -69,10 +70,9 @@ class SkeletonTestTask extends PyExecutionFixtureTestTask { @Override - public void runTestOn(@NotNull final String sdkHome) throws IOException { - final Sdk sdk = getSdk(sdkHome); - ModuleRootModificationUtil.setModuleSdk(myFixture.getModule(), sdk); - final File skeletonsPath = new File(PythonSdkType.getSkeletonsPath(PathManager.getSystemPath(), sdkHome)); + public void runTestOn(@NotNull final String sdkHome) throws IOException, InvalidSdkException { + final Sdk sdk = createTempSdk(sdkHome, SdkCreationType.SDK_PACKAGES_ONLY); + final File skeletonsPath = new File(PythonSdkType.getSkeletonsPath(PathManager.getSystemPath(), sdk.getHomePath())); File skeletonFileOrDirectory = new File(skeletonsPath, myModuleNameToBeGenerated); // File with module skeleton // Module may be stored in "moduleName.py" or "moduleName/__init__.py" From 56568eb1d9dd0bf04ec4d483e2602d4b71a98047 Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Sat, 24 May 2014 14:37:44 +0400 Subject: [PATCH 153/183] PyEnv test fix --- .../env/django/DjangoProjectCreationTest.java | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java index abab541fa42a..43ca140255cd 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java @@ -1,5 +1,6 @@ package com.jetbrains.env.django; +import com.google.common.collect.Sets; import com.intellij.execution.ExecutionException; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.vfs.VirtualFile; @@ -15,6 +16,8 @@ import com.jetbrains.python.psi.impl.PyBlockEvaluator; import org.jetbrains.annotations.NotNull; import org.junit.Assert; +import java.util.Set; + /** * Tests projection creation for Django * @@ -24,9 +27,10 @@ public class DjangoProjectCreationTest extends PyEnvTestCase { private static final String ROOT_FOLDER_NAME = "content_root"; private static final String WEB_SITE_NAME = "myWebSite"; + private static final String DJANGO_TAG = "django"; public DjangoProjectCreationTest() { - super("django"); + super(DJANGO_TAG); } @@ -79,5 +83,10 @@ public class DjangoProjectCreationTest extends PyEnvTestCase { // TODO: Finish test } + + @Override + public Set getTags() { + return Sets.newHashSet(DJANGO_TAG); + } } } From 6ebcb84b7c7ea56e672420b0a486adfa9f34ac19 Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Sat, 24 May 2014 19:09:59 +0400 Subject: [PATCH 154/183] PY-11592 Django 1.6: TEMPLATE_DIRS variable in settings.py is not created properly on project creation (only tests are added, NOT FIXED!) --- .../env/django/DjangoProjectCreationTest.java | 22 +++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java index 43ca140255cd..d1555328c89b 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java @@ -13,9 +13,11 @@ import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; import com.jetbrains.python.psi.PyFile; import com.jetbrains.python.psi.PyUtil; import com.jetbrains.python.psi.impl.PyBlockEvaluator; +import org.hamcrest.Matchers; import org.jetbrains.annotations.NotNull; import org.junit.Assert; +import java.util.List; import java.util.Set; /** @@ -72,16 +74,32 @@ public class DjangoProjectCreationTest extends PyEnvTestCase { } }); + final String pathToSettingsPy; + if (DjangoAdmin.isDjangoVersionAtLeast(sdk, "1.4")) { + pathToSettingsPy = ROOT_FOLDER_NAME + '/' + WEB_SITE_NAME + '/' + DjangoNames.SETTINGS_FILE; + } + else { + pathToSettingsPy = ROOT_FOLDER_NAME + '/' + DjangoNames.SETTINGS_FILE; + } + final PyFile settingsPy = - PyUtil.as(myFixture.configureByFile(ROOT_FOLDER_NAME + '/' + WEB_SITE_NAME + '/' + DjangoNames.SETTINGS_FILE), PyFile.class); + PyUtil.as(myFixture.configureByFile(pathToSettingsPy), PyFile.class); Assert.assertNotNull(DjangoNames.SETTINGS_FILE + " not created", settingsPy); Assert.assertEquals("Bad file name for settings", DjangoNames.SETTINGS_FILE, settingsPy.getName()); final PyBlockEvaluator evaluator = new PyBlockEvaluator(); evaluator.evaluate(settingsPy); - Object baseDirPath = evaluator.getValue("TEMPLATE_DIRS"); + // TODO: Temporary skip test for 1.6, because not implemented yet + if (DjangoAdmin.isDjangoVersionAtLeast(sdk, "1.6")) { + return; + } + + final List templateDirs = evaluator.getValueAsStringList(DjangoNames.TEMPLATE_DIRS_SETTING); + Assert.assertThat(String.format("Failed to find %s in %s", DjangoNames.TEMPLATE_DIRS_SETTING, settingsPy), templateDirs, + Matchers.allOf(Matchers.notNullValue(), Matchers.not(Matchers.empty()))); // TODO: Finish test + } @Override From bcf8e99bcc3b8180cdcec035c58aa56b8c194a3a Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Mon, 26 May 2014 21:54:49 +0400 Subject: [PATCH 155/183] PY-11592 Django 1.6: TEMPLATE_DIRS variable in settings.py is not created properly on project creation --- .../env/django/DjangoProjectCreationTest.java | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java index d1555328c89b..2ebb5e44c4a8 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java @@ -49,8 +49,8 @@ public class DjangoProjectCreationTest extends PyEnvTestCase { assert djangoPath != null : "No django found under " + sdkHome; final VirtualFile contentRoot = myFixture.getTempDirFixture().findOrCreateDir(ROOT_FOLDER_NAME); - final String templatesDir = myFixture.getTempDirFixture().findOrCreateDir(ROOT_FOLDER_NAME + "/templates").getCanonicalPath(); - assert templatesDir != null : "Failed to create template dirs"; + final String templateDir = myFixture.getTempDirFixture().findOrCreateDir(ROOT_FOLDER_NAME + "/templates_dir").getCanonicalPath(); + assert templateDir != null : "Failed to create template dirs"; UsefulTestCase.edt(new Runnable() { @Override @@ -62,7 +62,7 @@ public class DjangoProjectCreationTest extends PyEnvTestCase { contentRoot, WEB_SITE_NAME, "myMainApp", - templatesDir, + templateDir, djangoPath, false, false @@ -90,15 +90,11 @@ public class DjangoProjectCreationTest extends PyEnvTestCase { final PyBlockEvaluator evaluator = new PyBlockEvaluator(); evaluator.evaluate(settingsPy); - // TODO: Temporary skip test for 1.6, because not implemented yet - if (DjangoAdmin.isDjangoVersionAtLeast(sdk, "1.6")) { - return; - } - - final List templateDirs = evaluator.getValueAsStringList(DjangoNames.TEMPLATE_DIRS_SETTING); - Assert.assertThat(String.format("Failed to find %s in %s", DjangoNames.TEMPLATE_DIRS_SETTING, settingsPy), templateDirs, + final List templateDirsFromConfig = evaluator.getValueAsStringList(DjangoNames.TEMPLATE_DIRS_SETTING); + Assert.assertThat(String.format("Failed to find %s in %s", DjangoNames.TEMPLATE_DIRS_SETTING, settingsPy), templateDirsFromConfig, Matchers.allOf(Matchers.notNullValue(), Matchers.not(Matchers.empty()))); - // TODO: Finish test + + Assert.assertThat("Wrong template dirs in config", templateDirsFromConfig, Matchers.contains(templateDir)); } From 565142de54b4a9c5269a82a90477042792d35269 Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Tue, 27 May 2014 00:32:01 +0400 Subject: [PATCH 156/183] PY-11592 Django 1.6: TEMPLATE_DIRS variable in settings.py is not created properly on project creation (test fix) --- .../env/django/DjangoProjectCreationTest.java | 24 +++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java index 2ebb5e44c4a8..0cd3b9c4342a 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java @@ -1,5 +1,7 @@ package com.jetbrains.env.django; +import com.google.common.base.Function; +import com.google.common.collect.Collections2; import com.google.common.collect.Sets; import com.intellij.execution.ExecutionException; import com.intellij.openapi.projectRoots.Sdk; @@ -17,6 +19,8 @@ import org.hamcrest.Matchers; import org.jetbrains.annotations.NotNull; import org.junit.Assert; +import java.io.File; +import java.io.IOException; import java.util.List; import java.util.Set; @@ -30,6 +34,7 @@ public class DjangoProjectCreationTest extends PyEnvTestCase { private static final String ROOT_FOLDER_NAME = "content_root"; private static final String WEB_SITE_NAME = "myWebSite"; private static final String DJANGO_TAG = "django"; + private static final MyDjangoProjectCreationTest.Canonicator CANONICATOR = new MyDjangoProjectCreationTest.Canonicator(); public DjangoProjectCreationTest() { super(DJANGO_TAG); @@ -94,13 +99,28 @@ public class DjangoProjectCreationTest extends PyEnvTestCase { Assert.assertThat(String.format("Failed to find %s in %s", DjangoNames.TEMPLATE_DIRS_SETTING, settingsPy), templateDirsFromConfig, Matchers.allOf(Matchers.notNullValue(), Matchers.not(Matchers.empty()))); - Assert.assertThat("Wrong template dirs in config", templateDirsFromConfig, Matchers.contains(templateDir)); - + // Canoncial path is used to prevent ".." + Assert.assertThat("Wrong template dirs in config", Collections2.transform(templateDirsFromConfig, CANONICATOR), + Matchers.contains(CANONICATOR.apply(templateDir))); } @Override public Set getTags() { return Sets.newHashSet(DJANGO_TAG); } + + // Makes canoncial path from any path + private static class Canonicator implements Function { + + @Override + public String apply(final String input) { + try { + return new File(input).getCanonicalPath(); + } + catch (final IOException e) { + throw new AssertionError("Errror with file " + input + " : " + e); + } + } + } } } From 1a98a60f2576a649d78d40b7467ff2434f344233 Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Mon, 9 Jun 2014 22:16:22 +0400 Subject: [PATCH 157/183] PY-13210 Unused star import in Django settings.py --- .../testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java | 2 +- .../com/jetbrains/env/python/dotNet/SkeletonTestTask.java | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index 7072bfa7a8a8..03c73a4d0694 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -13,7 +13,7 @@ import com.jetbrains.env.python.debug.PyTestTask; import com.jetbrains.python.PythonFileType; import com.jetbrains.python.PythonTestUtil; import com.jetbrains.python.documentation.PythonDocumentationProvider; -import com.jetbrains.python.inspections.PyUnresolvedReferencesInspection; +import com.jetbrains.python.inspections.unresolvedReference.PyUnresolvedReferencesInspection; import com.jetbrains.python.psi.*; import com.jetbrains.python.psi.impl.PyBuiltinCache; import com.jetbrains.python.psi.resolve.PythonSdkPathCache; diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java index 52e9cc00670a..5a36e203efdb 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java @@ -3,14 +3,13 @@ package com.jetbrains.env.python.dotNet; import com.google.common.collect.Sets; import com.intellij.openapi.application.PathManager; import com.intellij.openapi.projectRoots.Sdk; -import com.intellij.openapi.roots.ModuleRootModificationUtil; import com.intellij.openapi.util.io.FileUtil; import com.intellij.psi.PsiDocumentManager; import com.intellij.util.ui.UIUtil; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; import com.jetbrains.python.PyBundle; import com.jetbrains.python.PyNames; -import com.jetbrains.python.inspections.PyUnresolvedReferencesInspection; +import com.jetbrains.python.inspections.unresolvedReference.PyUnresolvedReferencesInspection; import com.jetbrains.python.psi.PyFile; import com.jetbrains.python.sdk.InvalidSdkException; import com.jetbrains.python.sdk.PythonSdkType; From 6912bfd6de21598686b36a257898bd560735e7ba Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Sun, 15 Jun 2014 19:58:53 +0400 Subject: [PATCH 158/183] fixed django project creation for python plugin --- .../com/jetbrains/env/django/DjangoProjectCreationTest.java | 1 - 1 file changed, 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java index 0cd3b9c4342a..dcb9cd7d8e5f 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java @@ -67,7 +67,6 @@ public class DjangoProjectCreationTest extends PyEnvTestCase { contentRoot, WEB_SITE_NAME, "myMainApp", - templateDir, djangoPath, false, false From 00ae7e644b89632b32832a3a164255ccf1e37813 Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Sun, 15 Jun 2014 20:11:18 +0400 Subject: [PATCH 159/183] reverted back templates folder setup in django --- .../com/jetbrains/env/django/DjangoProjectCreationTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java index dcb9cd7d8e5f..0cd3b9c4342a 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java @@ -67,6 +67,7 @@ public class DjangoProjectCreationTest extends PyEnvTestCase { contentRoot, WEB_SITE_NAME, "myMainApp", + templateDir, djangoPath, false, false From a0c9a376d57955a9bc3160087d4f42eae42c5dd6 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Mon, 16 Jun 2014 20:19:50 +0200 Subject: [PATCH 160/183] Don't use deprecated method (fixed PY-13172 among others). --- .../testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index eec23e2bf9b7..82c1d81c7016 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -244,7 +244,7 @@ public abstract class PyEnvTestCase extends UsefulTestCase { }); } - return ((PyRemoteSdkAdditionalData)sdk.getSdkAdditionalData()).getRemoteSdkCredentials().getSdkId(); + return ((PyRemoteSdkAdditionalData)sdk.getSdkAdditionalData()).getRemoteSdkCredentials(false).getSdkId(); } catch (Exception e) { throw new RuntimeException(e); From 06c0a02dd5a0e5b2e3ed0126b8f3eb474f96a6d2 Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Mon, 23 Jun 2014 11:10:40 +0400 Subject: [PATCH 161/183] install template language bindings for new projects --- .../testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java index 0c09346f39f6..fec5ea404c25 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java @@ -53,7 +53,7 @@ public class DjangoTestRunnerTest extends PyEnvTestCase { protected void configure(AbstractPythonRunConfiguration config) { String target = "myapp.SimpleTest"; try { - final PyPackage django = ((PyPackageManagerImpl)PyPackageManager.getInstance(config.getSdk())).findPackage("django"); + final PyPackage django = PyPackageManager.getInstance(config.getSdk()).findInstalledPackage("django"); if (django != null) { if (django.matches(PyRequirement.fromStringGuaranteed("django>=1.6a"))) { target = "myapp.tests.SimpleTest"; From 2198b224b0f20afa036b273097ddf48f20fe9b41 Mon Sep 17 00:00:00 2001 From: Sergey Ignatov Date: Thu, 26 Jun 2014 12:13:58 +0400 Subject: [PATCH 162/183] notnull --- .../testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index 82c1d81c7016..338eb16281f3 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -84,7 +84,7 @@ public abstract class PyEnvTestCase extends UsefulTestCase { } @Override - protected void invokeTestRunnable(final Runnable runnable) throws Exception { + protected void invokeTestRunnable(@NotNull final Runnable runnable) throws Exception { if (runInWriteAction()) { UIUtil.invokeAndWaitIfNeeded(new Runnable() { public void run() { From d537bf50d5004eb113fb78ce3a47c17cd60ef0ee Mon Sep 17 00:00:00 2001 From: "Maxim.Mossienko" Date: Thu, 3 Jul 2014 13:20:53 +0200 Subject: [PATCH 163/183] upgrade Guava to v17 --- python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java index 43c920cab9f7..c0c783ed74c5 100644 --- a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java +++ b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java @@ -118,7 +118,7 @@ public class PyTestRemoteSdkProvider { final File dir = new File("/tmp"); File tmpDir = FileUtil.createTempDirectory(dir, "pycharm_helpers_", "_" + Math.abs( - Hashing.md5().hashString(interpreterPath).asInt()), true); + Hashing.md5().hashUnencodedChars(interpreterPath).asInt()), true); return tmpDir.getPath(); } From af3d0e1858a751968aee72f62a7601e8d51094d3 Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Fri, 4 Jul 2014 02:40:48 +0400 Subject: [PATCH 164/183] PY-13180 Pycharm 3.4: Right mouse click on selected text inside unicode string hangs out IDE interface for 20-30 seconds: Performance fix #3 --- .../com/jetbrains/env/django/DjangoProjectCreationTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java index 0cd3b9c4342a..35786cb96b8a 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java @@ -14,7 +14,7 @@ import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; import com.jetbrains.python.psi.PyFile; import com.jetbrains.python.psi.PyUtil; -import com.jetbrains.python.psi.impl.PyBlockEvaluator; +import com.jetbrains.python.psi.impl.blockEvaluator.PyBlockEvaluator; import org.hamcrest.Matchers; import org.jetbrains.annotations.NotNull; import org.junit.Assert; From 4f85691dedf28e5155b39d310b29d0f9cca46dad Mon Sep 17 00:00:00 2001 From: Roman Shevchenko Date: Fri, 4 Jul 2014 12:35:21 +0200 Subject: [PATCH 165/183] Cleanup (duplicate dropped) --- .../testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index 338eb16281f3..a0c85778d2c5 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -311,7 +311,7 @@ public abstract class PyEnvTestCase extends UsefulTestCase { if (parent.isFile()) { parent = parent.getParentFile(); } - envTags = com.jetbrains.appengine.util.FileUtil.loadLines(new File(parent, TAGS_FILE)); + envTags = com.intellij.openapi.util.io.FileUtil.loadLines(new File(parent, TAGS_FILE)); } catch (IOException e) { envTags = Lists.newArrayList(); From b4da3884c057a6ecd0c5feb5f16d91fd73a56664 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Mon, 7 Jul 2014 15:06:29 +0200 Subject: [PATCH 166/183] Report an error when there is no directory. --- .../com/jetbrains/env/python/debug/PyEnvTestCase.java | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index a0c85778d2c5..ffe01b81ef94 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -295,8 +295,13 @@ public abstract class PyEnvTestCase extends UsefulTestCase { String[] roots = envs.split(File.pathSeparator); for (String root : roots) { File virtualEnvRoot = new File(root); - for (File f : virtualEnvRoot.listFiles()) { - result.add(f.getAbsolutePath()); + File[] virtualenvs = virtualEnvRoot.listFiles(); + if (virtualenvs != null) { + for (File f : virtualenvs) { + result.add(f.getAbsolutePath()); + } + } else { + LOG.error(root + " is not a directory of doesn't exist"); } } From e6fa78115fc64fa486e467e62ce97d27dbeb701c Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Mon, 7 Jul 2014 21:44:24 +0200 Subject: [PATCH 167/183] System property to run remote and don't run local env tests. --- .../jetbrains/env/PyTestRemoteSdkProvider.java | 3 ++- .../env/python/debug/PyEnvTestCase.java | 18 ++++++++++++------ 2 files changed, 14 insertions(+), 7 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java index c0c783ed74c5..6dfcc5d6bbcf 100644 --- a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java +++ b/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java @@ -15,7 +15,8 @@ import com.intellij.remote.RemoteSdkException; import com.intellij.testFramework.UsefulTestCase; import com.intellij.util.ui.UIUtil; import com.jetbrains.env.python.debug.PyTestTask; -import com.jetbrains.python.remote.*; +import com.jetbrains.python.remote.PyRemoteInterpreterManagerImpl; +import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; import org.jetbrains.annotations.NotNull; import java.io.File; diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index ffe01b81ef94..9df6a77a038b 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -38,6 +38,11 @@ public abstract class PyEnvTestCase extends UsefulTestCase { protected static final boolean IS_ENV_CONFIGURATION = System.getProperty("pycharm.env") != null; + + public static final boolean SHOULD_RUN_REMOTE = System.getProperty("pycharm.run_remote") != null; + + public static final boolean DONT_RUN_LOCAL = System.getProperty("pycharm.dont_run_local") != null; + /** * Tags that should exist between all tags, available on all interpreters for test to run. * See {@link #PyEnvTestCase(String...)} @@ -130,15 +135,16 @@ public abstract class PyEnvTestCase extends UsefulTestCase { return; } + if (!DONT_RUN_LOCAL) { + TaskRunner taskRunner = new TaskRunner(roots); - TaskRunner taskRunner = new TaskRunner(roots); + taskRunner.runTask(testTask, testName); + } - taskRunner.runTask(testTask, testName); - - if (PyTestRemoteSdkProvider.shouldRunRemoteSdk(testTask)) { + if (SHOULD_RUN_REMOTE && PyTestRemoteSdkProvider.shouldRunRemoteSdk(testTask)) { if (PyTestRemoteSdkProvider.canRunRemoteSdk()) { - taskRunner = new RemoteTaskRunner(roots); - taskRunner.runTask(testTask, testName); + TaskRunner remoteRunner = new RemoteTaskRunner(roots); + remoteRunner.runTask(testTask, testName); } else { if (PyTestRemoteSdkProvider.shouldFailWhenCantRunRemote()) { From da8bc5e85f0638b6e734ba15b495926fa2939640 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 8 Jul 2014 15:14:15 +0200 Subject: [PATCH 168/183] read actions to fix tests. --- .../env/python/IPythonConsoleTest.java | 27 +++++++++++----- .../env/python/PythonSkeletonsTest.java | 31 +++++++++++++------ 2 files changed, 41 insertions(+), 17 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java index 3f12bc8b6c29..a1e6d77601e4 100644 --- a/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java @@ -3,6 +3,7 @@ package com.jetbrains.env.python; import com.google.common.base.Function; import com.google.common.collect.Collections2; import com.google.common.collect.ImmutableSet; +import com.intellij.openapi.application.ApplicationManager; import com.intellij.psi.PsiDocumentManager; import com.intellij.psi.PsiErrorElement; import com.intellij.psi.PsiFile; @@ -38,9 +39,15 @@ public class IPythonConsoleTest extends PyEnvTestCase { public void testing() throws Exception { waitForReady(); addTextToEditor("sys?"); - PsiFile psi = - PsiDocumentManager.getInstance(getProject()).getPsiFile(getConsoleView().getLanguageConsole().getConsoleEditor().getDocument()); - Assert.assertThat("No errors expected", getErrors(psi), Matchers.empty()); + ApplicationManager.getApplication().runReadAction(new Runnable() { + @Override + public void run() { + PsiFile psi = + PsiDocumentManager.getInstance(getProject()) + .getPsiFile(getConsoleView().getLanguageConsole().getConsoleEditor().getDocument()); + Assert.assertThat("No errors expected", getErrors(psi), Matchers.empty()); + } + }); } }); } @@ -65,10 +72,16 @@ public class IPythonConsoleTest extends PyEnvTestCase { public void testing() throws Exception { waitForReady(); addTextToEditor("sys?"); - PsiFile psi = - PsiDocumentManager.getInstance(getProject()).getPsiFile(getConsoleView().getLanguageConsole().getConsoleEditor().getDocument()); - //TreeUtil.ensureParsed(psi.getNode()); - assertTrue(PsiTreeUtil.hasErrorElements(psi)); + ApplicationManager.getApplication().runReadAction(new Runnable() { + @Override + public void run() { + PsiFile psi = + PsiDocumentManager.getInstance(getProject()).getPsiFile(getConsoleView().getLanguageConsole().getConsoleEditor().getDocument()); + //TreeUtil.ensureParsed(psi.getNode()); + assertTrue(PsiTreeUtil.hasErrorElements(psi)); + } + }); + } @Override diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index 03c73a4d0694..dbfce666b194 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -1,6 +1,7 @@ package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; +import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.module.Module; import com.intellij.openapi.module.ModuleUtil; import com.intellij.openapi.project.Project; @@ -121,9 +122,14 @@ public class PythonSkeletonsTest extends PyEnvTestCase { "expr = slice(1, 2).start\n"); final PyExpression expr = myFixture.findElementByText("expr", PyExpression.class); final TypeEvalContext context = TypeEvalContext.codeAnalysis(myFixture.getFile()); - final PyType type = context.getType(expr); - final String actualType = PythonDocumentationProvider.getTypeName(type, context); - assertEquals("int", actualType); + ApplicationManager.getApplication().runReadAction(new Runnable() { + @Override + public void run() { + final PyType type = context.getType(expr); + final String actualType = PythonDocumentationProvider.getTypeName(type, context); + assertEquals("int", actualType); + } + }); } }); } @@ -141,13 +147,18 @@ public class PythonSkeletonsTest extends PyEnvTestCase { final Project project = myFixture.getProject(); final PyFile builtins = PyBuiltinCache.getBuiltinsForSdk(project, sdk); assertNotNull(builtins); - final PyClass cls = builtins.findTopLevelClass("int"); - assertNotNull(cls); - final Property prop = cls.findProperty("real", true); - assertNotNull(prop); - assertIsNotNull(prop.getGetter()); - assertIsNotNull(prop.getSetter()); - assertIsNotNull(prop.getDeleter()); + ApplicationManager.getApplication().runReadAction(new Runnable() { + @Override + public void run() { + final PyClass cls = builtins.findTopLevelClass("int"); + assertNotNull(cls); + final Property prop = cls.findProperty("real", true); + assertNotNull(prop); + assertIsNotNull(prop.getGetter()); + assertIsNotNull(prop.getSetter()); + assertIsNotNull(prop.getDeleter()); + } + }); } private void assertIsNotNull(Maybe accessor) { From 94a95a432451ee6d7bacd31a839f35df27bf6354 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 8 Jul 2014 15:26:24 +0200 Subject: [PATCH 169/183] Props renamed. --- .../com/jetbrains/env/python/debug/PyEnvTestCase.java | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java index 9df6a77a038b..e82758794e48 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java @@ -9,6 +9,7 @@ import com.intellij.openapi.projectRoots.ProjectJdkTable; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.util.text.StringUtil; import com.intellij.testFramework.UsefulTestCase; +import com.intellij.util.SystemProperties; import com.intellij.util.ui.UIUtil; import com.jetbrains.env.PyTestRemoteSdkProvider; import com.jetbrains.python.fixtures.PyTestCase; @@ -39,9 +40,9 @@ public abstract class PyEnvTestCase extends UsefulTestCase { protected static final boolean IS_ENV_CONFIGURATION = System.getProperty("pycharm.env") != null; - public static final boolean SHOULD_RUN_REMOTE = System.getProperty("pycharm.run_remote") != null; + public static final boolean RUN_REMOTE = SystemProperties.getBooleanProperty("pycharm.run_remote", false); - public static final boolean DONT_RUN_LOCAL = System.getProperty("pycharm.dont_run_local") != null; + public static final boolean RUN_LOCAL = SystemProperties.getBooleanProperty("pycharm.run_local", true); /** * Tags that should exist between all tags, available on all interpreters for test to run. @@ -135,13 +136,13 @@ public abstract class PyEnvTestCase extends UsefulTestCase { return; } - if (!DONT_RUN_LOCAL) { + if (RUN_LOCAL) { TaskRunner taskRunner = new TaskRunner(roots); taskRunner.runTask(testTask, testName); } - if (SHOULD_RUN_REMOTE && PyTestRemoteSdkProvider.shouldRunRemoteSdk(testTask)) { + if (RUN_REMOTE && PyTestRemoteSdkProvider.shouldRunRemoteSdk(testTask)) { if (PyTestRemoteSdkProvider.canRunRemoteSdk()) { TaskRunner remoteRunner = new RemoteTaskRunner(roots); remoteRunner.runTask(testTask, testName); From 38b2bc90fe9b4c5de628da104f926c84ba447933 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 8 Jul 2014 21:29:59 +0200 Subject: [PATCH 170/183] Added read and write actions to fix tests. --- .../env/django/DjangoManageTestTask.java | 17 ++++++- .../env/django/DjangoProjectCreationTest.java | 51 ++++++++++++------- 2 files changed, 49 insertions(+), 19 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java index 66ad2ba69fcf..456ea4bec223 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java @@ -13,6 +13,7 @@ import com.intellij.execution.runners.ExecutionEnvironment; import com.intellij.execution.runners.ProgramRunner; import com.intellij.execution.ui.ExecutionConsole; import com.intellij.execution.ui.RunContentDescriptor; +import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.application.Result; import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.module.Module; @@ -119,7 +120,18 @@ public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { runProcess(sdkHome, s); try { - testing(); + ApplicationManager.getApplication().runReadAction(new Runnable() { + @Override + public void run() { + try { + testing(); + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + }); + Assert.assertTrue(s.waitFor(60000)); XDebuggerTestUtil.waitForSwing(); after(); @@ -169,11 +181,12 @@ public abstract class DjangoManageTestTask extends PyExecutionFixtureTestTask { config.addContentRoots(DjangoTestsConfigurationType.getInstance().getDjangoTestsFactory().equals(factory)); config.setSdkHome(sdkHome); config.setWorkingDirectory(getWorkingFolder()); - configure(config); new WriteAction() { @Override protected void run(Result result) throws Throwable { + configure(config); + RunManagerEx.getInstanceEx(project).addConfiguration(settings, false); RunManagerEx.getInstanceEx(project).setSelectedConfiguration(settings); Assert.assertSame(settings, RunManagerEx.getInstanceEx(project).getSelectedConfiguration()); diff --git a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java index 35786cb96b8a..9c1ef6e175ea 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java @@ -4,6 +4,9 @@ import com.google.common.base.Function; import com.google.common.collect.Collections2; import com.google.common.collect.Sets; import com.intellij.execution.ExecutionException; +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.application.Result; +import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.testFramework.UsefulTestCase; @@ -60,22 +63,28 @@ public class DjangoProjectCreationTest extends PyEnvTestCase { UsefulTestCase.edt(new Runnable() { @Override public void run() { - try { - DjangoAdmin.createProject( - myFixture.getProject(), - sdk, - contentRoot, - WEB_SITE_NAME, - "myMainApp", - templateDir, - djangoPath, - false, - false - ); - } - catch (final ExecutionException ex) { - Assert.fail(ex.toString()); - } + + new WriteAction() { + @Override + protected void run(@NotNull Result result) throws Throwable { + try { + DjangoAdmin.createProject( + myFixture.getProject(), + sdk, + contentRoot, + WEB_SITE_NAME, + "myMainApp", + templateDir, + djangoPath, + false, + false + ); + } + catch (final ExecutionException ex) { + Assert.fail(ex.toString()); + } + } + }.execute(); } }); @@ -92,8 +101,16 @@ public class DjangoProjectCreationTest extends PyEnvTestCase { Assert.assertNotNull(DjangoNames.SETTINGS_FILE + " not created", settingsPy); Assert.assertEquals("Bad file name for settings", DjangoNames.SETTINGS_FILE, settingsPy.getName()); + final PyBlockEvaluator evaluator = new PyBlockEvaluator(); - evaluator.evaluate(settingsPy); + + ApplicationManager.getApplication().runReadAction(new Runnable() { + @Override + public void run() { + evaluator.evaluate(settingsPy); + } + }); + final List templateDirsFromConfig = evaluator.getValueAsStringList(DjangoNames.TEMPLATE_DIRS_SETTING); Assert.assertThat(String.format("Failed to find %s in %s", DjangoNames.TEMPLATE_DIRS_SETTING, settingsPy), templateDirsFromConfig, From 9d2355259ef4f813a19ba74bb1997db10958664c Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Wed, 9 Jul 2014 14:13:42 +0200 Subject: [PATCH 171/183] Test simplyfied. --- .../jetbrains/env/django/DjangoTemplateDebuggerTest.java | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java index c6a41f6d03f5..1a867ce011c1 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java @@ -130,27 +130,22 @@ public class DjangoTemplateDebuggerTest extends PyEnvTestCase { waitForPause(); eval("x").hasValue("1"); - eval("name").hasValue("'TemplateDebugging'"); - - setVal("name", "'TemplateDjangoDebugging'"); resume(); waitForPause(); eval("x").hasValue("2"); - eval("name").hasValue("'TemplateDjangoDebugging'"); resume(); waitForPause(); eval("x").hasValue("3"); - eval("name").hasValue("'TemplateDjangoDebugging'"); resume(); - page.get().contains("templatedjangodebugging"); + page.get().contains("templatedebugging"); } }); } From 691855b8aa57647a15aee3ba2b12fb728eb29f9b Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 10 Jul 2014 15:27:28 +0200 Subject: [PATCH 172/183] Use long timeout for some of Django template tests. --- .../jetbrains/env/django/DjangoTemplateDebuggerTest.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java index 1a867ce011c1..868e0a33060e 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java @@ -261,6 +261,8 @@ public class DjangoTemplateDebuggerTest extends PyEnvTestCase { toggleBreakpoint(file, 6); XDebuggerTestUtil.setBreakpointLogExpression(getProject(), 6, "'x = %d'%x"); + + useLongTimeout(); } @Override @@ -335,6 +337,12 @@ public class DjangoTemplateDebuggerTest extends PyEnvTestCase { public void testBreakpointStopAndEvalInAutoReloadMode() throws IOException { final int[] ports = findFreePorts(4); BreakpointStopAndEvalTask testTask = new BreakpointStopAndEvalTask("/djangoDebug", "manage.py", "runserver ", ports[3]) { + @Override + public void before() throws Exception { + super.before(); + useLongTimeout(); + } + @Override public Set getTags() { Set tags = Sets.newHashSet(super.getTags()); From 4580626ab835d880fec0749e48d0ee9bc0775726 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 10 Jul 2014 15:37:06 +0200 Subject: [PATCH 173/183] Read action. --- .../env/python/dotNet/PyIronPythonTest.java | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java index ee41db732c96..254f8ade4f86 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java @@ -1,7 +1,10 @@ package com.jetbrains.env.python.dotNet; +import com.intellij.openapi.application.ReadAction; +import com.intellij.openapi.application.Result; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.python.psi.PyFile; +import org.jetbrains.annotations.NotNull; import org.junit.Assert; /** @@ -93,9 +96,15 @@ public class PyIronPythonTest extends PyEnvTestCase { ); runPythonTest(task); final PyFile skeleton = task.getGeneratedSkeleton(); - Assert.assertNotNull("System.Web does not contain class AspNetHostingPermissionLevel. Error generating stub? It has classes " + - skeleton.getTopLevelClasses(), - skeleton.findTopLevelClass("AspNetHostingPermissionLevel")); + new ReadAction() { + @Override + protected void run(@NotNull Result result) throws Throwable { + Assert.assertNotNull("System.Web does not contain class AspNetHostingPermissionLevel. Error generating stub? It has classes " + + skeleton.getTopLevelClasses(), + skeleton.findTopLevelClass("AspNetHostingPermissionLevel")); + } + }.execute(); + } /** From 2652720a7732cfc193e4613e62df618e1ee625a3 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 10 Jul 2014 16:38:24 +0200 Subject: [PATCH 174/183] Set val in templates commented out. --- .../com/jetbrains/env/django/DjangoTemplateDebuggerTest.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java index 868e0a33060e..66a3b3233c1b 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java @@ -64,6 +64,7 @@ public class DjangoTemplateDebuggerTest extends PyEnvTestCase { } } + /* TODO: uncomment after fixing http://youtrack.jetbrains.com/issue/PY-13465 public void testSetVal() throws IOException { //setShouldPrintOutput(true); final int[] ports = findFreePorts(2); @@ -111,6 +112,7 @@ public class DjangoTemplateDebuggerTest extends PyEnvTestCase { }); } + */ public void testVariableDoesNotExistExceptionBreak() throws IOException { //setShouldPrintOutput(true); From 99870c3b5e193f554434f147cfafb63a6a3e2619 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 10 Jul 2014 16:57:47 +0200 Subject: [PATCH 175/183] Don't run debug eggs test on Jython. --- .../com/jetbrains/env/python/PythonDebuggerTest.java | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index b49103c5d5e6..16f07cb4f72b 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -4,10 +4,7 @@ import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; import com.google.common.collect.Sets; import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; -import com.intellij.xdebugger.XDebuggerManager; import com.intellij.xdebugger.XDebuggerTestUtil; -import com.intellij.xdebugger.breakpoints.XBreakpoint; -import com.intellij.xdebugger.breakpoints.XBreakpointManager; import com.jetbrains.env.python.debug.PyDebuggerTask; import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.ut.PyUnitTestTask; @@ -443,6 +440,11 @@ public class PythonDebuggerTest extends PyEnvTestCase { eval("ret").hasValue("16"); resume(); } + + @Override + public Set getTags() { + return ImmutableSet.of("-jython"); //TODO: fix that for Jython if anybody needs it + } }); } From b051fce6cd3967d422f726eb5c1ad8c2bc9d49e4 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Thu, 10 Jul 2014 17:08:28 +0200 Subject: [PATCH 176/183] Use timeout in waitForOutput --- .../com/jetbrains/env/python/debug/PyBaseDebuggerTask.java | 6 +++--- .../env/python/debug/PyExecutionFixtureTestTask.java | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java index 2256aca12ae6..3d6ece5583d3 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java @@ -198,13 +198,13 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { } public void waitForOutput(String ... string) throws InterruptedException { - int count = 0; + long started = System.currentTimeMillis(); + while (!containsOneOf(output(), string)) { - if (count > 10) { + if (System.currentTimeMillis() - started > myTimeout) { Assert.fail("None of '" + StringUtil.join(string, ", ") + "'" + " is not present in output.\n" + output()); } Thread.sleep(2000); - count++; } } diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java index cb44c54072e2..087c025fe6cc 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java @@ -47,7 +47,7 @@ import java.util.concurrent.TimeUnit; public abstract class PyExecutionFixtureTestTask extends PyTestTask { public static final int NORMAL_TIMEOUT = 30000; public static final int LONG_TIMEOUT = 120000; - private int myTimeout = NORMAL_TIMEOUT; + protected int myTimeout = NORMAL_TIMEOUT; protected CodeInsightTestFixture myFixture; public Project getProject() { From 5d70fc6a589ae6f7627bda1c8d1d8824377a1e3b Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Fri, 11 Jul 2014 01:46:43 +0400 Subject: [PATCH 177/183] Performance tests added --- .../env/django/DjangoManageTestTask.java | 1 + .../env/django/DjangoProjectCreationTest.java | 1 + .../PyPackageRequirementsInspectionTest.java | 1 + .../jetbrains/env/python/PyPackagingTest.java | 1 + .../env/python/PythonSkeletonsTest.java | 1 + .../env/python/console/PyConsoleTask.java | 1 + .../debug/PyExecutionFixtureTestTask.java | 115 +----------------- .../env/python/debug/PyTestTask.java | 2 +- .../env/python/dotNet/SkeletonTestTask.java | 1 + 9 files changed, 14 insertions(+), 110 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java index 456ea4bec223..7de1dfe4ef9a 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java @@ -34,6 +34,7 @@ import com.jetbrains.python.PythonHelpersLocator; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import com.jetbrains.python.run.PythonTracebackFilter; import com.jetbrains.python.sdk.InvalidSdkException; +import com.jetbrains.python.sdkTools.SdkCreationType; import com.jetbrains.python.templateLanguages.TemplatesService; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; diff --git a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java index 9c1ef6e175ea..135aff0cffde 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java @@ -18,6 +18,7 @@ import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; import com.jetbrains.python.psi.PyFile; import com.jetbrains.python.psi.PyUtil; import com.jetbrains.python.psi.impl.blockEvaluator.PyBlockEvaluator; +import com.jetbrains.python.sdkTools.SdkCreationType; import org.hamcrest.Matchers; import org.jetbrains.annotations.NotNull; import org.junit.Assert; diff --git a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java index 9f82a1830e63..ac6ae2625091 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java @@ -10,6 +10,7 @@ import com.jetbrains.env.python.debug.PyEnvTestCase; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; import com.jetbrains.python.PythonTestUtil; import com.jetbrains.python.inspections.PyPackageRequirementsInspection; +import com.jetbrains.python.sdkTools.SdkCreationType; import org.jetbrains.annotations.NotNull; import java.util.Set; diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index f0c16c870cb4..a14fa6aa879d 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -13,6 +13,7 @@ import com.jetbrains.python.psi.LanguageLevel; import com.jetbrains.python.sdk.PythonSdkType; import com.jetbrains.python.sdk.flavors.PythonSdkFlavor; import com.jetbrains.python.sdk.flavors.VirtualEnvSdkFlavor; +import com.jetbrains.python.sdkTools.SdkCreationType; import org.jetbrains.annotations.Nullable; import java.io.File; diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index dbfce666b194..f836b1039879 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -23,6 +23,7 @@ import com.jetbrains.python.psi.types.TypeEvalContext; import com.jetbrains.python.sdk.PythonSdkType; import com.jetbrains.python.sdk.skeletons.PySkeletonRefresher; import com.jetbrains.python.sdk.skeletons.SkeletonVersionChecker; +import com.jetbrains.python.sdkTools.SdkCreationType; import com.jetbrains.python.toolbox.Maybe; import org.jetbrains.annotations.NotNull; diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 02500c6d6122..c2667162f283 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -18,6 +18,7 @@ import com.jetbrains.python.console.*; import com.jetbrains.python.console.pydev.ConsoleCommunicationListener; import com.jetbrains.python.debugger.PyDebugValue; import com.jetbrains.python.debugger.PyDebuggerException; +import com.jetbrains.python.sdkTools.SdkCreationType; import org.jetbrains.annotations.NotNull; import org.junit.Assert; diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java index 087c025fe6cc..8382dd2b24a8 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java @@ -3,22 +3,13 @@ package com.jetbrains.env.python.debug; import com.google.common.collect.Lists; import com.intellij.execution.process.ProcessHandler; import com.intellij.ide.util.projectWizard.EmptyModuleBuilder; -import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.module.ModuleType; import com.intellij.openapi.module.ModuleTypeManager; import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; -import com.intellij.openapi.projectRoots.SdkModificator; -import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil; -import com.intellij.openapi.roots.ModuleRootModificationUtil; -import com.intellij.openapi.roots.OrderRootType; -import com.intellij.openapi.roots.ProjectRootManager; -import com.intellij.openapi.util.Ref; -import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.testFramework.LightProjectDescriptor; -import com.intellij.testFramework.UsefulTestCase; import com.intellij.testFramework.builders.ModuleFixtureBuilder; import com.intellij.testFramework.fixtures.*; import com.intellij.testFramework.fixtures.impl.ModuleFixtureBuilderImpl; @@ -27,15 +18,12 @@ import com.intellij.util.ui.UIUtil; import com.jetbrains.python.PythonModuleTypeBase; import com.jetbrains.python.fixtures.PyProfessionalTestCase; import com.jetbrains.python.sdk.InvalidSdkException; -import com.jetbrains.python.sdk.PythonSdkType; -import com.jetbrains.python.sdk.skeletons.PySkeletonRefresher; -import com.jetbrains.python.sdk.skeletons.SkeletonVersionChecker; -import org.hamcrest.Matchers; +import com.jetbrains.python.sdkTools.PyTestSdkTools; +import com.jetbrains.python.sdkTools.SdkCreationType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.junit.Assert; -import java.io.File; import java.io.IOException; import java.util.List; import java.util.concurrent.Semaphore; @@ -168,109 +156,18 @@ public abstract class PyExecutionFixtureTestTask extends PyTestTask { * Creates SDK by its path * * @param sdkHome path to sdk (probably obtained by {@link #runTestOn(String)}) - * @param sdkCreationType SDK creation strategy (see {@link com.jetbrains.env.python.debug.PyExecutionFixtureTestTask.SdkCreationType} doc) + * @param sdkCreationType SDK creation strategy (see {@link com.jetbrains.python.sdkTools.SdkCreationType} doc) * @return sdk */ @NotNull protected Sdk createTempSdk(@NotNull final String sdkHome, @NotNull final SdkCreationType sdkCreationType) throws InvalidSdkException, IOException { - final VirtualFile binary = LocalFileSystem.getInstance().findFileByPath(sdkHome); - Assert.assertNotNull("Interpreter file not found: " + sdkHome, binary); - final Ref ref = Ref.create(); - UsefulTestCase.edt(new Runnable() { - - @Override - public void run() { - final Sdk sdk = SdkConfigurationUtil.setupSdk(new Sdk[0], binary, PythonSdkType.getInstance(), true, null, null); - Assert.assertNotNull(sdk); - ref.set(sdk); - } - }); - final Sdk sdk = ref.get(); - if (sdkCreationType != SdkCreationType.EMPTY_SDK) { - generateTempSkeletonsOrPackages(sdk, sdkCreationType == SdkCreationType.SDK_PACKAGES_AND_SKELETONS); - } - UsefulTestCase.edt(new Runnable() { - @Override - public void run() { - SdkConfigurationUtil.addSdk(sdk); - } - }); - return sdk; + final VirtualFile sdkHomeFile = LocalFileSystem.getInstance().findFileByPath(sdkHome); + Assert.assertNotNull("Interpreter file not found: " + sdkHome, sdkHomeFile); + return PyTestSdkTools.createTempSdk(sdkHomeFile, sdkCreationType, myFixture.getModule()); } - // TODO: Doc - private void generateTempSkeletonsOrPackages(@NotNull final Sdk sdk, final boolean addSkeletons) throws InvalidSdkException, IOException { - final Project project = myFixture.getProject(); - ModuleRootModificationUtil.setModuleSdk(myFixture.getModule(), sdk); - - UsefulTestCase.edt(new Runnable() { - @Override - public void run() { - ApplicationManager.getApplication().runWriteAction(new Runnable() { - @Override - public void run() { - ProjectRootManager.getInstance(project).setProjectSdk(sdk); - } - }); - } - }); - - - final SdkModificator modificator = sdk.getSdkModificator(); - modificator.removeRoots(OrderRootType.CLASSES); - - for (final String path : PythonSdkType.getSysPathsFromScript(sdk.getHomePath())) { - PythonSdkType.addSdkRoot(modificator, path); - } - if (!addSkeletons) { - UsefulTestCase.edt(new Runnable() { - @Override - public void run() { - modificator.commitChanges(); - } - }); - return; - } - - final File tempDir = FileUtil.createTempDirectory(getClass().getName(), null); - final File skeletonsDir = new File(tempDir, PythonSdkType.SKELETON_DIR_NAME); - FileUtil.createDirectory(skeletonsDir); - final String skeletonsPath = skeletonsDir.toString(); - PythonSdkType.addSdkRoot(modificator, skeletonsPath); - - UsefulTestCase.edt(new Runnable() { - @Override - public void run() { - modificator.commitChanges(); - } - }); - - final SkeletonVersionChecker checker = new SkeletonVersionChecker(0); - final PySkeletonRefresher refresher = new PySkeletonRefresher(project, null, sdk, skeletonsPath, null, null); - final List errors = refresher.regenerateSkeletons(checker, null); - Assert.assertThat("Errors found", errors, Matchers.empty()); - } - - /** - * SDK creation type - */ - public enum SdkCreationType { - /** - * SDK only (no packages nor skeletons) - */ - EMPTY_SDK, - /** - * SDK + installed packages from syspath - */ - SDK_PACKAGES_ONLY, - /** - * SDK + installed packages from syspath + skeletons - */ - SDK_PACKAGES_AND_SKELETONS - } - public interface MyModuleFixtureBuilder extends ModuleFixtureBuilder { } diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java index e8aceaa20932..239f57002372 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java @@ -33,7 +33,7 @@ public abstract class PyTestTask { /** * Run test on certain SDK path. - * To create SDK from path, use {@link com.jetbrains.env.python.debug.PyExecutionFixtureTestTask#createTempSdk(String, com.jetbrains.env.python.debug.PyExecutionFixtureTestTask.SdkCreationType)} + * To create SDK from path, use {@link com.jetbrains.env.python.debug.PyExecutionFixtureTestTask#createTempSdk(String, com.jetbrains.python.sdkTools.SdkCreationType)} * * @param sdkHome sdk path */ diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java index 5a36e203efdb..1c2ac1cee357 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java @@ -13,6 +13,7 @@ import com.jetbrains.python.inspections.unresolvedReference.PyUnresolvedReferenc import com.jetbrains.python.psi.PyFile; import com.jetbrains.python.sdk.InvalidSdkException; import com.jetbrains.python.sdk.PythonSdkType; +import com.jetbrains.python.sdkTools.SdkCreationType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.junit.Assert; From bd149e480edf324ec164fdf1130323553050ac3c Mon Sep 17 00:00:00 2001 From: Andrey Vlasovskikh Date: Fri, 11 Jul 2014 18:00:00 +0400 Subject: [PATCH 178/183] Force VFS refresh in PythonSkeletonsTest.testFakeNamedTuple --- .../testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index f836b1039879..e6a5fd82558d 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -6,6 +6,7 @@ import com.intellij.openapi.module.Module; import com.intellij.openapi.module.ModuleUtil; import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiFile; import com.jetbrains.env.python.debug.PyEnvTestCase; @@ -101,6 +102,9 @@ public class PythonSkeletonsTest extends PyEnvTestCase { return; } + // XXX: A workaround for invalidating VFS cache with the test file copied to our temp directory + LocalFileSystem.getInstance().refresh(false); + // Run inspections on code that uses named tuples myFixture.configureByFile(getTestName(false) + ".py"); myFixture.enableInspections(PyUnresolvedReferencesInspection.class); From f672b29d4a1cc211054f69595a3cc86da34eddbb Mon Sep 17 00:00:00 2001 From: "Ilya.Kazakevich" Date: Sat, 12 Jul 2014 00:51:23 +0400 Subject: [PATCH 179/183] Win tests should be more stable now --- .../env/python/dotNet/SkeletonTestTask.java | 44 +++++++------------ 1 file changed, 16 insertions(+), 28 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java index 1c2ac1cee357..0b197921cc3e 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java @@ -1,7 +1,12 @@ package com.jetbrains.env.python.dotNet; import com.google.common.collect.Sets; +import com.intellij.codeInsight.intention.IntentionAction; +import com.intellij.codeInspection.LocalQuickFix; +import com.intellij.codeInspection.ex.QuickFixWrapper; import com.intellij.openapi.application.PathManager; +import com.intellij.openapi.progress.Task; +import com.intellij.openapi.progress.util.AbstractProgressIndicatorBase; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.util.io.FileUtil; import com.intellij.psi.PsiDocumentManager; @@ -9,11 +14,13 @@ import com.intellij.util.ui.UIUtil; import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; import com.jetbrains.python.PyBundle; import com.jetbrains.python.PyNames; +import com.jetbrains.python.inspections.quickfix.GenerateBinaryStubsFix; import com.jetbrains.python.inspections.unresolvedReference.PyUnresolvedReferencesInspection; import com.jetbrains.python.psi.PyFile; import com.jetbrains.python.sdk.InvalidSdkException; import com.jetbrains.python.sdk.PythonSdkType; import com.jetbrains.python.sdkTools.SdkCreationType; +import org.hamcrest.Matchers; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.junit.Assert; @@ -86,7 +93,7 @@ class SkeletonTestTask extends PyExecutionFixtureTestTask { final File skeletonFile = skeletonFileOrDirectory; if (skeletonFile.exists()) { // To make sure we do not reuse it - skeletonFile.delete(); + assert skeletonFile.delete() : "Failed to delete file " + skeletonFile; } myFixture.copyFileToProject("dotNet/" + mySourceFileToRunGenerationOn, mySourceFileToRunGenerationOn); // File that uses CLR library @@ -101,8 +108,14 @@ class SkeletonTestTask extends PyExecutionFixtureTestTask { public void run() { PsiDocumentManager.getInstance(myFixture.getProject()).commitAllDocuments(); final String intentionName = PyBundle.message("sdk.gen.stubs.for.binary.modules", myUseQuickFixWithThisModuleOnly); - myFixture.findSingleIntention(intentionName).invoke(myFixture.getProject(), myFixture.getEditor(), myFixture.getFile()); - waitForSkeleton(skeletonFile); + final IntentionAction intention = myFixture.findSingleIntention(intentionName); + Assert.assertNotNull("No intention found to generate skeletons!", intention); + Assert.assertThat("Intention should be quick fix to run", intention, Matchers.instanceOf(QuickFixWrapper.class)); + final LocalQuickFix quickFix = ((QuickFixWrapper)intention).getFix(); + Assert.assertThat("Quick fix should be 'generate binary skeletons' fix to run", quickFix, + Matchers.instanceOf(GenerateBinaryStubsFix.class)); + final Task fixTask = ((GenerateBinaryStubsFix)quickFix).getFixTask(myFixture.getFile()); + fixTask.run(new AbstractProgressIndicatorBase()); } }); @@ -119,31 +132,6 @@ class SkeletonTestTask extends PyExecutionFixtureTestTask { return Collections.unmodifiableSet(IRON_TAGS); } - /** - * Waits {@link #SECONDS_TO_WAIT_FOR_SKELETON_GENERATION} seconds for file to be created. - * Fails test after that. - * - * @param skeletonToWait file to wait - */ - private static void waitForSkeleton(@NotNull final File skeletonToWait) { - for (int i = 0; i < SECONDS_TO_WAIT_FOR_SKELETON_GENERATION; i++) { - try { - // Can't sync with external process (no IPC is available for now), so we use busy wait - //noinspection BusyWait - Thread.sleep(1000L); - if (skeletonToWait.exists()) { - return; - } - } - catch (final InterruptedException e) { - throw new IllegalStateException("Interrupted while waiting for skeleton ", e); - } - } - final String message = - String.format("After %s seconds of waiting, skeleton %s still not ready", SECONDS_TO_WAIT_FOR_SKELETON_GENERATION, skeletonToWait); - Assert.assertTrue(message, skeletonToWait.exists()); - } - /** * @return File for generated skeleton. Call it after {@link #runTestOn(String)} only! */ From f0de704dce0c89297faa564f5a572952da2ab01a Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Wed, 6 Aug 2014 14:12:06 +0200 Subject: [PATCH 180/183] Fix broken console env tests. --- .../env/python/console/PyConsoleTask.java | 31 +++++++++++++++++-- 1 file changed, 29 insertions(+), 2 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index c2667162f283..9f0e0c505f36 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -1,9 +1,13 @@ package com.jetbrains.env.python.console; import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.intellij.execution.ExecutionManager; +import com.intellij.execution.Executor; import com.intellij.execution.console.LanguageConsoleView; import com.intellij.execution.process.ProcessAdapter; import com.intellij.execution.process.ProcessEvent; +import com.intellij.execution.ui.RunContentDescriptor; import com.intellij.openapi.application.Result; import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.project.Project; @@ -20,9 +24,11 @@ import com.jetbrains.python.debugger.PyDebugValue; import com.jetbrains.python.debugger.PyDebuggerException; import com.jetbrains.python.sdkTools.SdkCreationType; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.junit.Assert; import java.util.List; +import java.util.Map; import java.util.concurrent.Semaphore; /** @@ -131,8 +137,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { setProcessCanTerminate(false); - PydevConsoleRunner consoleRunner = PydevConsoleRunner.create(project, sdk, PyConsoleType.PYTHON, getWorkingFolder()); - + PydevConsoleRunner consoleRunner = new PythonTestConsoleRunner(project, sdk, PyConsoleType.PYTHON, getWorkingFolder(), Maps.newHashMap()); before(); mySemaphore0 = new Semaphore(0); @@ -380,4 +385,26 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { } ); } + + private static class PythonTestConsoleRunner extends PydevConsoleRunner { + + protected PythonTestConsoleRunner(@NotNull Project project, + @NotNull Sdk sdk, + @NotNull PyConsoleType consoleType, + @Nullable String workingDir, + Map environmentVariables) { + super(project, sdk, consoleType, workingDir, environmentVariables); + } + + @Override + protected void showConsole(Executor defaultExecutor, RunContentDescriptor contentDescriptor) { + // Show in run toolwindow + ExecutionManager.getInstance(getProject()).getContentManager().showRunContent(defaultExecutor, contentDescriptor); + } + + @Override + protected List getActiveConsoleNames(String consoleTitle) { + return getActiveConsolesFromRunToolWindow(consoleTitle); + } + } } From 234a84bf70e56f2326ab436fcbcbee0c8ea42063 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Mon, 11 Aug 2014 10:53:23 +0200 Subject: [PATCH 181/183] Use Python console action in Plugin and toolwindow in PyCharm. --- .../env/python/console/PyConsoleTask.java | 30 +------------------ 1 file changed, 1 insertion(+), 29 deletions(-) diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index 9f0e0c505f36..0ff971f45d7a 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -1,13 +1,9 @@ package com.jetbrains.env.python.console; import com.google.common.collect.Lists; -import com.google.common.collect.Maps; -import com.intellij.execution.ExecutionManager; -import com.intellij.execution.Executor; import com.intellij.execution.console.LanguageConsoleView; import com.intellij.execution.process.ProcessAdapter; import com.intellij.execution.process.ProcessEvent; -import com.intellij.execution.ui.RunContentDescriptor; import com.intellij.openapi.application.Result; import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.project.Project; @@ -24,11 +20,9 @@ import com.jetbrains.python.debugger.PyDebugValue; import com.jetbrains.python.debugger.PyDebuggerException; import com.jetbrains.python.sdkTools.SdkCreationType; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.junit.Assert; import java.util.List; -import java.util.Map; import java.util.concurrent.Semaphore; /** @@ -137,7 +131,7 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { setProcessCanTerminate(false); - PydevConsoleRunner consoleRunner = new PythonTestConsoleRunner(project, sdk, PyConsoleType.PYTHON, getWorkingFolder(), Maps.newHashMap()); + PydevConsoleRunner consoleRunner = PydevConsoleRunner.create(project, sdk, PyConsoleType.PYTHON, getWorkingFolder()); before(); mySemaphore0 = new Semaphore(0); @@ -385,26 +379,4 @@ public class PyConsoleTask extends PyExecutionFixtureTestTask { } ); } - - private static class PythonTestConsoleRunner extends PydevConsoleRunner { - - protected PythonTestConsoleRunner(@NotNull Project project, - @NotNull Sdk sdk, - @NotNull PyConsoleType consoleType, - @Nullable String workingDir, - Map environmentVariables) { - super(project, sdk, consoleType, workingDir, environmentVariables); - } - - @Override - protected void showConsole(Executor defaultExecutor, RunContentDescriptor contentDescriptor) { - // Show in run toolwindow - ExecutionManager.getInstance(getProject()).getContentManager().showRunContent(defaultExecutor, contentDescriptor); - } - - @Override - protected List getActiveConsoleNames(String consoleTitle) { - return getActiveConsolesFromRunToolWindow(consoleTitle); - } - } } From 26ae9c89c21cf940492d5d9f2f54c71581566826 Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 12 Aug 2014 18:04:25 +0200 Subject: [PATCH 182/183] Community env tests separated. --- .../com/jetbrains/env/RemoteSdkTestable.java | 7 - .../{ => community}/PyEnvSufficiencyTest.java | 3 +- .../env/community/PyEnvTaskRunner.java | 112 +++++++++++ .../debug => community}/PyEnvTestCase.java | 176 +----------------- .../PyExecutionFixtureTestTask.java | 2 +- .../debug => community}/PyTestTask.java | 4 +- .../python/IPythonConsoleTest.java | 6 +- .../PyPackageRequirementsInspectionTest.java | 6 +- .../python/PyPackagingTest.java | 8 +- .../python/PythonConsoleTest.java | 7 +- .../python/PythonDebuggerTest.java | 8 +- .../python/PythonGeneratorTest.java | 6 +- .../python/PythonSkeletonsTest.java | 8 +- .../python/console/PyConsoleTask.java | 6 +- .../python/debug/PyBaseDebuggerTask.java | 5 +- .../python/debug/PyDebuggerTask.java | 10 +- .../python/dotNet/PyIronPythonTest.java | 4 +- .../python/dotNet/SkeletonTestTask.java | 4 +- .../python/dotNet/package-info.java | 2 +- .../python/testing/PythonDocTestingTest.java | 6 +- .../python/testing/PythonNoseTestingTest.java | 6 +- .../python/testing/PythonPyTestingTest.java | 6 +- .../python/testing/PythonUnitTestingTest.java | 6 +- .../env/{ => community}/ut/PyDocTestTask.java | 2 +- .../{ => community}/ut/PyNoseTestTask.java | 2 +- .../{ => community}/ut/PyTestTestTask.java | 2 +- .../{ => community}/ut/PyUnitTestTask.java | 4 +- .../env/django/DjangoEnvTestTask.java | 2 +- .../django/DjangoManageTaskActionsTest.java | 2 +- .../env/django/DjangoManageTestTask.java | 2 +- .../jetbrains/env/django/DjangoPathTest.java | 2 +- .../env/django/DjangoProjectCreationTest.java | 4 +- .../django/DjangoTemplateDebuggerTest.java | 2 +- .../env/django/DjangoTestRunnerTest.java | 7 +- .../PyRemoteDebuggerTask.java | 3 +- .../env/remote/PyRemoteDebuggerTest.java | 85 +++++++++ .../{ => remote}/PyTestRemoteSdkProvider.java | 6 +- 37 files changed, 277 insertions(+), 256 deletions(-) delete mode 100644 python/testSrc/com/jetbrains/env/RemoteSdkTestable.java rename python/testSrc/com/jetbrains/env/{ => community}/PyEnvSufficiencyTest.java (94%) create mode 100644 python/testSrc/com/jetbrains/env/community/PyEnvTaskRunner.java rename python/testSrc/com/jetbrains/env/{python/debug => community}/PyEnvTestCase.java (53%) rename python/testSrc/com/jetbrains/env/{python/debug => community}/PyExecutionFixtureTestTask.java (99%) rename python/testSrc/com/jetbrains/env/{python/debug => community}/PyTestTask.java (88%) rename python/testSrc/com/jetbrains/env/{ => community}/python/IPythonConsoleTest.java (94%) rename python/testSrc/com/jetbrains/env/{ => community}/python/PyPackageRequirementsInspectionTest.java (94%) rename python/testSrc/com/jetbrains/env/{ => community}/python/PyPackagingTest.java (97%) rename python/testSrc/com/jetbrains/env/{ => community}/python/PythonConsoleTest.java (94%) rename python/testSrc/com/jetbrains/env/{ => community}/python/PythonDebuggerTest.java (98%) rename python/testSrc/com/jetbrains/env/{ => community}/python/PythonGeneratorTest.java (75%) rename python/testSrc/com/jetbrains/env/{ => community}/python/PythonSkeletonsTest.java (97%) rename python/testSrc/com/jetbrains/env/{ => community}/python/console/PyConsoleTask.java (98%) rename python/testSrc/com/jetbrains/env/{ => community}/python/debug/PyBaseDebuggerTask.java (98%) rename python/testSrc/com/jetbrains/env/{ => community}/python/debug/PyDebuggerTask.java (95%) rename python/testSrc/com/jetbrains/env/{ => community}/python/dotNet/PyIronPythonTest.java (97%) rename python/testSrc/com/jetbrains/env/{ => community}/python/dotNet/SkeletonTestTask.java (98%) rename python/testSrc/com/jetbrains/env/{ => community}/python/dotNet/package-info.java (79%) rename python/testSrc/com/jetbrains/env/{ => community}/python/testing/PythonDocTestingTest.java (90%) rename python/testSrc/com/jetbrains/env/{ => community}/python/testing/PythonNoseTestingTest.java (81%) rename python/testSrc/com/jetbrains/env/{ => community}/python/testing/PythonPyTestingTest.java (81%) rename python/testSrc/com/jetbrains/env/{ => community}/python/testing/PythonUnitTestingTest.java (92%) rename python/testSrc/com/jetbrains/env/{ => community}/ut/PyDocTestTask.java (95%) rename python/testSrc/com/jetbrains/env/{ => community}/ut/PyNoseTestTask.java (95%) rename python/testSrc/com/jetbrains/env/{ => community}/ut/PyTestTestTask.java (96%) rename python/testSrc/com/jetbrains/env/{ => community}/ut/PyUnitTestTask.java (98%) rename python/testSrc/com/jetbrains/env/{python/debug => remote}/PyRemoteDebuggerTask.java (98%) create mode 100644 python/testSrc/com/jetbrains/env/remote/PyRemoteDebuggerTest.java rename python/testSrc/com/jetbrains/env/{ => remote}/PyTestRemoteSdkProvider.java (96%) diff --git a/python/testSrc/com/jetbrains/env/RemoteSdkTestable.java b/python/testSrc/com/jetbrains/env/RemoteSdkTestable.java deleted file mode 100644 index c60202ae3257..000000000000 --- a/python/testSrc/com/jetbrains/env/RemoteSdkTestable.java +++ /dev/null @@ -1,7 +0,0 @@ -package com.jetbrains.env; - -/** - * @author traff - */ -public interface RemoteSdkTestable { -} diff --git a/python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java b/python/testSrc/com/jetbrains/env/community/PyEnvSufficiencyTest.java similarity index 94% rename from python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java rename to python/testSrc/com/jetbrains/env/community/PyEnvSufficiencyTest.java index a5e261efe25f..61b64dfee5bf 100644 --- a/python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java +++ b/python/testSrc/com/jetbrains/env/community/PyEnvSufficiencyTest.java @@ -1,4 +1,4 @@ -package com.jetbrains.env; +package com.jetbrains.env.community; import com.google.common.collect.ImmutableList; import com.google.common.collect.Lists; @@ -6,7 +6,6 @@ import com.google.common.collect.Sets; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.text.StringUtil; import com.intellij.testFramework.UsefulTestCase; -import com.jetbrains.env.python.debug.PyEnvTestCase; import java.util.List; import java.util.Set; diff --git a/python/testSrc/com/jetbrains/env/community/PyEnvTaskRunner.java b/python/testSrc/com/jetbrains/env/community/PyEnvTaskRunner.java new file mode 100644 index 000000000000..aab5f969da28 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/community/PyEnvTaskRunner.java @@ -0,0 +1,112 @@ +package com.jetbrains.env.community; + +import com.google.common.collect.Lists; +import com.google.common.collect.Sets; +import com.jetbrains.python.sdk.PythonSdkType; +import org.jetbrains.annotations.NotNull; + +import java.util.List; +import java.util.Set; + +/** + * @author traff + */ +public class PyEnvTaskRunner { + private final List myRoots; + + public PyEnvTaskRunner(List roots) { + myRoots = roots; + } + + public void runTask(PyTestTask testTask, String testName) { + boolean wasExecuted = false; + + List passedRoots = Lists.newArrayList(); + + for (String root : myRoots) { + + if (!isSuitableForTask(PyEnvTestCase.loadEnvTags(root), testTask) || !shouldRun(root, testTask)) { + continue; + } + + try { + testTask.setUp(testName); + wasExecuted = true; + if (isJython(root)) { + testTask.useLongTimeout(); + } + else { + testTask.useNormalTimeout(); + } + final String executable = getExecutable(root, testTask); + if (executable == null) { + throw new RuntimeException("Cannot find Python interpreter in " + root); + } + testTask.runTestOn(executable); + passedRoots.add(root); + } + catch (Throwable e) { + throw new RuntimeException( + PyEnvTestCase.joinStrings(passedRoots, "Tests passed environments: ") + "Test failed on " + getEnvType() + " environment " + root, + e); + } + finally { + try { + testTask.tearDown(); + } + catch (Exception e) { + throw new RuntimeException("Couldn't tear down task", e); + } + } + } + + if (!wasExecuted) { + throw new RuntimeException("test" + + testName + + " was not executed.\n" + + PyEnvTestCase.joinStrings(myRoots, "All roots: ") + + "\n" + + PyEnvTestCase.joinStrings(testTask.getTags(), "Required tags in tags.txt in root: ")); + } + } + + protected boolean shouldRun(String root, PyTestTask task) { + return true; + } + + protected String getExecutable(String root, PyTestTask testTask) { + return PythonSdkType.getPythonExecutable(root); + } + + protected String getEnvType() { + return "local"; + } + + private static boolean isSuitableForTask(List tags, PyTestTask task) { + return isSuitableForTags(tags, task.getTags()); + } + + public static boolean isSuitableForTags(List envTags, Set taskTags) { + Set necessaryTags = Sets.newHashSet(taskTags); + + for (String tag : envTags) { + necessaryTags.remove(tag.trim()); + } + + for (String tag : taskTags) { + if (tag.startsWith("-")) { //do not run on envs with that tag + if (envTags.contains(tag.substring(1))) { + return false; + } + necessaryTags.remove(tag); + } + } + + return necessaryTags.isEmpty(); + } + + + protected static boolean isJython(@NotNull String sdkHome) { + return sdkHome.toLowerCase().contains("jython"); + } +} diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/community/PyEnvTestCase.java similarity index 53% rename from python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java rename to python/testSrc/com/jetbrains/env/community/PyEnvTestCase.java index e82758794e48..5f07b29a1639 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/community/PyEnvTestCase.java @@ -1,20 +1,13 @@ -package com.jetbrains.env.python.debug; +package com.jetbrains.env.community; import com.google.common.collect.Lists; -import com.google.common.collect.Sets; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; -import com.intellij.openapi.project.Project; -import com.intellij.openapi.projectRoots.ProjectJdkTable; -import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.util.text.StringUtil; import com.intellij.testFramework.UsefulTestCase; import com.intellij.util.SystemProperties; import com.intellij.util.ui.UIUtil; -import com.jetbrains.env.PyTestRemoteSdkProvider; import com.jetbrains.python.fixtures.PyTestCase; -import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; -import com.jetbrains.python.sdk.PythonSdkType; import org.hamcrest.Matchers; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -25,7 +18,6 @@ import java.io.IOException; import java.util.Collection; import java.util.HashSet; import java.util.List; -import java.util.Set; /** * @author traff @@ -136,147 +128,18 @@ public abstract class PyEnvTestCase extends UsefulTestCase { return; } + doRunTests(testTask, testName, roots); + } + + protected void doRunTests(PyTestTask testTask, String testName, List roots) { if (RUN_LOCAL) { - TaskRunner taskRunner = new TaskRunner(roots); + PyEnvTaskRunner taskRunner = new PyEnvTaskRunner(roots); taskRunner.runTask(testTask, testName); } - - if (RUN_REMOTE && PyTestRemoteSdkProvider.shouldRunRemoteSdk(testTask)) { - if (PyTestRemoteSdkProvider.canRunRemoteSdk()) { - TaskRunner remoteRunner = new RemoteTaskRunner(roots); - remoteRunner.runTask(testTask, testName); - } - else { - if (PyTestRemoteSdkProvider.shouldFailWhenCantRunRemote()) { - fail("Cant run with remote sdk: password isn't set"); - } - } - } } - private static class TaskRunner { - private final List myRoots; - - private TaskRunner(List roots) { - myRoots = roots; - } - - public void runTask(PyTestTask testTask, String testName) { - boolean wasExecuted = false; - - List passedRoots = Lists.newArrayList(); - - for (String root : myRoots) { - - if (!isSuitableForTask(loadEnvTags(root), testTask) || !shouldRun(root, testTask)) { - continue; - } - - try { - testTask.setUp(testName); - wasExecuted = true; - if (isJython(root)) { - testTask.useLongTimeout(); - } - else { - testTask.useNormalTimeout(); - } - final String executable = getExecutable(root, testTask); - if (executable == null) { - throw new RuntimeException("Cannot find Python interpreter in " + root); - } - testTask.runTestOn(executable); - passedRoots.add(root); - } - catch (Throwable e) { - throw new RuntimeException( - joinStrings(passedRoots, "Tests passed environments: ") + "Test failed on " + getEnvType() + " environment " + root, e); - } - finally { - try { - testTask.tearDown(); - } - catch (Exception e) { - throw new RuntimeException("Couldn't tear down task", e); - } - } - } - - if (!wasExecuted) { - throw new RuntimeException("test" + - testName + - " was not executed.\n" + - joinStrings(myRoots, "All roots: ") + - "\n" + - joinStrings(testTask.getTags(), "Required tags in tags.txt in root: ")); - } - } - - protected boolean shouldRun(String root, PyTestTask task) { - return true; - } - - protected String getExecutable(String root, PyTestTask testTask) { - return PythonSdkType.getPythonExecutable(root); - } - - protected String getEnvType() { - return "local"; - } - } - - private static class RemoteTaskRunner extends TaskRunner { - private RemoteTaskRunner(List roots) { - super(roots); - } - - @Override - protected String getExecutable(String root, PyTestTask testTask) { - try { - final Sdk sdk = PyTestRemoteSdkProvider.getInstance().getSdk(getProject(testTask), super.getExecutable(root, testTask)); - - if (ProjectJdkTable.getInstance().findJdk(sdk.getName()) == null) { - UIUtil.invokeAndWaitIfNeeded(new Runnable() { - @Override - public void run() { - ApplicationManager.getApplication().runWriteAction(new Runnable() { - @Override - public void run() { - ProjectJdkTable.getInstance().addJdk(sdk); - } - }); - } - }); - } - - return ((PyRemoteSdkAdditionalData)sdk.getSdkAdditionalData()).getRemoteSdkCredentials(false).getSdkId(); - } - catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Nullable - public Project getProject(PyTestTask task) { - if (task instanceof PyExecutionFixtureTestTask) { - return ((PyExecutionFixtureTestTask)task).getProject(); - } - return null; - } - - @Override - protected boolean shouldRun(String root, PyTestTask task) { - return !isJython(super.getExecutable(root, task)); //TODO: make remote tests work for jython - } - - @Override - protected String getEnvType() { - return "remote"; - } - } - public static boolean notEnvConfiguration() { return UsefulTestCase.IS_UNDER_TEAMCITY && !IS_ENV_CONFIGURATION; } @@ -331,35 +194,8 @@ public abstract class PyEnvTestCase extends UsefulTestCase { return envTags; } - private static boolean isSuitableForTask(List tags, PyTestTask task) { - return isSuitableForTags(tags, task.getTags()); - } - - public static boolean isSuitableForTags(List envTags, Set taskTags) { - Set necessaryTags = Sets.newHashSet(taskTags); - - for (String tag : envTags) { - necessaryTags.remove(tag.trim()); - } - - for (String tag : taskTags) { - if (tag.startsWith("-")) { //do not run on envs with that tag - if (envTags.contains(tag.substring(1))) { - return false; - } - necessaryTags.remove(tag); - } - } - - return necessaryTags.isEmpty(); - } - public static String joinStrings(Collection roots, String rootsName) { return roots.size() > 0 ? rootsName + StringUtil.join(roots, ", ") + "\n" : ""; } - - private static boolean isJython(String sdkHome) { - return sdkHome.toLowerCase().contains("jython"); - } } diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java b/python/testSrc/com/jetbrains/env/community/PyExecutionFixtureTestTask.java similarity index 99% rename from python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java rename to python/testSrc/com/jetbrains/env/community/PyExecutionFixtureTestTask.java index 8382dd2b24a8..2c48c1b6da8f 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyExecutionFixtureTestTask.java +++ b/python/testSrc/com/jetbrains/env/community/PyExecutionFixtureTestTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.python.debug; +package com.jetbrains.env.community; import com.google.common.collect.Lists; import com.intellij.execution.process.ProcessHandler; diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java b/python/testSrc/com/jetbrains/env/community/PyTestTask.java similarity index 88% rename from python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java rename to python/testSrc/com/jetbrains/env/community/PyTestTask.java index 239f57002372..61e81d08110d 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyTestTask.java +++ b/python/testSrc/com/jetbrains/env/community/PyTestTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.python.debug; +package com.jetbrains.env.community; import com.google.common.collect.Sets; import com.intellij.openapi.util.io.FileUtil; @@ -33,7 +33,7 @@ public abstract class PyTestTask { /** * Run test on certain SDK path. - * To create SDK from path, use {@link com.jetbrains.env.python.debug.PyExecutionFixtureTestTask#createTempSdk(String, com.jetbrains.python.sdkTools.SdkCreationType)} + * To create SDK from path, use {@link PyExecutionFixtureTestTask#createTempSdk(String, com.jetbrains.python.sdkTools.SdkCreationType)} * * @param sdkHome sdk path */ diff --git a/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java b/python/testSrc/com/jetbrains/env/community/python/IPythonConsoleTest.java similarity index 94% rename from python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java rename to python/testSrc/com/jetbrains/env/community/python/IPythonConsoleTest.java index a1e6d77601e4..a67503e8d586 100644 --- a/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/community/python/IPythonConsoleTest.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.python; +package com.jetbrains.env.community.python; import com.google.common.base.Function; import com.google.common.collect.Collections2; @@ -8,8 +8,8 @@ import com.intellij.psi.PsiDocumentManager; import com.intellij.psi.PsiErrorElement; import com.intellij.psi.PsiFile; import com.intellij.psi.util.PsiTreeUtil; -import com.jetbrains.env.python.console.PyConsoleTask; -import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.community.python.console.PyConsoleTask; import org.hamcrest.Matchers; import org.jetbrains.annotations.NotNull; import org.junit.Assert; diff --git a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java b/python/testSrc/com/jetbrains/env/community/python/PyPackageRequirementsInspectionTest.java similarity index 94% rename from python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java rename to python/testSrc/com/jetbrains/env/community/python/PyPackageRequirementsInspectionTest.java index ac6ae2625091..cda73ca8b50d 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java +++ b/python/testSrc/com/jetbrains/env/community/python/PyPackageRequirementsInspectionTest.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.python; +package com.jetbrains.env.community.python; import com.google.common.collect.ImmutableSet; import com.intellij.openapi.module.Module; @@ -6,8 +6,8 @@ import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.roots.ModuleRootModificationUtil; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.testFramework.PsiTestUtil; -import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; +import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.community.PyExecutionFixtureTestTask; import com.jetbrains.python.PythonTestUtil; import com.jetbrains.python.inspections.PyPackageRequirementsInspection; import com.jetbrains.python.sdkTools.SdkCreationType; diff --git a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/community/python/PyPackagingTest.java similarity index 97% rename from python/testSrc/com/jetbrains/env/python/PyPackagingTest.java rename to python/testSrc/com/jetbrains/env/community/python/PyPackagingTest.java index a14fa6aa879d..c8e1197b2ba5 100644 --- a/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/community/python/PyPackagingTest.java @@ -1,13 +1,13 @@ -package com.jetbrains.env.python; +package com.jetbrains.env.community.python; import com.google.common.collect.Sets; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; import com.intellij.testFramework.UsefulTestCase; -import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; -import com.jetbrains.env.python.debug.PyTestTask; +import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.community.PyExecutionFixtureTestTask; +import com.jetbrains.env.community.PyTestTask; import com.jetbrains.python.packaging.*; import com.jetbrains.python.psi.LanguageLevel; import com.jetbrains.python.sdk.PythonSdkType; diff --git a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java b/python/testSrc/com/jetbrains/env/community/python/PythonConsoleTest.java similarity index 94% rename from python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java rename to python/testSrc/com/jetbrains/env/community/python/PythonConsoleTest.java index 992346973a9a..534dd13e7653 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/community/python/PythonConsoleTest.java @@ -1,9 +1,8 @@ -package com.jetbrains.env.python; +package com.jetbrains.env.community.python; -import com.google.common.collect.ImmutableSet; import com.google.common.collect.Sets; -import com.jetbrains.env.python.console.PyConsoleTask; -import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.community.python.console.PyConsoleTask; import org.junit.Assert; import java.util.Collections; diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/community/python/PythonDebuggerTest.java similarity index 98% rename from python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java rename to python/testSrc/com/jetbrains/env/community/python/PythonDebuggerTest.java index 16f07cb4f72b..9db598652821 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/community/python/PythonDebuggerTest.java @@ -1,13 +1,13 @@ -package com.jetbrains.env.python; +package com.jetbrains.env.community.python; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; import com.google.common.collect.Sets; import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; import com.intellij.xdebugger.XDebuggerTestUtil; -import com.jetbrains.env.python.debug.PyDebuggerTask; -import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.env.ut.PyUnitTestTask; +import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.community.python.debug.PyDebuggerTask; +import com.jetbrains.env.community.ut.PyUnitTestTask; import com.jetbrains.python.PythonHelpersLocator; import com.jetbrains.python.console.pydev.PydevCompletionVariant; import com.jetbrains.python.debugger.PyDebuggerException; diff --git a/python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java b/python/testSrc/com/jetbrains/env/community/python/PythonGeneratorTest.java similarity index 75% rename from python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java rename to python/testSrc/com/jetbrains/env/community/python/PythonGeneratorTest.java index e9a227a4fdc4..f28344ea834d 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java +++ b/python/testSrc/com/jetbrains/env/community/python/PythonGeneratorTest.java @@ -1,7 +1,7 @@ -package com.jetbrains.env.python; +package com.jetbrains.env.community.python; -import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.env.ut.PyUnitTestTask; +import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.community.ut.PyUnitTestTask; import com.jetbrains.python.PythonHelpersLocator; /** diff --git a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/community/python/PythonSkeletonsTest.java similarity index 97% rename from python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java rename to python/testSrc/com/jetbrains/env/community/python/PythonSkeletonsTest.java index e6a5fd82558d..de34949aca58 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/community/python/PythonSkeletonsTest.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.python; +package com.jetbrains.env.community.python; import com.google.common.collect.ImmutableSet; import com.intellij.openapi.application.ApplicationManager; @@ -9,9 +9,9 @@ import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiFile; -import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; -import com.jetbrains.env.python.debug.PyTestTask; +import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.community.PyExecutionFixtureTestTask; +import com.jetbrains.env.community.PyTestTask; import com.jetbrains.python.PythonFileType; import com.jetbrains.python.PythonTestUtil; import com.jetbrains.python.documentation.PythonDocumentationProvider; diff --git a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/community/python/console/PyConsoleTask.java similarity index 98% rename from python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java rename to python/testSrc/com/jetbrains/env/community/python/console/PyConsoleTask.java index 0ff971f45d7a..d43ce0a10232 100644 --- a/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/community/python/console/PyConsoleTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.python.console; +package com.jetbrains.env.community.python.console; import com.google.common.collect.Lists; import com.intellij.execution.console.LanguageConsoleView; @@ -13,7 +13,7 @@ import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiDocumentManager; import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.frame.XValueChildrenList; -import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; +import com.jetbrains.env.community.PyExecutionFixtureTestTask; import com.jetbrains.python.console.*; import com.jetbrains.python.console.pydev.ConsoleCommunicationListener; import com.jetbrains.python.debugger.PyDebugValue; @@ -29,8 +29,6 @@ import java.util.concurrent.Semaphore; * @author traff */ public class PyConsoleTask extends PyExecutionFixtureTestTask { - - private boolean myProcessCanTerminate; protected PyConsoleProcessHandler myProcessHandler; diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java b/python/testSrc/com/jetbrains/env/community/python/debug/PyBaseDebuggerTask.java similarity index 98% rename from python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java rename to python/testSrc/com/jetbrains/env/community/python/debug/PyBaseDebuggerTask.java index 3d6ece5583d3..b3426fc24b54 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/community/python/debug/PyBaseDebuggerTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.python.debug; +package com.jetbrains.env.community.python.debug; import com.google.common.collect.Sets; import com.intellij.openapi.application.Result; @@ -12,6 +12,7 @@ import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.*; import com.intellij.xdebugger.frame.XValue; import com.jetbrains.django.util.VirtualFileUtil; +import com.jetbrains.env.community.PyExecutionFixtureTestTask; import com.jetbrains.python.console.PythonDebugLanguageConsoleView; import com.jetbrains.python.debugger.PyDebugProcess; import com.jetbrains.python.debugger.PyDebugValue; @@ -322,7 +323,7 @@ public abstract class PyBaseDebuggerTask extends PyExecutionFixtureTestTask { } } - protected class OutputPrinter { + public class OutputPrinter { private Thread myThread; public void start() { diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/community/python/debug/PyDebuggerTask.java similarity index 95% rename from python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java rename to python/testSrc/com/jetbrains/env/community/python/debug/PyDebuggerTask.java index a5cd9fe15a7a..d2923f34a3ad 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/community/python/debug/PyDebuggerTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.python.debug; +package com.jetbrains.env.community.python.debug; import com.intellij.execution.*; import com.intellij.execution.configurations.ConfigurationFactory; @@ -13,11 +13,7 @@ import com.intellij.openapi.application.Result; import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Key; -import com.intellij.openapi.util.SystemInfo; -import com.intellij.openapi.util.io.FileUtil; import com.intellij.xdebugger.*; -import com.jetbrains.env.RemoteSdkTestable; -import com.jetbrains.python.PythonHelpersLocator; import com.jetbrains.python.debugger.PyDebugProcess; import com.jetbrains.python.debugger.PyDebugRunner; import com.jetbrains.python.run.PythonCommandLineState; @@ -26,8 +22,6 @@ import com.jetbrains.python.run.PythonRunConfiguration; import org.jetbrains.annotations.NotNull; import org.junit.Assert; -import java.io.File; -import java.io.FilenameFilter; import java.io.IOException; import java.net.ServerSocket; import java.util.concurrent.Semaphore; @@ -35,7 +29,7 @@ import java.util.concurrent.Semaphore; /** * @author traff */ -public class PyDebuggerTask extends PyBaseDebuggerTask implements RemoteSdkTestable { +public class PyDebuggerTask extends PyBaseDebuggerTask { private boolean myMultiprocessDebug = false; private PythonRunConfiguration myRunConfiguration; diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java b/python/testSrc/com/jetbrains/env/community/python/dotNet/PyIronPythonTest.java similarity index 97% rename from python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java rename to python/testSrc/com/jetbrains/env/community/python/dotNet/PyIronPythonTest.java index 254f8ade4f86..70f9b2453419 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java +++ b/python/testSrc/com/jetbrains/env/community/python/dotNet/PyIronPythonTest.java @@ -1,8 +1,8 @@ -package com.jetbrains.env.python.dotNet; +package com.jetbrains.env.community.python.dotNet; import com.intellij.openapi.application.ReadAction; import com.intellij.openapi.application.Result; -import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.community.PyEnvTestCase; import com.jetbrains.python.psi.PyFile; import org.jetbrains.annotations.NotNull; import org.junit.Assert; diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java b/python/testSrc/com/jetbrains/env/community/python/dotNet/SkeletonTestTask.java similarity index 98% rename from python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java rename to python/testSrc/com/jetbrains/env/community/python/dotNet/SkeletonTestTask.java index 0b197921cc3e..f2b788b82848 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java +++ b/python/testSrc/com/jetbrains/env/community/python/dotNet/SkeletonTestTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.python.dotNet; +package com.jetbrains.env.community.python.dotNet; import com.google.common.collect.Sets; import com.intellij.codeInsight.intention.IntentionAction; @@ -11,7 +11,7 @@ import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.util.io.FileUtil; import com.intellij.psi.PsiDocumentManager; import com.intellij.util.ui.UIUtil; -import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; +import com.jetbrains.env.community.PyExecutionFixtureTestTask; import com.jetbrains.python.PyBundle; import com.jetbrains.python.PyNames; import com.jetbrains.python.inspections.quickfix.GenerateBinaryStubsFix; diff --git a/python/testSrc/com/jetbrains/env/python/dotNet/package-info.java b/python/testSrc/com/jetbrains/env/community/python/dotNet/package-info.java similarity index 79% rename from python/testSrc/com/jetbrains/env/python/dotNet/package-info.java rename to python/testSrc/com/jetbrains/env/community/python/dotNet/package-info.java index e56e6203b98d..9facb61f3be3 100644 --- a/python/testSrc/com/jetbrains/env/python/dotNet/package-info.java +++ b/python/testSrc/com/jetbrains/env/community/python/dotNet/package-info.java @@ -2,4 +2,4 @@ * IronPython tests. Install IronPython, .NET and add "iron" to "tags.txt" file. Check for more info: http://confluence.jetbrains.com/display/PYINT/Env+Tests * @author Ilya.Kazakevich */ -package com.jetbrains.env.python.dotNet; \ No newline at end of file +package com.jetbrains.env.community.python.dotNet; \ No newline at end of file diff --git a/python/testSrc/com/jetbrains/env/python/testing/PythonDocTestingTest.java b/python/testSrc/com/jetbrains/env/community/python/testing/PythonDocTestingTest.java similarity index 90% rename from python/testSrc/com/jetbrains/env/python/testing/PythonDocTestingTest.java rename to python/testSrc/com/jetbrains/env/community/python/testing/PythonDocTestingTest.java index a710d5a22d1a..178673fa30c3 100644 --- a/python/testSrc/com/jetbrains/env/python/testing/PythonDocTestingTest.java +++ b/python/testSrc/com/jetbrains/env/community/python/testing/PythonDocTestingTest.java @@ -1,7 +1,7 @@ -package com.jetbrains.env.python.testing; +package com.jetbrains.env.community.python.testing; -import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.env.ut.PyDocTestTask; +import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.community.ut.PyDocTestTask; /** * User : catherine diff --git a/python/testSrc/com/jetbrains/env/python/testing/PythonNoseTestingTest.java b/python/testSrc/com/jetbrains/env/community/python/testing/PythonNoseTestingTest.java similarity index 81% rename from python/testSrc/com/jetbrains/env/python/testing/PythonNoseTestingTest.java rename to python/testSrc/com/jetbrains/env/community/python/testing/PythonNoseTestingTest.java index 6f5c7567a7cf..7bc3d438e9db 100644 --- a/python/testSrc/com/jetbrains/env/python/testing/PythonNoseTestingTest.java +++ b/python/testSrc/com/jetbrains/env/community/python/testing/PythonNoseTestingTest.java @@ -1,7 +1,7 @@ -package com.jetbrains.env.python.testing; +package com.jetbrains.env.community.python.testing; -import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.env.ut.PyNoseTestTask; +import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.community.ut.PyNoseTestTask; /** * User : catherine diff --git a/python/testSrc/com/jetbrains/env/python/testing/PythonPyTestingTest.java b/python/testSrc/com/jetbrains/env/community/python/testing/PythonPyTestingTest.java similarity index 81% rename from python/testSrc/com/jetbrains/env/python/testing/PythonPyTestingTest.java rename to python/testSrc/com/jetbrains/env/community/python/testing/PythonPyTestingTest.java index c503c02ba99f..94463b89ae27 100644 --- a/python/testSrc/com/jetbrains/env/python/testing/PythonPyTestingTest.java +++ b/python/testSrc/com/jetbrains/env/community/python/testing/PythonPyTestingTest.java @@ -1,7 +1,7 @@ -package com.jetbrains.env.python.testing; +package com.jetbrains.env.community.python.testing; -import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.env.ut.PyTestTestTask; +import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.community.ut.PyTestTestTask; /** * User : catherine diff --git a/python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java b/python/testSrc/com/jetbrains/env/community/python/testing/PythonUnitTestingTest.java similarity index 92% rename from python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java rename to python/testSrc/com/jetbrains/env/community/python/testing/PythonUnitTestingTest.java index 5ab502643398..892db6c8bdee 100644 --- a/python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java +++ b/python/testSrc/com/jetbrains/env/community/python/testing/PythonUnitTestingTest.java @@ -1,7 +1,7 @@ -package com.jetbrains.env.python.testing; +package com.jetbrains.env.community.python.testing; -import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.env.ut.PyUnitTestTask; +import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.community.ut.PyUnitTestTask; import junit.framework.Assert; /** diff --git a/python/testSrc/com/jetbrains/env/ut/PyDocTestTask.java b/python/testSrc/com/jetbrains/env/community/ut/PyDocTestTask.java similarity index 95% rename from python/testSrc/com/jetbrains/env/ut/PyDocTestTask.java rename to python/testSrc/com/jetbrains/env/community/ut/PyDocTestTask.java index e8228d767287..bfc62fa55a38 100644 --- a/python/testSrc/com/jetbrains/env/ut/PyDocTestTask.java +++ b/python/testSrc/com/jetbrains/env/community/ut/PyDocTestTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.ut; +package com.jetbrains.env.community.ut; import com.intellij.execution.configurations.ConfigurationFactory; import com.intellij.openapi.project.Project; diff --git a/python/testSrc/com/jetbrains/env/ut/PyNoseTestTask.java b/python/testSrc/com/jetbrains/env/community/ut/PyNoseTestTask.java similarity index 95% rename from python/testSrc/com/jetbrains/env/ut/PyNoseTestTask.java rename to python/testSrc/com/jetbrains/env/community/ut/PyNoseTestTask.java index e130dd5717a4..7d26d96c3eca 100644 --- a/python/testSrc/com/jetbrains/env/ut/PyNoseTestTask.java +++ b/python/testSrc/com/jetbrains/env/community/ut/PyNoseTestTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.ut; +package com.jetbrains.env.community.ut; import com.google.common.collect.ImmutableSet; import com.intellij.execution.configurations.ConfigurationFactory; diff --git a/python/testSrc/com/jetbrains/env/ut/PyTestTestTask.java b/python/testSrc/com/jetbrains/env/community/ut/PyTestTestTask.java similarity index 96% rename from python/testSrc/com/jetbrains/env/ut/PyTestTestTask.java rename to python/testSrc/com/jetbrains/env/community/ut/PyTestTestTask.java index 1e4261188206..e80d40aa7326 100644 --- a/python/testSrc/com/jetbrains/env/ut/PyTestTestTask.java +++ b/python/testSrc/com/jetbrains/env/community/ut/PyTestTestTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.ut; +package com.jetbrains.env.community.ut; import com.google.common.collect.ImmutableSet; import com.intellij.execution.configurations.ConfigurationFactory; diff --git a/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java b/python/testSrc/com/jetbrains/env/community/ut/PyUnitTestTask.java similarity index 98% rename from python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java rename to python/testSrc/com/jetbrains/env/community/ut/PyUnitTestTask.java index c98f0f1c2786..ce441dd46961 100644 --- a/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java +++ b/python/testSrc/com/jetbrains/env/community/ut/PyUnitTestTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.ut; +package com.jetbrains.env.community.ut; import com.google.common.collect.Lists; import com.intellij.execution.*; @@ -21,7 +21,7 @@ import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.Key; import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.XDebuggerTestUtil; -import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; +import com.jetbrains.env.community.PyExecutionFixtureTestTask; import com.jetbrains.python.sdk.PythonEnvUtil; import com.jetbrains.python.sdk.flavors.JythonSdkFlavor; import com.jetbrains.python.sdk.flavors.PythonSdkFlavor; diff --git a/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java index 7e87e9fd8cb2..7755b840080a 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java @@ -9,7 +9,7 @@ import com.intellij.openapi.vfs.VirtualFile; import com.intellij.util.ui.UIUtil; import com.jetbrains.django.facet.DjangoFacet; import com.jetbrains.django.fixtures.DjangoTestCase; -import com.jetbrains.env.python.debug.PyDebuggerTask; +import com.jetbrains.env.community.python.debug.PyDebuggerTask; import com.jetbrains.python.fixtures.PyProfessionalTestCase; import com.jetbrains.python.templateLanguages.TemplatesService; import org.junit.Assert; diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java index 81204ef0cbc2..cc3b4c17c748 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java @@ -7,7 +7,7 @@ import com.jetbrains.django.actions.manage.ManageTaskActions; import com.jetbrains.django.manage.BaseCommand; import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; import com.jetbrains.django.util.DjangoUtil; -import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.community.PyEnvTestCase; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import org.jetbrains.annotations.Nullable; import org.junit.Assert; diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java index 7de1dfe4ef9a..446939b9ec7e 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java @@ -29,7 +29,7 @@ import com.jetbrains.django.fixtures.DjangoTestCase; import com.jetbrains.django.manage.DjangoManageTask; import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; import com.jetbrains.django.ui.DjangoBundle; -import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; +import com.jetbrains.env.community.PyExecutionFixtureTestTask; import com.jetbrains.python.PythonHelpersLocator; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import com.jetbrains.python.run.PythonTracebackFilter; diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java index 4ac8c45de9fd..b60af2d9db13 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java @@ -5,7 +5,7 @@ import com.intellij.execution.configurations.ConfigurationFactory; import com.intellij.openapi.util.io.FileUtil; import com.jetbrains.django.run.DjangoServerRunConfiguration; import com.jetbrains.django.run.DjangoServerRunConfigurationType; -import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.community.PyEnvTestCase; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import junit.framework.Assert; import org.jetbrains.annotations.Nullable; diff --git a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java index 135aff0cffde..59143a0e7b37 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java @@ -13,8 +13,8 @@ import com.intellij.testFramework.UsefulTestCase; import com.jetbrains.django.DjangoNames; import com.jetbrains.django.model.DjangoAdmin; import com.jetbrains.django.util.DjangoUtil; -import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.env.python.debug.PyExecutionFixtureTestTask; +import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.community.PyExecutionFixtureTestTask; import com.jetbrains.python.psi.PyFile; import com.jetbrains.python.psi.PyUtil; import com.jetbrains.python.psi.impl.blockEvaluator.PyBlockEvaluator; diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java index 66a3b3233c1b..bf1f98f76726 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java @@ -4,7 +4,7 @@ import com.google.common.collect.Sets; import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; import com.intellij.xdebugger.XDebuggerTestUtil; import com.jetbrains.django.util.VirtualFileUtil; -import com.jetbrains.env.python.debug.PyEnvTestCase; +import com.jetbrains.env.community.PyEnvTestCase; import com.jetbrains.python.debugger.django.DjangoExceptionBreakpointProperties; import com.jetbrains.python.debugger.django.DjangoExceptionBreakpointType; diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java index fec5ea404c25..28c23802c3a7 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java @@ -9,8 +9,11 @@ import com.jetbrains.django.facet.DjangoFacet; import com.jetbrains.django.facet.DjangoFacetConfiguration; import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; import com.jetbrains.django.testRunner.DjangoTestsRunConfiguration; -import com.jetbrains.env.python.debug.PyEnvTestCase; -import com.jetbrains.python.packaging.*; +import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.python.packaging.PyExternalProcessException; +import com.jetbrains.python.packaging.PyPackage; +import com.jetbrains.python.packaging.PyPackageManager; +import com.jetbrains.python.packaging.PyRequirement; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; diff --git a/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java b/python/testSrc/com/jetbrains/env/remote/PyRemoteDebuggerTask.java similarity index 98% rename from python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java rename to python/testSrc/com/jetbrains/env/remote/PyRemoteDebuggerTask.java index a9fae7bf0cbf..7921c029fca4 100644 --- a/python/testSrc/com/jetbrains/env/python/debug/PyRemoteDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/remote/PyRemoteDebuggerTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.python.debug; +package com.jetbrains.env.remote; import com.intellij.execution.*; import com.intellij.execution.configurations.ConfigurationFactory; @@ -15,6 +15,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Key; import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.*; +import com.jetbrains.env.community.python.debug.PyBaseDebuggerTask; import com.jetbrains.python.PythonHelpersLocator; import com.jetbrains.python.debugger.remote.*; import com.jetbrains.python.debugger.remote.vfs.PyRemotePositionConverter; diff --git a/python/testSrc/com/jetbrains/env/remote/PyRemoteDebuggerTest.java b/python/testSrc/com/jetbrains/env/remote/PyRemoteDebuggerTest.java new file mode 100644 index 000000000000..0952a175bc75 --- /dev/null +++ b/python/testSrc/com/jetbrains/env/remote/PyRemoteDebuggerTest.java @@ -0,0 +1,85 @@ +package com.jetbrains.env.remote; + +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.projectRoots.ProjectJdkTable; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.util.ui.UIUtil; +import com.jetbrains.env.community.PyEnvTaskRunner; +import com.jetbrains.env.community.PyExecutionFixtureTestTask; +import com.jetbrains.env.community.PyTestTask; +import com.jetbrains.env.community.python.PythonDebuggerTest; +import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; +import org.jetbrains.annotations.Nullable; + +import java.util.List; + +/** + * @author traff + */ +public class PyRemoteDebuggerTest extends PythonDebuggerTest { + @Override + protected void doRunTests(PyTestTask testTask, String testName, List roots) { + if (RUN_REMOTE && PyTestRemoteSdkProvider.shouldRunRemoteSdk(testTask)) { + if (PyTestRemoteSdkProvider.canRunRemoteSdk()) { + PyEnvTaskRunner remoteRunner = new RemoteTaskRunner(roots); + remoteRunner.runTask(testTask, testName); + } + else { + if (PyTestRemoteSdkProvider.shouldFailWhenCantRunRemote()) { + fail("Cant run with remote sdk: password isn't set"); + } + } + } + } + + private static class RemoteTaskRunner extends PyEnvTaskRunner { + private RemoteTaskRunner(List roots) { + super(roots); + } + + @Override + protected String getExecutable(String root, PyTestTask testTask) { + try { + final Sdk sdk = PyTestRemoteSdkProvider.getInstance().getSdk(getProject(testTask), super.getExecutable(root, testTask)); + + if (ProjectJdkTable.getInstance().findJdk(sdk.getName()) == null) { + UIUtil.invokeAndWaitIfNeeded(new Runnable() { + @Override + public void run() { + ApplicationManager.getApplication().runWriteAction(new Runnable() { + @Override + public void run() { + ProjectJdkTable.getInstance().addJdk(sdk); + } + }); + } + }); + } + + return ((PyRemoteSdkAdditionalData)sdk.getSdkAdditionalData()).getRemoteSdkCredentials(false).getSdkId(); + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + + @Nullable + public Project getProject(PyTestTask task) { + if (task instanceof PyExecutionFixtureTestTask) { + return ((PyExecutionFixtureTestTask)task).getProject(); + } + return null; + } + + @Override + protected boolean shouldRun(String root, PyTestTask task) { + return !isJython(super.getExecutable(root, task)); //TODO: make remote tests work for jython + } + + @Override + protected String getEnvType() { + return "remote"; + } + } +} diff --git a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java b/python/testSrc/com/jetbrains/env/remote/PyTestRemoteSdkProvider.java similarity index 96% rename from python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java rename to python/testSrc/com/jetbrains/env/remote/PyTestRemoteSdkProvider.java index 6dfcc5d6bbcf..53798308c072 100644 --- a/python/testSrc/com/jetbrains/env/PyTestRemoteSdkProvider.java +++ b/python/testSrc/com/jetbrains/env/remote/PyTestRemoteSdkProvider.java @@ -1,4 +1,4 @@ -package com.jetbrains.env; +package com.jetbrains.env.remote; import com.google.common.cache.CacheBuilder; import com.google.common.cache.CacheLoader; @@ -14,7 +14,7 @@ import com.intellij.remote.RemoteCredentialsHolder; import com.intellij.remote.RemoteSdkException; import com.intellij.testFramework.UsefulTestCase; import com.intellij.util.ui.UIUtil; -import com.jetbrains.env.python.debug.PyTestTask; +import com.jetbrains.env.community.PyTestTask; import com.jetbrains.python.remote.PyRemoteInterpreterManagerImpl; import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; import org.jetbrains.annotations.NotNull; @@ -133,6 +133,6 @@ public class PyTestRemoteSdkProvider { } public static boolean shouldRunRemoteSdk(PyTestTask task) { - return SystemInfo.isUnix && task instanceof RemoteSdkTestable; + return SystemInfo.isUnix; } } From c17baa0668c5506d687ed2b962e92f02b3cf52ea Mon Sep 17 00:00:00 2001 From: Dmitry Trofimov Date: Tue, 12 Aug 2014 21:05:38 +0200 Subject: [PATCH 183/183] Move community env tests back to env package. --- .../env/{community => }/PyEnvSufficiencyTest.java | 2 +- .../jetbrains/env/{community => }/PyEnvTaskRunner.java | 2 +- .../com/jetbrains/env/{community => }/PyEnvTestCase.java | 2 +- .../env/{community => }/PyExecutionFixtureTestTask.java | 2 +- .../com/jetbrains/env/{community => }/PyTestTask.java | 2 +- .../com/jetbrains/env/django/DjangoEnvTestTask.java | 2 +- .../jetbrains/env/django/DjangoManageTaskActionsTest.java | 2 +- .../com/jetbrains/env/django/DjangoManageTestTask.java | 2 +- .../testSrc/com/jetbrains/env/django/DjangoPathTest.java | 2 +- .../jetbrains/env/django/DjangoProjectCreationTest.java | 4 ++-- .../jetbrains/env/django/DjangoTemplateDebuggerTest.java | 2 +- .../com/jetbrains/env/django/DjangoTestRunnerTest.java | 2 +- .../env/{community => }/python/IPythonConsoleTest.java | 6 +++--- .../python/PyPackageRequirementsInspectionTest.java | 6 +++--- .../env/{community => }/python/PyPackagingTest.java | 8 ++++---- .../env/{community => }/python/PythonConsoleTest.java | 6 +++--- .../env/{community => }/python/PythonDebuggerTest.java | 8 ++++---- .../env/{community => }/python/PythonGeneratorTest.java | 6 +++--- .../env/{community => }/python/PythonSkeletonsTest.java | 8 ++++---- .../env/{community => }/python/console/PyConsoleTask.java | 4 ++-- .../{community => }/python/debug/PyBaseDebuggerTask.java | 4 ++-- .../env/{community => }/python/debug/PyDebuggerTask.java | 2 +- .../{community => }/python/dotNet/PyIronPythonTest.java | 4 ++-- .../{community => }/python/dotNet/SkeletonTestTask.java | 4 ++-- .../env/{community => }/python/dotNet/package-info.java | 2 +- .../python/testing/PythonDocTestingTest.java | 6 +++--- .../python/testing/PythonNoseTestingTest.java | 6 +++--- .../python/testing/PythonPyTestingTest.java | 6 +++--- .../python/testing/PythonUnitTestingTest.java | 6 +++--- .../com/jetbrains/env/remote/PyRemoteDebuggerTask.java | 2 +- .../com/jetbrains/env/remote/PyRemoteDebuggerTest.java | 8 ++++---- .../com/jetbrains/env/remote/PyTestRemoteSdkProvider.java | 2 +- .../jetbrains/env/{community => }/ut/PyDocTestTask.java | 2 +- .../jetbrains/env/{community => }/ut/PyNoseTestTask.java | 2 +- .../jetbrains/env/{community => }/ut/PyTestTestTask.java | 2 +- .../jetbrains/env/{community => }/ut/PyUnitTestTask.java | 4 ++-- 36 files changed, 70 insertions(+), 70 deletions(-) rename python/testSrc/com/jetbrains/env/{community => }/PyEnvSufficiencyTest.java (97%) rename python/testSrc/com/jetbrains/env/{community => }/PyEnvTaskRunner.java (98%) rename python/testSrc/com/jetbrains/env/{community => }/PyEnvTestCase.java (99%) rename python/testSrc/com/jetbrains/env/{community => }/PyExecutionFixtureTestTask.java (99%) rename python/testSrc/com/jetbrains/env/{community => }/PyTestTask.java (97%) rename python/testSrc/com/jetbrains/env/{community => }/python/IPythonConsoleTest.java (94%) rename python/testSrc/com/jetbrains/env/{community => }/python/PyPackageRequirementsInspectionTest.java (94%) rename python/testSrc/com/jetbrains/env/{community => }/python/PyPackagingTest.java (97%) rename python/testSrc/com/jetbrains/env/{community => }/python/PythonConsoleTest.java (95%) rename python/testSrc/com/jetbrains/env/{community => }/python/PythonDebuggerTest.java (98%) rename python/testSrc/com/jetbrains/env/{community => }/python/PythonGeneratorTest.java (75%) rename python/testSrc/com/jetbrains/env/{community => }/python/PythonSkeletonsTest.java (97%) rename python/testSrc/com/jetbrains/env/{community => }/python/console/PyConsoleTask.java (98%) rename python/testSrc/com/jetbrains/env/{community => }/python/debug/PyBaseDebuggerTask.java (98%) rename python/testSrc/com/jetbrains/env/{community => }/python/debug/PyDebuggerTask.java (99%) rename python/testSrc/com/jetbrains/env/{community => }/python/dotNet/PyIronPythonTest.java (97%) rename python/testSrc/com/jetbrains/env/{community => }/python/dotNet/SkeletonTestTask.java (98%) rename python/testSrc/com/jetbrains/env/{community => }/python/dotNet/package-info.java (79%) rename python/testSrc/com/jetbrains/env/{community => }/python/testing/PythonDocTestingTest.java (90%) rename python/testSrc/com/jetbrains/env/{community => }/python/testing/PythonNoseTestingTest.java (81%) rename python/testSrc/com/jetbrains/env/{community => }/python/testing/PythonPyTestingTest.java (81%) rename python/testSrc/com/jetbrains/env/{community => }/python/testing/PythonUnitTestingTest.java (92%) rename python/testSrc/com/jetbrains/env/{community => }/ut/PyDocTestTask.java (95%) rename python/testSrc/com/jetbrains/env/{community => }/ut/PyNoseTestTask.java (95%) rename python/testSrc/com/jetbrains/env/{community => }/ut/PyTestTestTask.java (96%) rename python/testSrc/com/jetbrains/env/{community => }/ut/PyUnitTestTask.java (98%) diff --git a/python/testSrc/com/jetbrains/env/community/PyEnvSufficiencyTest.java b/python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java similarity index 97% rename from python/testSrc/com/jetbrains/env/community/PyEnvSufficiencyTest.java rename to python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java index 61b64dfee5bf..83846a1bb5f5 100644 --- a/python/testSrc/com/jetbrains/env/community/PyEnvSufficiencyTest.java +++ b/python/testSrc/com/jetbrains/env/PyEnvSufficiencyTest.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community; +package com.jetbrains.env; import com.google.common.collect.ImmutableList; import com.google.common.collect.Lists; diff --git a/python/testSrc/com/jetbrains/env/community/PyEnvTaskRunner.java b/python/testSrc/com/jetbrains/env/PyEnvTaskRunner.java similarity index 98% rename from python/testSrc/com/jetbrains/env/community/PyEnvTaskRunner.java rename to python/testSrc/com/jetbrains/env/PyEnvTaskRunner.java index aab5f969da28..baabd5a5e5e1 100644 --- a/python/testSrc/com/jetbrains/env/community/PyEnvTaskRunner.java +++ b/python/testSrc/com/jetbrains/env/PyEnvTaskRunner.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community; +package com.jetbrains.env; import com.google.common.collect.Lists; import com.google.common.collect.Sets; diff --git a/python/testSrc/com/jetbrains/env/community/PyEnvTestCase.java b/python/testSrc/com/jetbrains/env/PyEnvTestCase.java similarity index 99% rename from python/testSrc/com/jetbrains/env/community/PyEnvTestCase.java rename to python/testSrc/com/jetbrains/env/PyEnvTestCase.java index 5f07b29a1639..853a5504de63 100644 --- a/python/testSrc/com/jetbrains/env/community/PyEnvTestCase.java +++ b/python/testSrc/com/jetbrains/env/PyEnvTestCase.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community; +package com.jetbrains.env; import com.google.common.collect.Lists; import com.intellij.openapi.application.ApplicationManager; diff --git a/python/testSrc/com/jetbrains/env/community/PyExecutionFixtureTestTask.java b/python/testSrc/com/jetbrains/env/PyExecutionFixtureTestTask.java similarity index 99% rename from python/testSrc/com/jetbrains/env/community/PyExecutionFixtureTestTask.java rename to python/testSrc/com/jetbrains/env/PyExecutionFixtureTestTask.java index 2c48c1b6da8f..f42fd9721c67 100644 --- a/python/testSrc/com/jetbrains/env/community/PyExecutionFixtureTestTask.java +++ b/python/testSrc/com/jetbrains/env/PyExecutionFixtureTestTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community; +package com.jetbrains.env; import com.google.common.collect.Lists; import com.intellij.execution.process.ProcessHandler; diff --git a/python/testSrc/com/jetbrains/env/community/PyTestTask.java b/python/testSrc/com/jetbrains/env/PyTestTask.java similarity index 97% rename from python/testSrc/com/jetbrains/env/community/PyTestTask.java rename to python/testSrc/com/jetbrains/env/PyTestTask.java index 61e81d08110d..bfc1a688ebfa 100644 --- a/python/testSrc/com/jetbrains/env/community/PyTestTask.java +++ b/python/testSrc/com/jetbrains/env/PyTestTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community; +package com.jetbrains.env; import com.google.common.collect.Sets; import com.intellij.openapi.util.io.FileUtil; diff --git a/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java index 7755b840080a..7e87e9fd8cb2 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoEnvTestTask.java @@ -9,7 +9,7 @@ import com.intellij.openapi.vfs.VirtualFile; import com.intellij.util.ui.UIUtil; import com.jetbrains.django.facet.DjangoFacet; import com.jetbrains.django.fixtures.DjangoTestCase; -import com.jetbrains.env.community.python.debug.PyDebuggerTask; +import com.jetbrains.env.python.debug.PyDebuggerTask; import com.jetbrains.python.fixtures.PyProfessionalTestCase; import com.jetbrains.python.templateLanguages.TemplatesService; import org.junit.Assert; diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java index cc3b4c17c748..ca3f2c23fd18 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTaskActionsTest.java @@ -7,7 +7,7 @@ import com.jetbrains.django.actions.manage.ManageTaskActions; import com.jetbrains.django.manage.BaseCommand; import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; import com.jetbrains.django.util.DjangoUtil; -import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.PyEnvTestCase; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import org.jetbrains.annotations.Nullable; import org.junit.Assert; diff --git a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java index 446939b9ec7e..f476ac99aadb 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoManageTestTask.java @@ -29,7 +29,7 @@ import com.jetbrains.django.fixtures.DjangoTestCase; import com.jetbrains.django.manage.DjangoManageTask; import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; import com.jetbrains.django.ui.DjangoBundle; -import com.jetbrains.env.community.PyExecutionFixtureTestTask; +import com.jetbrains.env.PyExecutionFixtureTestTask; import com.jetbrains.python.PythonHelpersLocator; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import com.jetbrains.python.run.PythonTracebackFilter; diff --git a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java index b60af2d9db13..c98d26f9ca60 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoPathTest.java @@ -5,7 +5,7 @@ import com.intellij.execution.configurations.ConfigurationFactory; import com.intellij.openapi.util.io.FileUtil; import com.jetbrains.django.run.DjangoServerRunConfiguration; import com.jetbrains.django.run.DjangoServerRunConfigurationType; -import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.PyEnvTestCase; import com.jetbrains.python.run.AbstractPythonRunConfiguration; import junit.framework.Assert; import org.jetbrains.annotations.Nullable; diff --git a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java index 59143a0e7b37..7d977dc9cebd 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoProjectCreationTest.java @@ -13,8 +13,8 @@ import com.intellij.testFramework.UsefulTestCase; import com.jetbrains.django.DjangoNames; import com.jetbrains.django.model.DjangoAdmin; import com.jetbrains.django.util.DjangoUtil; -import com.jetbrains.env.community.PyEnvTestCase; -import com.jetbrains.env.community.PyExecutionFixtureTestTask; +import com.jetbrains.env.PyEnvTestCase; +import com.jetbrains.env.PyExecutionFixtureTestTask; import com.jetbrains.python.psi.PyFile; import com.jetbrains.python.psi.PyUtil; import com.jetbrains.python.psi.impl.blockEvaluator.PyBlockEvaluator; diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java index bf1f98f76726..1cda9ed3a533 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTemplateDebuggerTest.java @@ -4,7 +4,7 @@ import com.google.common.collect.Sets; import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; import com.intellij.xdebugger.XDebuggerTestUtil; import com.jetbrains.django.util.VirtualFileUtil; -import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.PyEnvTestCase; import com.jetbrains.python.debugger.django.DjangoExceptionBreakpointProperties; import com.jetbrains.python.debugger.django.DjangoExceptionBreakpointType; diff --git a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java index 28c23802c3a7..9be764dd6eb6 100644 --- a/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java +++ b/python/testSrc/com/jetbrains/env/django/DjangoTestRunnerTest.java @@ -9,7 +9,7 @@ import com.jetbrains.django.facet.DjangoFacet; import com.jetbrains.django.facet.DjangoFacetConfiguration; import com.jetbrains.django.testRunner.DjangoTestsConfigurationType; import com.jetbrains.django.testRunner.DjangoTestsRunConfiguration; -import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.PyEnvTestCase; import com.jetbrains.python.packaging.PyExternalProcessException; import com.jetbrains.python.packaging.PyPackage; import com.jetbrains.python.packaging.PyPackageManager; diff --git a/python/testSrc/com/jetbrains/env/community/python/IPythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java similarity index 94% rename from python/testSrc/com/jetbrains/env/community/python/IPythonConsoleTest.java rename to python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java index a67503e8d586..a039344451d4 100644 --- a/python/testSrc/com/jetbrains/env/community/python/IPythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/python/IPythonConsoleTest.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community.python; +package com.jetbrains.env.python; import com.google.common.base.Function; import com.google.common.collect.Collections2; @@ -8,8 +8,8 @@ import com.intellij.psi.PsiDocumentManager; import com.intellij.psi.PsiErrorElement; import com.intellij.psi.PsiFile; import com.intellij.psi.util.PsiTreeUtil; -import com.jetbrains.env.community.PyEnvTestCase; -import com.jetbrains.env.community.python.console.PyConsoleTask; +import com.jetbrains.env.PyEnvTestCase; +import com.jetbrains.env.python.console.PyConsoleTask; import org.hamcrest.Matchers; import org.jetbrains.annotations.NotNull; import org.junit.Assert; diff --git a/python/testSrc/com/jetbrains/env/community/python/PyPackageRequirementsInspectionTest.java b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java similarity index 94% rename from python/testSrc/com/jetbrains/env/community/python/PyPackageRequirementsInspectionTest.java rename to python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java index cda73ca8b50d..8e3b75dd56a0 100644 --- a/python/testSrc/com/jetbrains/env/community/python/PyPackageRequirementsInspectionTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackageRequirementsInspectionTest.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community.python; +package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; import com.intellij.openapi.module.Module; @@ -6,8 +6,8 @@ import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.roots.ModuleRootModificationUtil; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.testFramework.PsiTestUtil; -import com.jetbrains.env.community.PyEnvTestCase; -import com.jetbrains.env.community.PyExecutionFixtureTestTask; +import com.jetbrains.env.PyEnvTestCase; +import com.jetbrains.env.PyExecutionFixtureTestTask; import com.jetbrains.python.PythonTestUtil; import com.jetbrains.python.inspections.PyPackageRequirementsInspection; import com.jetbrains.python.sdkTools.SdkCreationType; diff --git a/python/testSrc/com/jetbrains/env/community/python/PyPackagingTest.java b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java similarity index 97% rename from python/testSrc/com/jetbrains/env/community/python/PyPackagingTest.java rename to python/testSrc/com/jetbrains/env/python/PyPackagingTest.java index c8e1197b2ba5..54afb702322b 100644 --- a/python/testSrc/com/jetbrains/env/community/python/PyPackagingTest.java +++ b/python/testSrc/com/jetbrains/env/python/PyPackagingTest.java @@ -1,13 +1,13 @@ -package com.jetbrains.env.community.python; +package com.jetbrains.env.python; import com.google.common.collect.Sets; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; import com.intellij.testFramework.UsefulTestCase; -import com.jetbrains.env.community.PyEnvTestCase; -import com.jetbrains.env.community.PyExecutionFixtureTestTask; -import com.jetbrains.env.community.PyTestTask; +import com.jetbrains.env.PyEnvTestCase; +import com.jetbrains.env.PyExecutionFixtureTestTask; +import com.jetbrains.env.PyTestTask; import com.jetbrains.python.packaging.*; import com.jetbrains.python.psi.LanguageLevel; import com.jetbrains.python.sdk.PythonSdkType; diff --git a/python/testSrc/com/jetbrains/env/community/python/PythonConsoleTest.java b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java similarity index 95% rename from python/testSrc/com/jetbrains/env/community/python/PythonConsoleTest.java rename to python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java index 534dd13e7653..4134b1697851 100644 --- a/python/testSrc/com/jetbrains/env/community/python/PythonConsoleTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonConsoleTest.java @@ -1,8 +1,8 @@ -package com.jetbrains.env.community.python; +package com.jetbrains.env.python; import com.google.common.collect.Sets; -import com.jetbrains.env.community.PyEnvTestCase; -import com.jetbrains.env.community.python.console.PyConsoleTask; +import com.jetbrains.env.PyEnvTestCase; +import com.jetbrains.env.python.console.PyConsoleTask; import org.junit.Assert; import java.util.Collections; diff --git a/python/testSrc/com/jetbrains/env/community/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java similarity index 98% rename from python/testSrc/com/jetbrains/env/community/python/PythonDebuggerTest.java rename to python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index 9db598652821..4372715371eb 100644 --- a/python/testSrc/com/jetbrains/env/community/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -1,13 +1,13 @@ -package com.jetbrains.env.community.python; +package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; import com.google.common.collect.Sets; import com.intellij.testFramework.fixtures.IdeaProjectTestFixture; import com.intellij.xdebugger.XDebuggerTestUtil; -import com.jetbrains.env.community.PyEnvTestCase; -import com.jetbrains.env.community.python.debug.PyDebuggerTask; -import com.jetbrains.env.community.ut.PyUnitTestTask; +import com.jetbrains.env.PyEnvTestCase; +import com.jetbrains.env.python.debug.PyDebuggerTask; +import com.jetbrains.env.ut.PyUnitTestTask; import com.jetbrains.python.PythonHelpersLocator; import com.jetbrains.python.console.pydev.PydevCompletionVariant; import com.jetbrains.python.debugger.PyDebuggerException; diff --git a/python/testSrc/com/jetbrains/env/community/python/PythonGeneratorTest.java b/python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java similarity index 75% rename from python/testSrc/com/jetbrains/env/community/python/PythonGeneratorTest.java rename to python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java index f28344ea834d..273cb3f94011 100644 --- a/python/testSrc/com/jetbrains/env/community/python/PythonGeneratorTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonGeneratorTest.java @@ -1,7 +1,7 @@ -package com.jetbrains.env.community.python; +package com.jetbrains.env.python; -import com.jetbrains.env.community.PyEnvTestCase; -import com.jetbrains.env.community.ut.PyUnitTestTask; +import com.jetbrains.env.PyEnvTestCase; +import com.jetbrains.env.ut.PyUnitTestTask; import com.jetbrains.python.PythonHelpersLocator; /** diff --git a/python/testSrc/com/jetbrains/env/community/python/PythonSkeletonsTest.java b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java similarity index 97% rename from python/testSrc/com/jetbrains/env/community/python/PythonSkeletonsTest.java rename to python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java index de34949aca58..c6b150f31359 100644 --- a/python/testSrc/com/jetbrains/env/community/python/PythonSkeletonsTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonSkeletonsTest.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community.python; +package com.jetbrains.env.python; import com.google.common.collect.ImmutableSet; import com.intellij.openapi.application.ApplicationManager; @@ -9,9 +9,9 @@ import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiFile; -import com.jetbrains.env.community.PyEnvTestCase; -import com.jetbrains.env.community.PyExecutionFixtureTestTask; -import com.jetbrains.env.community.PyTestTask; +import com.jetbrains.env.PyEnvTestCase; +import com.jetbrains.env.PyExecutionFixtureTestTask; +import com.jetbrains.env.PyTestTask; import com.jetbrains.python.PythonFileType; import com.jetbrains.python.PythonTestUtil; import com.jetbrains.python.documentation.PythonDocumentationProvider; diff --git a/python/testSrc/com/jetbrains/env/community/python/console/PyConsoleTask.java b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java similarity index 98% rename from python/testSrc/com/jetbrains/env/community/python/console/PyConsoleTask.java rename to python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java index d43ce0a10232..9a242934042d 100644 --- a/python/testSrc/com/jetbrains/env/community/python/console/PyConsoleTask.java +++ b/python/testSrc/com/jetbrains/env/python/console/PyConsoleTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community.python.console; +package com.jetbrains.env.python.console; import com.google.common.collect.Lists; import com.intellij.execution.console.LanguageConsoleView; @@ -13,7 +13,7 @@ import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiDocumentManager; import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.frame.XValueChildrenList; -import com.jetbrains.env.community.PyExecutionFixtureTestTask; +import com.jetbrains.env.PyExecutionFixtureTestTask; import com.jetbrains.python.console.*; import com.jetbrains.python.console.pydev.ConsoleCommunicationListener; import com.jetbrains.python.debugger.PyDebugValue; diff --git a/python/testSrc/com/jetbrains/env/community/python/debug/PyBaseDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java similarity index 98% rename from python/testSrc/com/jetbrains/env/community/python/debug/PyBaseDebuggerTask.java rename to python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java index b3426fc24b54..4cbe159f7cc7 100644 --- a/python/testSrc/com/jetbrains/env/community/python/debug/PyBaseDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyBaseDebuggerTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community.python.debug; +package com.jetbrains.env.python.debug; import com.google.common.collect.Sets; import com.intellij.openapi.application.Result; @@ -12,7 +12,7 @@ import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.*; import com.intellij.xdebugger.frame.XValue; import com.jetbrains.django.util.VirtualFileUtil; -import com.jetbrains.env.community.PyExecutionFixtureTestTask; +import com.jetbrains.env.PyExecutionFixtureTestTask; import com.jetbrains.python.console.PythonDebugLanguageConsoleView; import com.jetbrains.python.debugger.PyDebugProcess; import com.jetbrains.python.debugger.PyDebugValue; diff --git a/python/testSrc/com/jetbrains/env/community/python/debug/PyDebuggerTask.java b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java similarity index 99% rename from python/testSrc/com/jetbrains/env/community/python/debug/PyDebuggerTask.java rename to python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java index d2923f34a3ad..7de13d1ebed6 100644 --- a/python/testSrc/com/jetbrains/env/community/python/debug/PyDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/python/debug/PyDebuggerTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community.python.debug; +package com.jetbrains.env.python.debug; import com.intellij.execution.*; import com.intellij.execution.configurations.ConfigurationFactory; diff --git a/python/testSrc/com/jetbrains/env/community/python/dotNet/PyIronPythonTest.java b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java similarity index 97% rename from python/testSrc/com/jetbrains/env/community/python/dotNet/PyIronPythonTest.java rename to python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java index 70f9b2453419..a6f9dd68971d 100644 --- a/python/testSrc/com/jetbrains/env/community/python/dotNet/PyIronPythonTest.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/PyIronPythonTest.java @@ -1,8 +1,8 @@ -package com.jetbrains.env.community.python.dotNet; +package com.jetbrains.env.python.dotNet; import com.intellij.openapi.application.ReadAction; import com.intellij.openapi.application.Result; -import com.jetbrains.env.community.PyEnvTestCase; +import com.jetbrains.env.PyEnvTestCase; import com.jetbrains.python.psi.PyFile; import org.jetbrains.annotations.NotNull; import org.junit.Assert; diff --git a/python/testSrc/com/jetbrains/env/community/python/dotNet/SkeletonTestTask.java b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java similarity index 98% rename from python/testSrc/com/jetbrains/env/community/python/dotNet/SkeletonTestTask.java rename to python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java index f2b788b82848..e10916cbe7de 100644 --- a/python/testSrc/com/jetbrains/env/community/python/dotNet/SkeletonTestTask.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/SkeletonTestTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community.python.dotNet; +package com.jetbrains.env.python.dotNet; import com.google.common.collect.Sets; import com.intellij.codeInsight.intention.IntentionAction; @@ -11,7 +11,7 @@ import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.util.io.FileUtil; import com.intellij.psi.PsiDocumentManager; import com.intellij.util.ui.UIUtil; -import com.jetbrains.env.community.PyExecutionFixtureTestTask; +import com.jetbrains.env.PyExecutionFixtureTestTask; import com.jetbrains.python.PyBundle; import com.jetbrains.python.PyNames; import com.jetbrains.python.inspections.quickfix.GenerateBinaryStubsFix; diff --git a/python/testSrc/com/jetbrains/env/community/python/dotNet/package-info.java b/python/testSrc/com/jetbrains/env/python/dotNet/package-info.java similarity index 79% rename from python/testSrc/com/jetbrains/env/community/python/dotNet/package-info.java rename to python/testSrc/com/jetbrains/env/python/dotNet/package-info.java index 9facb61f3be3..e56e6203b98d 100644 --- a/python/testSrc/com/jetbrains/env/community/python/dotNet/package-info.java +++ b/python/testSrc/com/jetbrains/env/python/dotNet/package-info.java @@ -2,4 +2,4 @@ * IronPython tests. Install IronPython, .NET and add "iron" to "tags.txt" file. Check for more info: http://confluence.jetbrains.com/display/PYINT/Env+Tests * @author Ilya.Kazakevich */ -package com.jetbrains.env.community.python.dotNet; \ No newline at end of file +package com.jetbrains.env.python.dotNet; \ No newline at end of file diff --git a/python/testSrc/com/jetbrains/env/community/python/testing/PythonDocTestingTest.java b/python/testSrc/com/jetbrains/env/python/testing/PythonDocTestingTest.java similarity index 90% rename from python/testSrc/com/jetbrains/env/community/python/testing/PythonDocTestingTest.java rename to python/testSrc/com/jetbrains/env/python/testing/PythonDocTestingTest.java index 178673fa30c3..411b6049350a 100644 --- a/python/testSrc/com/jetbrains/env/community/python/testing/PythonDocTestingTest.java +++ b/python/testSrc/com/jetbrains/env/python/testing/PythonDocTestingTest.java @@ -1,7 +1,7 @@ -package com.jetbrains.env.community.python.testing; +package com.jetbrains.env.python.testing; -import com.jetbrains.env.community.PyEnvTestCase; -import com.jetbrains.env.community.ut.PyDocTestTask; +import com.jetbrains.env.PyEnvTestCase; +import com.jetbrains.env.ut.PyDocTestTask; /** * User : catherine diff --git a/python/testSrc/com/jetbrains/env/community/python/testing/PythonNoseTestingTest.java b/python/testSrc/com/jetbrains/env/python/testing/PythonNoseTestingTest.java similarity index 81% rename from python/testSrc/com/jetbrains/env/community/python/testing/PythonNoseTestingTest.java rename to python/testSrc/com/jetbrains/env/python/testing/PythonNoseTestingTest.java index 7bc3d438e9db..33250ae17fa4 100644 --- a/python/testSrc/com/jetbrains/env/community/python/testing/PythonNoseTestingTest.java +++ b/python/testSrc/com/jetbrains/env/python/testing/PythonNoseTestingTest.java @@ -1,7 +1,7 @@ -package com.jetbrains.env.community.python.testing; +package com.jetbrains.env.python.testing; -import com.jetbrains.env.community.PyEnvTestCase; -import com.jetbrains.env.community.ut.PyNoseTestTask; +import com.jetbrains.env.PyEnvTestCase; +import com.jetbrains.env.ut.PyNoseTestTask; /** * User : catherine diff --git a/python/testSrc/com/jetbrains/env/community/python/testing/PythonPyTestingTest.java b/python/testSrc/com/jetbrains/env/python/testing/PythonPyTestingTest.java similarity index 81% rename from python/testSrc/com/jetbrains/env/community/python/testing/PythonPyTestingTest.java rename to python/testSrc/com/jetbrains/env/python/testing/PythonPyTestingTest.java index 94463b89ae27..ab3dee60c5b0 100644 --- a/python/testSrc/com/jetbrains/env/community/python/testing/PythonPyTestingTest.java +++ b/python/testSrc/com/jetbrains/env/python/testing/PythonPyTestingTest.java @@ -1,7 +1,7 @@ -package com.jetbrains.env.community.python.testing; +package com.jetbrains.env.python.testing; -import com.jetbrains.env.community.PyEnvTestCase; -import com.jetbrains.env.community.ut.PyTestTestTask; +import com.jetbrains.env.PyEnvTestCase; +import com.jetbrains.env.ut.PyTestTestTask; /** * User : catherine diff --git a/python/testSrc/com/jetbrains/env/community/python/testing/PythonUnitTestingTest.java b/python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java similarity index 92% rename from python/testSrc/com/jetbrains/env/community/python/testing/PythonUnitTestingTest.java rename to python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java index 892db6c8bdee..682eb8160285 100644 --- a/python/testSrc/com/jetbrains/env/community/python/testing/PythonUnitTestingTest.java +++ b/python/testSrc/com/jetbrains/env/python/testing/PythonUnitTestingTest.java @@ -1,7 +1,7 @@ -package com.jetbrains.env.community.python.testing; +package com.jetbrains.env.python.testing; -import com.jetbrains.env.community.PyEnvTestCase; -import com.jetbrains.env.community.ut.PyUnitTestTask; +import com.jetbrains.env.PyEnvTestCase; +import com.jetbrains.env.ut.PyUnitTestTask; import junit.framework.Assert; /** diff --git a/python/testSrc/com/jetbrains/env/remote/PyRemoteDebuggerTask.java b/python/testSrc/com/jetbrains/env/remote/PyRemoteDebuggerTask.java index 7921c029fca4..844dd61e02a0 100644 --- a/python/testSrc/com/jetbrains/env/remote/PyRemoteDebuggerTask.java +++ b/python/testSrc/com/jetbrains/env/remote/PyRemoteDebuggerTask.java @@ -15,7 +15,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Key; import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.*; -import com.jetbrains.env.community.python.debug.PyBaseDebuggerTask; +import com.jetbrains.env.python.debug.PyBaseDebuggerTask; import com.jetbrains.python.PythonHelpersLocator; import com.jetbrains.python.debugger.remote.*; import com.jetbrains.python.debugger.remote.vfs.PyRemotePositionConverter; diff --git a/python/testSrc/com/jetbrains/env/remote/PyRemoteDebuggerTest.java b/python/testSrc/com/jetbrains/env/remote/PyRemoteDebuggerTest.java index 0952a175bc75..c76bb26e1e65 100644 --- a/python/testSrc/com/jetbrains/env/remote/PyRemoteDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/remote/PyRemoteDebuggerTest.java @@ -5,10 +5,10 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.ProjectJdkTable; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.util.ui.UIUtil; -import com.jetbrains.env.community.PyEnvTaskRunner; -import com.jetbrains.env.community.PyExecutionFixtureTestTask; -import com.jetbrains.env.community.PyTestTask; -import com.jetbrains.env.community.python.PythonDebuggerTest; +import com.jetbrains.env.PyEnvTaskRunner; +import com.jetbrains.env.PyExecutionFixtureTestTask; +import com.jetbrains.env.PyTestTask; +import com.jetbrains.env.python.PythonDebuggerTest; import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; import org.jetbrains.annotations.Nullable; diff --git a/python/testSrc/com/jetbrains/env/remote/PyTestRemoteSdkProvider.java b/python/testSrc/com/jetbrains/env/remote/PyTestRemoteSdkProvider.java index 53798308c072..743082c9bfba 100644 --- a/python/testSrc/com/jetbrains/env/remote/PyTestRemoteSdkProvider.java +++ b/python/testSrc/com/jetbrains/env/remote/PyTestRemoteSdkProvider.java @@ -14,7 +14,7 @@ import com.intellij.remote.RemoteCredentialsHolder; import com.intellij.remote.RemoteSdkException; import com.intellij.testFramework.UsefulTestCase; import com.intellij.util.ui.UIUtil; -import com.jetbrains.env.community.PyTestTask; +import com.jetbrains.env.PyTestTask; import com.jetbrains.python.remote.PyRemoteInterpreterManagerImpl; import com.jetbrains.python.remote.PyRemoteSdkAdditionalData; import org.jetbrains.annotations.NotNull; diff --git a/python/testSrc/com/jetbrains/env/community/ut/PyDocTestTask.java b/python/testSrc/com/jetbrains/env/ut/PyDocTestTask.java similarity index 95% rename from python/testSrc/com/jetbrains/env/community/ut/PyDocTestTask.java rename to python/testSrc/com/jetbrains/env/ut/PyDocTestTask.java index bfc62fa55a38..e8228d767287 100644 --- a/python/testSrc/com/jetbrains/env/community/ut/PyDocTestTask.java +++ b/python/testSrc/com/jetbrains/env/ut/PyDocTestTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community.ut; +package com.jetbrains.env.ut; import com.intellij.execution.configurations.ConfigurationFactory; import com.intellij.openapi.project.Project; diff --git a/python/testSrc/com/jetbrains/env/community/ut/PyNoseTestTask.java b/python/testSrc/com/jetbrains/env/ut/PyNoseTestTask.java similarity index 95% rename from python/testSrc/com/jetbrains/env/community/ut/PyNoseTestTask.java rename to python/testSrc/com/jetbrains/env/ut/PyNoseTestTask.java index 7d26d96c3eca..e130dd5717a4 100644 --- a/python/testSrc/com/jetbrains/env/community/ut/PyNoseTestTask.java +++ b/python/testSrc/com/jetbrains/env/ut/PyNoseTestTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community.ut; +package com.jetbrains.env.ut; import com.google.common.collect.ImmutableSet; import com.intellij.execution.configurations.ConfigurationFactory; diff --git a/python/testSrc/com/jetbrains/env/community/ut/PyTestTestTask.java b/python/testSrc/com/jetbrains/env/ut/PyTestTestTask.java similarity index 96% rename from python/testSrc/com/jetbrains/env/community/ut/PyTestTestTask.java rename to python/testSrc/com/jetbrains/env/ut/PyTestTestTask.java index e80d40aa7326..1e4261188206 100644 --- a/python/testSrc/com/jetbrains/env/community/ut/PyTestTestTask.java +++ b/python/testSrc/com/jetbrains/env/ut/PyTestTestTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community.ut; +package com.jetbrains.env.ut; import com.google.common.collect.ImmutableSet; import com.intellij.execution.configurations.ConfigurationFactory; diff --git a/python/testSrc/com/jetbrains/env/community/ut/PyUnitTestTask.java b/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java similarity index 98% rename from python/testSrc/com/jetbrains/env/community/ut/PyUnitTestTask.java rename to python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java index ce441dd46961..2a2edc97a404 100644 --- a/python/testSrc/com/jetbrains/env/community/ut/PyUnitTestTask.java +++ b/python/testSrc/com/jetbrains/env/ut/PyUnitTestTask.java @@ -1,4 +1,4 @@ -package com.jetbrains.env.community.ut; +package com.jetbrains.env.ut; import com.google.common.collect.Lists; import com.intellij.execution.*; @@ -21,7 +21,7 @@ import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.Key; import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.XDebuggerTestUtil; -import com.jetbrains.env.community.PyExecutionFixtureTestTask; +import com.jetbrains.env.PyExecutionFixtureTestTask; import com.jetbrains.python.sdk.PythonEnvUtil; import com.jetbrains.python.sdk.flavors.JythonSdkFlavor; import com.jetbrains.python.sdk.flavors.PythonSdkFlavor;