Support for namespace and var selectors

This is work towards #2, they are tested against clojure.test.
clojurephant · Jun 16, 2016 · 22536b4 · 22536b4
1 parent f482eea
commit 22536b4
Show file tree

Hide file tree

Showing 9 changed files with 212 additions and 5 deletions.
diff --git a/jupiter-engine-clojure.test/build.gradle b/jupiter-engine-clojure.test/build.gradle
@@ -11,6 +11,7 @@ dependencies {
     compile project(':jupiter-lang-clojure')
 
     testCompile 'junit:junit:4.12'
+    testCompile 'org.junit:junit-launcher:default'
 }
 
 task sourcesJar(type: Jar) {

diff --git a/...jure.test/src/main/java/org/ajoberstar/jupiter/engine/clojure_test/ClojureTestEngine.java b/...jure.test/src/main/java/org/ajoberstar/jupiter/engine/clojure_test/ClojureTestEngine.java
@@ -2,28 +2,47 @@
 
 import clojure.java.api.Clojure;
 import clojure.lang.IFn;
-import org.junit.gen5.engine.*;
+import clojure.lang.Namespace;
+import clojure.lang.Var;
+import org.ajoberstar.jupiter.lang.clojure.NamespaceSelector;
+import org.ajoberstar.jupiter.lang.clojure.VarSelector;
+import org.junit.gen5.engine.EngineDiscoveryRequest;
+import org.junit.gen5.engine.ExecutionRequest;
+import org.junit.gen5.engine.TestDescriptor;
+import org.junit.gen5.engine.TestEngine;
+import org.junit.gen5.engine.UniqueId;
 import org.junit.gen5.engine.discovery.ClasspathSelector;
 
 import java.io.File;
 import java.util.List;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class ClojureTestEngine implements TestEngine {
     public static final String ENGINE_ID = "clojure.test";
 
     @Override
     public TestDescriptor discover(EngineDiscoveryRequest discoveryRequest, UniqueId uniqueId) {
         // TODO support UniqueIdSelectors
-        List<File> testDirs = discoveryRequest.getSelectorsByType(ClasspathSelector.class).stream()
-            .map(ClasspathSelector::getClasspathRoot)
+        Stream<File> testDirs = discoveryRequest.getSelectorsByType(ClasspathSelector.class).stream()
+            .map(ClasspathSelector::getClasspathRoot);
+
+        Stream<Namespace> namespaces = discoveryRequest.getSelectorsByType(NamespaceSelector.class).stream()
+            .map(NamespaceSelector::getNamespace);
+
+        Stream<Var> vars = discoveryRequest.getSelectorsByType(VarSelector.class).stream()
+            .map(VarSelector::getVar);
+
+        List<? extends Object> roots = Stream.of(testDirs, namespaces, vars)
+            .reduce(Stream::concat)
+            .orElse(Stream.empty())
             .collect(Collectors.toList());
 
         IFn require = Clojure.var("clojure.core", "require");
         require.invoke(Clojure.read("org.ajoberstar.jupiter.engine.clojure-test.discovery"));
 
         IFn scanner = Clojure.var("org.ajoberstar.jupiter.engine.clojure-test.discovery", "discover-descriptor");
-        TestDescriptor descriptor = (TestDescriptor) scanner.invoke(uniqueId, testDirs);
+        TestDescriptor descriptor = (TestDescriptor) scanner.invoke(uniqueId, roots);
 
         // TODO support filters
 

diff --git a/...-clojure.test/src/main/resources/org/ajoberstar/jupiter/engine/clojure_test/discovery.clj b/...-clojure.test/src/main/resources/org/ajoberstar/jupiter/engine/clojure_test/discovery.clj
@@ -1,5 +1,6 @@
 (ns org.ajoberstar.jupiter.engine.clojure-test.discovery
   (:require [clojure.tools.namespace.find :refer [find-namespaces]]
+            [clojure.java.io :as io]
             [org.ajoberstar.jupiter.lang.clojure :as lang])
   (:import (clojure.lang Var Symbol Namespace)
            (java.io File)
@@ -47,7 +48,7 @@
   (binding [lang/*root-id* root-id]
     (let [engine-desc (EngineDescriptor. root-id ClojureTestEngine/ENGINE_ID)]
       (doseq [root roots]
-        (binding [lang/*root-dir* root]
+        (binding [lang/*root-dir* (if (satisfies? io/Coercions root) root)]
           (let [ns-descs (->> (-discover-tests root)
                               (group-by (comp :ns meta))
                               (map ns->descriptor))]

diff --git a/....test/src/test/java/org/ajoberstar/jupiter/engine/clojure_test/ClojureTestEngineTest.java b/....test/src/test/java/org/ajoberstar/jupiter/engine/clojure_test/ClojureTestEngineTest.java
@@ -0,0 +1,89 @@
+package org.ajoberstar.jupiter.engine.clojure_test;
+
+import org.junit.Test;
+import org.junit.gen5.engine.EngineDiscoveryRequest;
+import org.junit.gen5.engine.TestDescriptor;
+import org.junit.gen5.engine.UniqueId;
+import org.junit.gen5.launcher.main.TestDiscoveryRequestBuilder;
+
+import java.io.File;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.*;
+import static org.junit.gen5.engine.discovery.ClasspathSelector.selectClasspathRoots;
+import static org.ajoberstar.jupiter.lang.clojure.NamespaceSelector.selectNamespace;
+import static org.ajoberstar.jupiter.lang.clojure.VarSelector.selectVar;
+
+public class ClojureTestEngineTest {
+    @Test
+    public void selectingByClasspathDir() {
+        Set<File> roots = Stream.of(new File(".")).collect(Collectors.toSet());
+        EngineDiscoveryRequest request = TestDiscoveryRequestBuilder.request()
+            .selectors(selectClasspathRoots(roots))
+            .build();
+        UniqueId root = UniqueId.root("sample", "test");
+
+        List<UniqueId> expectedIds = Stream.of(
+            root.append("namespace", "sample.core-test"),
+            root.append("namespace", "sample.other-test"),
+            root.append("namespace", "sample.core-test").append("name", "my-sample-works"),
+            root.append("namespace", "sample.core-test").append("name", "my-sample-fails"),
+            root.append("namespace", "sample.other-test").append("name", "my-other-works"),
+            root.append("namespace", "sample.other-test").append("name", "my-other-fails"),
+            root.append("namespace", "sample.other-test").append("name", "my-other-error")
+        ).collect(Collectors.toList());
+
+        TestDescriptor descriptor = new ClojureTestEngine().discover(request, root);
+        List<UniqueId> actualIds = descriptor.getAllDescendants().stream()
+            .map(TestDescriptor::getUniqueId)
+            .collect(Collectors.toList());
+
+        assertEquals(expectedIds, actualIds);
+    }
+
+    @Test
+    public void selectingByNamespace() {
+        EngineDiscoveryRequest request = TestDiscoveryRequestBuilder.request()
+            .selectors(selectNamespace("sample.other-test"))
+            .build();
+        UniqueId root = UniqueId.root("sample", "test");
+
+        List<UniqueId> expectedIds = Stream.of(
+            root.append("namespace", "sample.other-test"),
+            root.append("namespace", "sample.other-test").append("name", "my-other-works"),
+            root.append("namespace", "sample.other-test").append("name", "my-other-fails"),
+            root.append("namespace", "sample.other-test").append("name", "my-other-error")
+        ).collect(Collectors.toList());
+
+        TestDescriptor descriptor = new ClojureTestEngine().discover(request, root);
+        List<UniqueId> actualIds = descriptor.getAllDescendants().stream()
+            .map(TestDescriptor::getUniqueId)
+            .collect(Collectors.toList());
+
+        assertEquals(expectedIds, actualIds);
+    }
+
+
+    @Test
+    public void selectingByVar() {
+        EngineDiscoveryRequest request = TestDiscoveryRequestBuilder.request()
+            .selectors(selectVar("sample.other-test", "my-other-works"))
+            .build();
+        UniqueId root = UniqueId.root("sample", "test");
+
+        List<UniqueId> expectedIds = Stream.of(
+            root.append("namespace", "sample.other-test"),
+            root.append("namespace", "sample.other-test").append("name", "my-other-works")
+        ).collect(Collectors.toList());
+
+        TestDescriptor descriptor = new ClojureTestEngine().discover(request, root);
+        List<UniqueId> actualIds = descriptor.getAllDescendants().stream()
+            .map(TestDescriptor::getUniqueId)
+            .collect(Collectors.toList());
+
+        assertEquals(expectedIds, actualIds);
+    }
+}
diff --git a/jupiter-engine-clojure.test/src/test/resources/sample/core_test.clj b/jupiter-engine-clojure.test/src/test/resources/sample/core_test.clj
@@ -0,0 +1,8 @@
+(ns sample.core-test
+  (:require [clojure.test :refer :all]))
+
+(deftest my-sample-works
+  (is (= 1 (- 2 1))))
+
+(deftest my-sample-fails
+  (is (= 5 (+ 2 2))))
diff --git a/jupiter-engine-clojure.test/src/test/resources/sample/other_test.clj b/jupiter-engine-clojure.test/src/test/resources/sample/other_test.clj
@@ -0,0 +1,14 @@
+(ns sample.other-test
+    (:require [clojure.test :refer :all]))
+
+(deftest my-other-works
+  (is (= 1 (- 2 1)) "2 - 1 is 1"))
+
+(deftest my-other-fails
+  (is (= 5 (+ 2 2)) "2 + 2 is 5"))
+
+(defn do-stuff [_]
+  (throw (ex-info "Yay it works!" {})))
+
+(deftest my-other-error
+  (is (= 1 (do-stuff 7)) "Do stuff always returns 1"))
diff --git a/...ter-lang-clojure/src/main/java/org/ajoberstar/jupiter/lang/clojure/NamespaceSelector.java b/...ter-lang-clojure/src/main/java/org/ajoberstar/jupiter/lang/clojure/NamespaceSelector.java
@@ -0,0 +1,31 @@
+package org.ajoberstar.jupiter.lang.clojure;
+
+import clojure.java.api.Clojure;
+import clojure.lang.IFn;
+import clojure.lang.Namespace;
+import org.junit.gen5.engine.DiscoverySelector;
+
+public class NamespaceSelector implements DiscoverySelector {
+    private final Namespace namespace;
+
+    private NamespaceSelector(Namespace namespace) {
+        this.namespace = namespace;
+    }
+
+    public Namespace getNamespace() {
+        return namespace;
+    }
+
+    public static NamespaceSelector selectNamespace(String namespace) {
+        IFn symbol = Clojure.var("clojure.core", "symbol");
+        IFn require = Clojure.var("clojure.core", "require");
+        IFn findNs = Clojure.var("clojure.core", "find-ns");
+
+        Object sym = symbol.invoke(namespace);
+        require.invoke(sym);
+
+        Namespace ns = (Namespace) findNs.invoke(sym);
+
+        return new NamespaceSelector(ns);
+    }
+}
diff --git a/jupiter-lang-clojure/src/main/java/org/ajoberstar/jupiter/lang/clojure/VarSelector.java b/jupiter-lang-clojure/src/main/java/org/ajoberstar/jupiter/lang/clojure/VarSelector.java
@@ -0,0 +1,36 @@
+package org.ajoberstar.jupiter.lang.clojure;
+
+import clojure.java.api.Clojure;
+import clojure.lang.IFn;
+import clojure.lang.Namespace;
+import clojure.lang.Var;
+import org.junit.gen5.engine.DiscoverySelector;
+
+public class VarSelector implements DiscoverySelector {
+    private final Var var;
+
+    private VarSelector(Var var) {
+        this.var = var;
+    }
+
+    public Namespace getNamespace() {
+        return var.ns;
+    }
+
+    public Var getVar() {
+        return var;
+    }
+
+    public static VarSelector selectVar(String namespace, String name) {
+        IFn symbol = Clojure.var("clojure.core", "symbol");
+        IFn require = Clojure.var("clojure.core", "require");
+        IFn findVar = Clojure.var("clojure.core", "find-var");
+
+        require.invoke(symbol.invoke(namespace));
+
+        Object sym = symbol.invoke(namespace, name);
+        Var var = (Var) findVar.invoke(sym);
+
+        return new VarSelector(var);
+    }
+}
diff --git a/jupiter-launcher/build.gradle b/jupiter-launcher/build.gradle
@@ -15,6 +15,14 @@ task discoverClojureTest(type: JavaExec) {
     args 'src/sample/clojure.test'
 }
 
+
+task discoverNsClojureTest(type: JavaExec) {
+    classpath sourceSets.main.runtimeClasspath
+    classpath files('src/sample/clojure.test')
+    main = 'org.ajoberstar.jupiter.launcher.DiscoveryPrinter'
+    args 'src/sample/clojure.test'
+}
+
 task executeClojureTest(type: JavaExec) {
     classpath sourceSets.main.runtimeClasspath
     classpath files('src/sample/clojure.test')