fix(test-runner): Fix scoping for higher order tests (#26)

CHANGELOG.md

@@ -8,6 +8,7 @@
 - Line markers now works, for the whole file and the single test. ([#17](https://github.com/pestphp/pest-intellij/pull/17), [#24](https://github.com/pestphp/pest-intellij/pull/24))
 - Add running support with debugger ([#19](https://github.com/pestphp/pest-intellij/pull/19))
 - `$this->field` type support for fields declared in `beforeEach` and `beforeAll` functions ([#22](https://github.com/pestphp/pest-intellij/pull/22))
+- Run tests scoped based on the cursor ([#24](https://github.com/pestphp/pest-intellij/pull/24), [#26](https://github.com/pestphp/pest-intellij/pull/26))
 
 ## [v0.1.1]
 ### Added

gradle.properties

@@ -3,7 +3,7 @@
 
 pluginGroup = com.pestphp
 pluginName = Pest
-pluginVersion = 0.2.0
+pluginVersion = 0.2.1-alpha.1
 pluginSinceBuild = 201
 pluginUntilBuild = null
 

src/main/kotlin/com/pestphp/pest/PestTestRunLineMarkerProvider.kt

@@ -0,0 +1,24 @@
+package com.pestphp.pest
+
+import com.intellij.execution.lineMarker.RunLineMarkerContributor
+import com.intellij.psi.PsiElement
+import com.jetbrains.php.lang.lexer.PhpTokenTypes
+import com.jetbrains.php.lang.psi.PhpPsiUtil
+import com.jetbrains.php.lang.psi.elements.FunctionReference
+import com.pestphp.pest.PestUtil.isPestTestFunction
+
+class PestTestRunLineMarkerProvider : RunLineMarkerContributor() {
+ override fun getInfo(leaf: PsiElement): Info? {
+ if (!PhpPsiUtil.isOfType(leaf, PhpTokenTypes.IDENTIFIER)) {
+ return null
+ }
+
+ // return RunLineMarkerContributor.withExecutorActions(getTestStateIcon(getLocationHint(testName), leaf.getProject(), false));
+ return when {
+ leaf.parent !is FunctionReference -> null
+ isPestTestFunction(leaf.parent as FunctionReference) -> withExecutorActions(PestIcons.RUN_SINGLE_TEST)
+ else -> null
+ }
+
+ }
+}

src/main/kotlin/com/pestphp/pest/PestUtil.kt

@@ -0,0 +1,105 @@
+package com.pestphp.pest
+
+import com.intellij.notification.Notification
+import com.intellij.notification.NotificationType
+import com.intellij.notification.Notifications
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.text.StringUtil
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.util.ObjectUtils
+import com.jetbrains.php.lang.psi.PhpFile
+import com.jetbrains.php.lang.psi.elements.FunctionReference
+import com.jetbrains.php.lang.psi.elements.MethodReference
+import com.jetbrains.php.lang.psi.elements.StringLiteralExpression
+import com.jetbrains.php.testFramework.PhpTestFrameworkConfiguration
+import com.jetbrains.php.testFramework.PhpTestFrameworkSettingsManager
+import org.jetbrains.annotations.Nls
+
+object PestUtil {
+ private const val NOTIFICATION_GROUP = "Pest"
+
+ @JvmStatic
+ fun isPestTestFile(element: PsiElement?): Boolean {
+ if (element == null) {
+ return false
+ }
+ if (element !is PhpFile) {
+ return false
+ }
+ val functions = PsiTreeUtil.findChildrenOfType(element, FunctionReference::class.java)
+ return functions.stream()
+ .anyMatch { obj: FunctionReference? -> isPestTestFunction(obj) }
+ }
+
+ @JvmStatic
+ fun isPestTestFunction(element: PsiElement?): Boolean {
+ return when (element) {
+ null -> false
+ is MethodReference -> isPestTestFunction(element)
+ is FunctionReference -> isPestTestFunction(element)
+ else -> false
+ }
+ }
+
+ @JvmStatic
+ fun isPestTestFunction(reference: FunctionReference): Boolean {
+ return reference.canonicalText in setOf("it", "test")
+ }
+
+ @JvmStatic
+ fun isPestTestFunction(methodReference: MethodReference): Boolean {
+ val reference = ObjectUtils.tryCast(methodReference.classReference, FunctionReference::class.java)
+ return reference != null && isPestTestFunction(reference)
+ }
+
+ @JvmStatic
+ fun getTestName(element: FunctionReference): String? {
+ return when (val parameter = element.getParameter(0)) {
+ is StringLiteralExpression -> parameter.contents
+ else -> null
+ }
+ }
+
+ @JvmStatic
+ fun getTestName(element: PsiElement?): String? {
+ return when (element) {
+ is MethodReference -> (element.classReference as? FunctionReference)?.let(this::getTestName)
+ is FunctionReference -> getTestName(element)
+ else -> null
+ }
+ }
+
+ @JvmStatic
+ fun isEnabled(project: Project): Boolean {
+ return PhpTestFrameworkSettingsManager
+ .getInstance(project)
+ .getConfigurations(PestFrameworkType.getInstance())
+ .stream()
+ .anyMatch { config: PhpTestFrameworkConfiguration -> StringUtil.isNotEmpty(config.executablePath) }
+ }
+
+ @JvmStatic
+ fun doNotify(
+ title: String,
+ content: @Nls(capitalization = Nls.Capitalization.Sentence) String,
+ type: NotificationType,
+ project: Project?
+ ) {
+ val notification = Notification(NOTIFICATION_GROUP, title, content, type)
+ doNotify(notification, project)
+ }
+
+ @JvmStatic
+ fun doNotify(notification: Notification?, project: Project?) {
+ if (project != null && !project.isDisposed && !project.isDefault) {
+ project.messageBus.syncPublisher(Notifications.TOPIC).notify(notification!!)
+ } else {
+ val app = ApplicationManager.getApplication()
+ if (!app.isDisposed) {
+ app.messageBus.syncPublisher(Notifications.TOPIC).notify(notification!!)
+ }
+ }
+ }
+}

src/main/kotlin/com/pestphp/pest/configuration/PestRunConfigurationProducer.kt

@@ -8,7 +8,6 @@ import com.intellij.psi.PsiDirectory
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.util.Function
-import com.jetbrains.php.lang.psi.elements.FunctionReference
 import com.jetbrains.php.testFramework.run.PhpTestConfigurationProducer
 import com.pestphp.pest.PestUtil
 
@@ -32,14 +31,10 @@ class PestRunConfigurationProducer : PhpTestConfigurationProducer<PestRunConfigu
 
  companion object {
  private val METHOD = Condition<PsiElement> { element: PsiElement? ->
- (element is FunctionReference
- && PestUtil.isPestTestFunction(element))
+ return@Condition PestUtil.isPestTestFunction(element)
  }
  private val METHOD_NAMER = Function<PsiElement, String?> { element: PsiElement? ->
- if (element is FunctionReference) {
- return@Function PestUtil.getTestName(element)
- }
- null
+ return@Function PestUtil.getTestName(element)
  }
  private val FILE_TO_SCOPE = Function<PsiFile, PsiElement?> { file: PsiFile? ->
  if (PestUtil.isPestTestFile(file)) {

src/test/kotlin/com/pestphp/pest/tests/PestUtilTest.kt

@@ -20,7 +20,7 @@ class PestUtilTest: PestLightCodeFixture() {
  val file = myFixture.configureByFile("SimpleTest.php")
 
  val functions = PsiTreeUtil.findChildrenOfType(file, FunctionReference::class.java)
- .stream().filter(PestUtil::isPestTestFunction).collect(Collectors.toList())
+ .stream().filter { element -> PestUtil.isPestTestFunction(element)}.collect(Collectors.toList())
 
  assertEquals(1, functions.count())
 

src/test/kotlin/com/pestphp/pest/tests/fixtures/SimpleHigherOrderTestWithName.php

@@ -0,0 +1,3 @@
+<?php
+
+it('lives')->assertTrue(true);