From 7621f6ae530195b02bc14ea555fa82ba21c5bec9 Mon Sep 17 00:00:00 2001 From: Yaroslav Lepenkin Date: Mon, 4 Jul 2016 15:51:27 +0300 Subject: [PATCH] [Recent Tests] show only failed tests and passed configurations in popup. On right arrow failed test suite and configuration is shown --- .../testIntegration/RecentTestRunner.java | 27 ++- .../testIntegration/RecentTestsData.kt | 158 +++++++++++------- .../RecentTestsListProvider.java | 6 +- .../testIntegration/RunConfigurationEntry.kt | 134 ++++++++------- .../testIntegration/SelectTestStep.kt | 122 ++++++++++++-- .../testIntegration/ShowRecentTests.java | 9 +- .../testIntergration/RecentTestsOrderTest.kt | 52 ++---- .../testIntergration/RecentTestsTest.kt | 31 +--- 8 files changed, 328 insertions(+), 211 deletions(-) diff --git a/java/execution/impl/src/com/intellij/testIntegration/RecentTestRunner.java b/java/execution/impl/src/com/intellij/testIntegration/RecentTestRunner.java index d17513b46541..155ec44f6cad 100644 --- a/java/execution/impl/src/com/intellij/testIntegration/RecentTestRunner.java +++ b/java/execution/impl/src/com/intellij/testIntegration/RecentTestRunner.java @@ -37,8 +37,8 @@ public interface RecentTestRunner { } void setMode(Mode mode); - void run(String url); - void run(RunnerAndConfigurationSettings configuration); + + void run(RecentTestsPopupEntry entry); } class RecentTestRunnerImpl implements RecentTestRunner { @@ -67,14 +67,33 @@ class RecentTestRunnerImpl implements RecentTestRunner { } @Override - public void run(RunnerAndConfigurationSettings configuration) { + public void run(RecentTestsPopupEntry entry) { + entry.accept(new TestEntryVisitor() { + @Override + public void visitTest(@NotNull SingleTestEntry test) { + run(test.getUrl()); + } + + @Override + public void visitSuite(@NotNull SuiteEntry suite) { + run(suite.getSuiteUrl()); + } + + @Override + public void visitRunConfiguration(@NotNull RunConfigurationEntry configuration) { + run(configuration.getRunSettings()); + } + }); + } + + private void run(RunnerAndConfigurationSettings configuration) { Executor executor = myCurrentAction == RUN ? DefaultRunExecutor.getRunExecutorInstance() : DefaultDebugExecutor.getDebugExecutorInstance(); ProgramRunnerUtil.executeConfiguration(myProject, configuration, executor); } - public void run(@NotNull String url) { + private void run(@NotNull String url) { Location location = myTestLocator.getLocation(url); if (location == null) { return; diff --git a/java/execution/impl/src/com/intellij/testIntegration/RecentTestsData.kt b/java/execution/impl/src/com/intellij/testIntegration/RecentTestsData.kt index e0072f33a281..c67fd2172953 100644 --- a/java/execution/impl/src/com/intellij/testIntegration/RecentTestsData.kt +++ b/java/execution/impl/src/com/intellij/testIntegration/RecentTestsData.kt @@ -25,68 +25,61 @@ fun SuiteEntry.isMyTest(test: SingleTestEntry): Boolean { return testName.startsWith(this.suiteName) } +data class SingleTestInfo(val test: SingleTestEntry, val runConfigurationName: String) + class RecentTestsData { private val runConfigurationSuites = hashMapOf() - - private var unmatchedRunConfigurationTests = arrayListOf() - - private val urlSuites = mutableListOf() - private var unmatchedUrlTests = mutableListOf() - + private var testsWithoutSuites = arrayListOf() - fun addSuite(url: String, magnitude: Magnitude, runDate: Date, runConfiguration: RunnerAndConfigurationSettings?) { - val suite = SuiteEntry(url, magnitude, runDate) - if (runConfiguration != null) { - addRunConfigurationSuite(suite, runConfiguration) - } - else { - addUrlSuite(suite) - } + fun addSuite(url: String, runDate: Date, runConfiguration: RunnerAndConfigurationSettings) { + val suite = SuiteEntry(url, runDate) + addRunConfigurationSuite(suite, runConfiguration) } - fun addTest(url: String, magnitude: Magnitude, runDate: Date, runConfiguration: RunnerAndConfigurationSettings?) { - val test = SingleTestEntry(url, magnitude, runDate) - if (runConfiguration != null) { - addRunConfigurationTest(test, runConfiguration) - } - else { - addUrlTest(test) - } + fun addTest(url: String, magnitude: Magnitude, runDate: Date, runConfiguration: RunnerAndConfigurationSettings) { + val test = SingleTestEntry(url, runDate, magnitude) + addRunConfigurationTest(test, runConfiguration) } - private fun addUrlSuite(suite: SuiteEntry) { - val suiteTests = unmatchedUrlTests.filter { suite.isMyTest(it) } - suiteTests.forEach { suite.addTest(it) } - - unmatchedUrlTests = unmatchedUrlTests.filterTo(arrayListOf(), { !suite.isMyTest(it) }) - - urlSuites.add(suite) - } - private fun addRunConfigurationSuite(suite: SuiteEntry, config: RunnerAndConfigurationSettings) { - val suiteTests = unmatchedRunConfigurationTests.filter { suite.isMyTest(it) } - suiteTests.forEach { suite.addTest(it) } + moveSuiteTestsToSuite(suite, config) - unmatchedRunConfigurationTests = unmatchedRunConfigurationTests.filterTo(arrayListOf(), { !suite.isMyTest(it) }) - val id = config.uniqueID - runConfigurationSuites[id]?.addSuite(suite) ?: runConfigurationSuites.put(id, RunConfigurationEntry(config, suite)) + val entry = runConfigurationSuites[id] + if (entry != null) { + entry.addSuite(suite) + } + else { + runConfigurationSuites.put(id, RunConfigurationEntry(config, suite)) + } } - private fun addUrlTest(test: SingleTestEntry) { - findUrlSuite(test.url)?.addTest(test) ?: unmatchedUrlTests.add(test) + private fun moveSuiteTestsToSuite(suite: SuiteEntry, config: RunnerAndConfigurationSettings) { + val filteredTests = arrayListOf() + + testsWithoutSuites.forEach { + if (suite.isMyTest(it.test) && config.name == it.runConfigurationName) { + suite.addTest(it.test) + } + else { + filteredTests.add(it) + } + } + + testsWithoutSuites = filteredTests } private fun addRunConfigurationTest(test: SingleTestEntry, runConfiguration: RunnerAndConfigurationSettings) { - findRunConfigurationSuite(test.url, runConfiguration)?.addTest(test) ?: unmatchedRunConfigurationTests.add(test) + val suiteEntry = findRunConfigurationSuite(test.url, runConfiguration) + if (suiteEntry != null) { + suiteEntry.addTest(test) + } + else { + testsWithoutSuites.add(SingleTestInfo(test, runConfiguration.name)) + } } - - private fun findUrlSuite(url: String) = urlSuites.find { - val testName = VirtualFileManager.extractPath(url) - testName.startsWith(it.suiteName) - } - + private fun findRunConfigurationSuite(url: String, runConfiguration: RunnerAndConfigurationSettings): SuiteEntry? { val pack: RunConfigurationEntry = runConfigurationSuites[runConfiguration.uniqueID] ?: return null val testName = VirtualFileManager.extractPath(url) @@ -99,28 +92,69 @@ class RecentTestsData { return null } - - fun computeConfigurationSuites() = runConfigurationSuites.values - .fold(arrayListOf(), { total: List, entry: RunConfigurationEntry -> total + entry.suites }) fun getTestsToShow(): List { - val allConfigurationSuites = computeConfigurationSuites() - - unmatchedRunConfigurationTests.forEach { - val currentTest = it - allConfigurationSuites.find { it.isMyTest(currentTest) }?.addTest(currentTest) + val allConfigurations = runConfigurationSuites.values + + val allSuites = allConfigurations.fold(arrayListOf(), { list: List, entry -> list + entry.suites }) + testsWithoutSuites.forEach { + val info = it + allSuites.find { it.isMyTest(info.test) }?.let { info.test.suite = it } } - unmatchedUrlTests.forEach { - val currentTest = it - urlSuites.find { it.isMyTest(currentTest) }?.addTest(currentTest) - } + val testsCollector = SingleTestCollector() + allConfigurations.forEach { it.accept(testsCollector) } + val failedTests = testsCollector.tests.filter { it.failed } - return (runConfigurationSuites.values + urlSuites) - .sortedByDescending { it.runDate } - .fold(listOf(), { popupList, currentEntry -> - popupList + currentEntry.getEntriesToShow() - }) + val configsCollector = ConfigurationsCollector() + allConfigurations.forEach { it.accept(configsCollector) } + val passedConfigurations = configsCollector.entries.filter { !it.failed } + + val entriesToShow = failedTests + passedConfigurations + testsWithoutSuites.map { it.test }.filter { it.suite != null && it.failed } + + return entriesToShow.sortedByDescending { it.runDate } } +} + +class UrlsCollector: TestEntryVisitor() { + val urls = mutableListOf() + + override fun visitSuite(suite: SuiteEntry) { + urls.add(suite.suiteUrl) + suite.tests.forEach { urls.add(it.url) } + } + + override fun visitRunConfiguration(configuration: RunConfigurationEntry) { + configuration.suites.forEach { visitSuite(it) } + } +} + + +class SingleTestCollector : TestEntryVisitor() { + val tests = mutableListOf() + override fun visitTest(test: SingleTestEntry) { + tests.add(test) + } + + override fun visitSuite(suite: SuiteEntry) { + suite.tests.forEach { it.accept(this) } + } + + override fun visitRunConfiguration(configuration: RunConfigurationEntry) { + configuration.suites.forEach { it.accept(this) } + } +} + + +class ConfigurationsCollector : TestEntryVisitor() { + val entries = mutableListOf() + + override fun visitRunConfiguration(configuration: RunConfigurationEntry) { + entries.add(configuration) + } + + override fun visitSuite(suite: SuiteEntry) { + entries.add(suite) + } } \ No newline at end of file diff --git a/java/execution/impl/src/com/intellij/testIntegration/RecentTestsListProvider.java b/java/execution/impl/src/com/intellij/testIntegration/RecentTestsListProvider.java index 66ff8617809e..25a83e32f785 100644 --- a/java/execution/impl/src/com/intellij/testIntegration/RecentTestsListProvider.java +++ b/java/execution/impl/src/com/intellij/testIntegration/RecentTestsListProvider.java @@ -98,8 +98,12 @@ public class RecentTestsListProvider { } RunnerAndConfigurationSettings runConfiguration = myConfigurationProvider.getConfiguration(record); + if (runConfiguration == null) { + return; + } + if (TestLocator.isSuite(url)) { - data.addSuite(url, magnitude, record.date, runConfiguration); + data.addSuite(url, record.date, runConfiguration); } else { data.addTest(url, magnitude, record.date, runConfiguration); diff --git a/java/execution/impl/src/com/intellij/testIntegration/RunConfigurationEntry.kt b/java/execution/impl/src/com/intellij/testIntegration/RunConfigurationEntry.kt index a0263b085be6..daea4350491c 100644 --- a/java/execution/impl/src/com/intellij/testIntegration/RunConfigurationEntry.kt +++ b/java/execution/impl/src/com/intellij/testIntegration/RunConfigurationEntry.kt @@ -16,72 +16,76 @@ package com.intellij.testIntegration import com.intellij.execution.RunnerAndConfigurationSettings +import com.intellij.execution.testframework.TestIconMapper import com.intellij.execution.testframework.sm.runner.states.TestStateInfo -import com.intellij.execution.testframework.sm.runner.states.TestStateInfo.Magnitude.* +import com.intellij.execution.testframework.sm.runner.states.TestStateInfo.Magnitude.ERROR_INDEX +import com.intellij.execution.testframework.sm.runner.states.TestStateInfo.Magnitude.FAILED_INDEX +import com.intellij.icons.AllIcons import com.intellij.openapi.vfs.VirtualFileManager -import com.intellij.psi.PsiElement import java.util.* +import javax.swing.Icon + interface RecentTestsPopupEntry { - val runDate: Date - val magnitude: TestStateInfo.Magnitude + val icon: Icon? val presentation: String - - val testsUrls: List - - fun run(runner: RecentTestRunner) - - open fun navigatableElement(locator: TestLocator): PsiElement? = null + val runDate: Date - fun getEntriesToShow(): List + val failed: Boolean + + fun accept(visitor: TestEntryVisitor) } -open class SingleTestEntry(val url: String, - override val magnitude: TestStateInfo.Magnitude, - override val runDate: Date) : RecentTestsPopupEntry + +abstract class TestEntryVisitor { + open fun visitTest(test: SingleTestEntry) = Unit + open fun visitSuite(suite: SuiteEntry) = Unit + open fun visitRunConfiguration(configuration: RunConfigurationEntry) = Unit +} + +class SingleTestEntry(val url: String, + override val runDate: Date, + private val magnitude: TestStateInfo.Magnitude) : RecentTestsPopupEntry { override val presentation = VirtualFileManager.extractPath(url) - override val testsUrls = listOf(url) - - override fun run(runner: RecentTestRunner) { - runner.run(url) + override val icon = TestIconMapper.getIcon(magnitude) + + override val failed = magnitude == ERROR_INDEX || magnitude == FAILED_INDEX + + var suite: SuiteEntry? = null + + override fun accept(visitor: TestEntryVisitor) { + visitor.visitTest(this) } - - override fun navigatableElement(locator: TestLocator) = locator.getLocation(url)?.psiElement - - override fun getEntriesToShow(): List = listOf(this) } -class SuiteEntry(url: String, magnitude: TestStateInfo.Magnitude, runDate: Date) : SingleTestEntry(url, magnitude, runDate) { - - private val tests = hashSetOf() - override val testsUrls: List - get() = tests.fold(listOf(), { acc, testEntry -> acc + testEntry.testsUrls }) - - val suiteName = VirtualFileManager.extractPath(url) - - val failedTests: List - get() = tests.filter { it.magnitude == FAILED_INDEX || it.magnitude == ERROR_INDEX } - - fun addTest(info: SingleTestEntry) = tests.add(info) +class SuiteEntry(val suiteUrl: String, override val runDate: Date) : RecentTestsPopupEntry { - override val presentation = suiteName - - override fun getEntriesToShow(): List { - val failed = failedTests - if (failed.size > 0) { - return failed.sortedByDescending { it.runDate } + this + val tests = hashSetOf() + val suiteName = VirtualFileManager.extractPath(suiteUrl) + + var runConfiguration: RunConfigurationEntry? = null + + override val presentation = VirtualFileManager.extractPath(suiteUrl) + override val icon = AllIcons.RunConfigurations.Junit + + override val failed: Boolean + get() { + return tests.find { it.failed } != null } - return listOf(this) - } - override val magnitude: TestStateInfo.Magnitude by lazy { - tests.find { it.magnitude != PASSED_INDEX && it.magnitude != COMPLETE_INDEX }?.magnitude ?: PASSED_INDEX + fun addTest(test: SingleTestEntry) { + tests.add(test) + test.suite = this } - + + override fun accept(visitor: TestEntryVisitor) { + visitor.visitSuite(this) + } + } @@ -93,34 +97,28 @@ class RunConfigurationEntry(val runSettings: RunnerAndConfigurationSettings, ini addSuite(initial) } - fun addSuite(s: SuiteEntry) = suites.add(s) + override val runDate: Date + get() { + return suites.minBy { it.runDate }!!.runDate + } + + + override val failed: Boolean + get() { + return suites.find { it.failed } != null + } - override val runDate = suites.map { it.runDate }.min()!! - - override val magnitude: TestStateInfo.Magnitude by lazy { - suites.find { it.magnitude != PASSED_INDEX && it.magnitude != COMPLETE_INDEX }?.magnitude ?: PASSED_INDEX + fun addSuite(suite: SuiteEntry) { + suites.add(suite) + suite.runConfiguration = this } override val presentation = runSettings.name - override val testsUrls: List - get() = suites.fold(listOf(), { list, suite -> list + suite.testsUrls }) - - override fun run(runner: RecentTestRunner) { - runner.run(runSettings) - } + override val icon = AllIcons.RunConfigurations.Junit - override fun getEntriesToShow(): List { - if (suites.size == 1) { - return suites[0].getEntriesToShow() - } - - return suites - .filter { it.failedTests.size > 0} - .sortedByDescending { it.runDate } - .fold(listOf(), { popupList, currentEntry -> - popupList + currentEntry.getEntriesToShow() - }) + this + override fun accept(visitor: TestEntryVisitor) { + visitor.visitRunConfiguration(this) } -} +} \ No newline at end of file diff --git a/java/execution/impl/src/com/intellij/testIntegration/SelectTestStep.kt b/java/execution/impl/src/com/intellij/testIntegration/SelectTestStep.kt index 73e58109d227..d2a5b85a67ff 100644 --- a/java/execution/impl/src/com/intellij/testIntegration/SelectTestStep.kt +++ b/java/execution/impl/src/com/intellij/testIntegration/SelectTestStep.kt @@ -15,12 +15,13 @@ */ package com.intellij.testIntegration -import com.intellij.execution.testframework.TestIconMapper +import com.intellij.icons.AllIcons import com.intellij.openapi.keymap.MacKeymapUtil import com.intellij.openapi.ui.popup.ListPopupStep import com.intellij.openapi.ui.popup.PopupStep import com.intellij.openapi.ui.popup.util.BaseListPopupStep import com.intellij.openapi.util.SystemInfo +import com.intellij.psi.PsiElement import com.intellij.ui.popup.list.ListPopupImpl import com.intellij.util.PsiNavigateUtil import java.awt.event.ActionEvent @@ -31,9 +32,7 @@ import javax.swing.KeyStroke class RecentTestsListPopup(popupStep: ListPopupStep, private val testRunner: RecentTestRunner, - private val locator: TestLocator) - : ListPopupImpl(popupStep) -{ + private val locator: TestLocator) : ListPopupImpl(popupStep) { init { shiftReleased() @@ -58,16 +57,36 @@ class RecentTestsListPopup(popupStep: ListPopupStep, override fun actionPerformed(e: ActionEvent) { val values = selectedValues if (values.size == 1) { - val element = (values[0] as RecentTestsPopupEntry).navigatableElement(locator) - if (element != null) { + val entry = values[0] as RecentTestsPopupEntry + getElement(entry)?.let { cancel() - PsiNavigateUtil.navigate(element) + PsiNavigateUtil.navigate(it) } } } }) } + private fun getElement(entry: RecentTestsPopupEntry): PsiElement? { + var element: PsiElement? = null + entry.accept(object : TestEntryVisitor() { + override fun visitTest(test: SingleTestEntry) { + element = locator.getLocation(test.url)?.psiElement + } + + override fun visitSuite(suite: SuiteEntry) { + element = locator.getLocation(suite.suiteUrl)?.psiElement + } + + override fun visitRunConfiguration(configuration: RunConfigurationEntry) { + if (configuration.suites.size == 1) { + visitSuite(configuration.suites[0]) + } + } + }) + return element + } + private fun shiftPressed() { setCaption("Debug Recent Tests") testRunner.setMode(RecentTestRunner.Mode.DEBUG) @@ -80,22 +99,99 @@ class RecentTestsListPopup(popupStep: ListPopupStep, } -class SelectTestStep(tests: List, - private val runner: RecentTestRunner) - : BaseListPopupStep("Debug Recent Tests", tests) +class SelectTestStep(title: String?, + tests: List, + private val runner: RecentTestRunner) : BaseListPopupStep(title, tests) { override fun getIconFor(value: RecentTestsPopupEntry): Icon? { - return TestIconMapper.getIcon(value.magnitude) + if (value is SingleTestEntry) { + return AllIcons.RunConfigurations.TestFailed + } + else { + return AllIcons.RunConfigurations.TestPassed + } } override fun getTextFor(value: RecentTestsPopupEntry) = value.presentation override fun isSpeedSearchEnabled() = true + override fun hasSubstep(selectedValue: RecentTestsPopupEntry) = getConfigurations(selectedValue).isNotEmpty() + override fun onChosen(entry: RecentTestsPopupEntry, finalChoice: Boolean): PopupStep? { - entry.run(runner) - return null + if (finalChoice) { + runner.run(entry) + return null + } + + val configurations = getConfigurations(entry) + return SelectConfigurationStep(configurations, runner) + } + + private fun getConfigurations(entry: RecentTestsPopupEntry): List { + val items = mutableListOf() + + entry.accept(object : TestEntryVisitor() { + override fun visitTest(test: SingleTestEntry) { + val suite = test.suite ?: return + val configuration = suite.runConfiguration + if (configuration == null) { + items.add(suite) + return + } + + if (isSingleTestConfiguration(configuration)) { + items.add(suite) + return + } + + items.add(configuration) + if (configuration.suites.size > 1) { + items.add(0, suite) + } + } + + private fun isSingleTestConfiguration(configuration: RunConfigurationEntry): Boolean { + val suites = configuration.suites + return suites.size == 1 && suites[0].tests.size == 1 + } + + }) + + return items } } + + +class SelectConfigurationStep(private val items: List, + private val runner: RecentTestRunner) + : BaseListPopupStep(null, items) +{ + + override fun getTextFor(value: RecentTestsPopupEntry): String { + var presentation = value.presentation + value.accept(object : TestEntryVisitor() { + override fun visitSuite(suite: SuiteEntry) { + presentation = "[suite] " + presentation + } + + override fun visitRunConfiguration(configuration: RunConfigurationEntry) { + presentation = "[configuration] " + presentation + } + }) + return presentation + } + + override fun getIconFor(value: RecentTestsPopupEntry?) = AllIcons.RunConfigurations.Junit + + override fun onChosen(selectedValue: RecentTestsPopupEntry, finalChoice: Boolean): PopupStep? { + if (finalChoice) { + runner.run(selectedValue) + } + + return null + } + +} \ No newline at end of file diff --git a/java/execution/impl/src/com/intellij/testIntegration/ShowRecentTests.java b/java/execution/impl/src/com/intellij/testIntegration/ShowRecentTests.java index 2807216931c7..81ceea8be303 100644 --- a/java/execution/impl/src/com/intellij/testIntegration/ShowRecentTests.java +++ b/java/execution/impl/src/com/intellij/testIntegration/ShowRecentTests.java @@ -22,7 +22,6 @@ import com.intellij.openapi.actionSystem.AnActionEvent; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.project.Project; import com.intellij.util.Time; -import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import java.util.Date; @@ -60,7 +59,7 @@ public class ShowRecentTests extends AnAction { List entries = listProvider.getTestsToShow(); - SelectTestStep selectStepTest = new SelectTestStep(entries, testRunner); + SelectTestStep selectStepTest = new SelectTestStep("Debug Recent Tests", entries, testRunner); RecentTestsListPopup popup = new RecentTestsListPopup(selectStepTest, testRunner, testLocator); popup.showCenteredInCurrentWindow(project); @@ -69,9 +68,9 @@ public class ShowRecentTests extends AnAction { } private static void cleanDeadTests(List entries, TestLocator testLocator, TestStateStorage testStorage) { - List urls = ContainerUtil.newArrayList(); - entries.forEach((entry) -> urls.addAll(entry.getTestsUrls())); - ApplicationManager.getApplication().executeOnPooledThread(new DeadTestsCleaner(testStorage, urls, testLocator)); + UrlsCollector collector = new UrlsCollector(); + entries.forEach((e) -> e.accept(collector)); + ApplicationManager.getApplication().executeOnPooledThread(new DeadTestsCleaner(testStorage, collector.getUrls(), testLocator)); } } diff --git a/java/java-tests/testSrc/com/intellij/testIntergration/RecentTestsOrderTest.kt b/java/java-tests/testSrc/com/intellij/testIntergration/RecentTestsOrderTest.kt index b30883240cf0..364b10ed3595 100644 --- a/java/java-tests/testSrc/com/intellij/testIntergration/RecentTestsOrderTest.kt +++ b/java/java-tests/testSrc/com/intellij/testIntergration/RecentTestsOrderTest.kt @@ -37,11 +37,11 @@ class RecentTestsOrderTest: LightIdeaTestCase() { } fun addPassedSuite(suiteUrl: String, date: Date = Date(), runConfiguration: RunnerAndConfigurationSettings = allTests) { - data.addSuite(suiteUrl, PASSED_INDEX, date, runConfiguration) + data.addSuite(suiteUrl, date, runConfiguration) } fun addFailedSuite(suiteUrl: String, date: Date = Date(), runConfiguration: RunnerAndConfigurationSettings = allTests) { - data.addSuite(suiteUrl, FAILED_INDEX, date, runConfiguration) + data.addSuite(suiteUrl, date, runConfiguration) } fun addPassedTest(testUrl: String, date: Date = Date(), runConfiguration: RunnerAndConfigurationSettings = allTests) { @@ -57,11 +57,11 @@ class RecentTestsOrderTest: LightIdeaTestCase() { val test1 = "MySingleTest.test1".test() data.addTest(test1, PASSED_INDEX, now, allTests) - data.addSuite(suite, PASSED_INDEX, now, allTests) + data.addSuite(suite, now, allTests) val testsToShow = data.getTestsToShow() assertThat(testsToShow).hasSize(1) - assertThat(testsToShow[0].presentation).isEqualTo("MySingleTest") + assertThat(testsToShow[0].presentation).isEqualTo("all tests") } fun `test run configuration with multiple suites shows run configuration name`() { @@ -90,13 +90,10 @@ class RecentTestsOrderTest: LightIdeaTestCase() { addFailedTest(test) val tests = data.getTestsToShow() - assertThat(tests).hasSize(2) + assertThat(tests).hasSize(1) assertThat(tests[0].presentation).isEqualTo("SingleTest.test") - assertThat(tests[0].magnitude).isEqualTo(FAILED_INDEX) - - assertThat(tests[1].presentation).isEqualTo("SingleTest") - assertThat(tests[1].magnitude).isEqualTo(FAILED_INDEX) + assertThat(tests[0].failed).isEqualTo(true) } fun `test show failed suite and test in run configuration`() { @@ -111,41 +108,29 @@ class RecentTestsOrderTest: LightIdeaTestCase() { addPassedSuite("PassedSuite".suite()) val tests = data.getTestsToShow() - assertThat(tests).hasSize(3) + assertThat(tests).hasSize(1) assertThat(tests[0].presentation).isEqualTo("SingleTest.test") - assertThat(tests[0].magnitude).isEqualTo(FAILED_INDEX) - - assertThat(tests[1].presentation).isEqualTo("SingleTest") - assertThat(tests[1].magnitude).isEqualTo(FAILED_INDEX) - - assertThat(tests[2].presentation).isEqualTo("all tests") - assertThat(tests[2].magnitude).isEqualTo(FAILED_INDEX) + assertThat(tests[0].failed).isEqualTo(true) } fun `test single test run doesn't override suite status`() { val singleTestConfig = mockConfiguration("single test", "Junit.single test") val newNow = Date(now.time + 100000) - //current single test run - addFailedSuite("Test".suite(), newNow, singleTestConfig) - addFailedTest("Test.testOK".test(), newNow, singleTestConfig) //previous all suite run - addPassedTest("Test.testOK".test(), now, allTests) addFailedTest("Test.testFailed".test(), now, allTests) + //current single test run + addPassedSuite("Test".suite(), newNow, singleTestConfig) + addPassedTest("Test.testOK".test(), newNow, singleTestConfig) + val tests = data.getTestsToShow() - assertThat(tests).hasSize(3) - - assertThat(tests[0].presentation).isEqualTo("Test.testOK") - assertThat(tests[0].magnitude).isEqualTo(FAILED_INDEX) + assertThat(tests).hasSize(2) + assertThat(tests[0].presentation).isEqualTo("single test") assertThat(tests[1].presentation).isEqualTo("Test.testFailed") - assertThat(tests[1].magnitude).isEqualTo(FAILED_INDEX) - - assertThat(tests[2].presentation).isEqualTo("Test") - assertThat(tests[2].magnitude).isEqualTo(FAILED_INDEX) } @@ -156,18 +141,15 @@ class RecentTestsOrderTest: LightIdeaTestCase() { //previous all suite run addPassedTest("Test.testOK".test(), now, allTests) - addFailedTest("Test.testFailed".test(), now, allTests) //current single test run addFailedSuite("Test".suite(), newNow, singleTestConfig) - addFailedTest("Test.testOK".test(), newNow, singleTestConfig) + addFailedTest("Test.testFailed".test(), newNow, singleTestConfig) val tests = data.getTestsToShow() - assertThat(tests).hasSize(3) + assertThat(tests).hasSize(1) - assertThat(tests[0].presentation).isEqualTo("Test.testOK") - assertThat(tests[1].presentation).isEqualTo("Test.testFailed") - assertThat(tests[2].presentation).isEqualTo("Test") + assertThat(tests[0].presentation).isEqualTo("Test.testFailed") } } \ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/testIntergration/RecentTestsTest.kt b/java/java-tests/testSrc/com/intellij/testIntergration/RecentTestsTest.kt index 13967b0baa78..87dd94da7420 100644 --- a/java/java-tests/testSrc/com/intellij/testIntergration/RecentTestsTest.kt +++ b/java/java-tests/testSrc/com/intellij/testIntergration/RecentTestsTest.kt @@ -48,18 +48,10 @@ class RecentTestsStepTest: LightIdeaTestCase() { now = Date() } - fun `test show suites without run configuration`() { - data.addTest("Test.x".test(), PASSED_INDEX, now, null) - data.addSuite("Test".suite(), PASSED_INDEX, now, null) - - val tests = data.getTestsToShow() - assertThat(tests).hasSize(1) - } - fun `test all tests passed`() { data.addTest("Test.textXXX".test(), PASSED_INDEX, now, allTests) - data.addSuite("Test".suite(), PASSED_INDEX, now, allTests) - data.addSuite("JFSDTest".suite(), PASSED_INDEX, now, allTests) + data.addSuite("Test".suite(), now, allTests) + data.addSuite("JFSDTest".suite(), now, allTests) data.addTest("Test.textYYY".test(), PASSED_INDEX, now, allTests) data.addTest("JFSDTest.testItMakesMeSadToFixIt".test(), PASSED_INDEX, now, allTests) data.addTest("Test.textZZZ".test(), PASSED_INDEX, now, allTests) @@ -73,8 +65,8 @@ class RecentTestsStepTest: LightIdeaTestCase() { fun `test if one failed in run configuration show failed suite`() { - data.addSuite("JFSDTest".suite(), FAILED_INDEX, now, allTests) - data.addSuite("Test".test(), PASSED_INDEX, now, allTests) + data.addSuite("JFSDTest".suite(), now, allTests) + data.addSuite("Test".suite(), now, allTests) data.addTest("JFSDTest.testItMakesMeSadToFixIt".test(), FAILED_INDEX, now, allTests) data.addTest("JFSDTest.testUnconditionalAlignmentErrorneous".test(), PASSED_INDEX, now, allTests) @@ -83,28 +75,21 @@ class RecentTestsStepTest: LightIdeaTestCase() { val tests = data.getTestsToShow() - assertThat(tests).hasSize(3) + assertThat(tests).hasSize(1) assertThat(tests[0].presentation).isEqualTo("JFSDTest.testItMakesMeSadToFixIt") - assertThat(tests[0].magnitude).isEqualTo(FAILED_INDEX) - - assertThat(tests[1].presentation).isEqualTo("JFSDTest") - assertThat(tests[1].magnitude).isEqualTo(FAILED_INDEX) - - assertThat(tests[2].presentation).isEqualTo("all tests") - assertThat(tests[2].magnitude).isEqualTo(FAILED_INDEX) + assertThat(tests[0].failed).isEqualTo(true) } fun `test if configuration with single test show failed test`() { - data.addSuite("JFSDTest".suite(), FAILED_INDEX, now, allTests) + data.addSuite("JFSDTest".suite(), now, allTests) data.addTest("JFSDTest.testItMakesMeSadToFixIt".test(), FAILED_INDEX, now, allTests) data.addTest("JFSDTest.testUnconditionalAlignmentErrorneous".test(), PASSED_INDEX, now, allTests) val tests = data.getTestsToShow() - assertThat(tests).hasSize(2) + assertThat(tests).hasSize(1) assertThat(tests[0].presentation).isEqualTo("JFSDTest.testItMakesMeSadToFixIt") - assertThat(tests[1].presentation).isEqualTo("JFSDTest") }