some more work on coverage and some cleanup

- get packages for integ tests right
- introduce common AbstractFregeIntegrationSpec
- first stab of unit test coverage for FregeCompile
- minor cleanup on FregeCompile
- configure fregePath as part as part of base plugin convention

4 files changed, 270 insertions, 161 deletions

diff --git a/src/integTest/groovy/frege/gradle/integtest/fixtures/AbstractFregeIntegrationSpec.groovy b/src/integTest/groovy/frege/gradle/integtest/fixtures/AbstractFregeIntegrationSpec.groovy
new file mode 100644
index 0000000..6bcd339
--- /dev/null
+++ b/src/integTest/groovy/frege/gradle/integtest/fixtures/AbstractFregeIntegrationSpec.groovy
@@ -0,0 +1,68 @@
+package frege.gradle.integtest.fixtures
+
+import org.gradle.testkit.runner.GradleRunner
+import org.gradle.testkit.runner.BuildResult
+import org.junit.Rule
+import org.junit.rules.TemporaryFolder
+import spock.lang.Specification
+
+class AbstractFregeIntegrationSpec extends Specification {
+    public static final String DEFAULT_FREGE_VERSION = "3.23.370-g898bc8c"
+    List<File> pluginClasspath
+
+    @Rule
+    final TemporaryFolder testProjectDir = new TemporaryFolder()
+    File buildFile
+
+    def setup() {
+        buildFile = testProjectDir.newFile('build.gradle')
+
+
+        testProjectDir.newFolder("src", "main", "java", "org", "frege")
+        testProjectDir.newFolder("src", "main", "frege", "org", "frege")
+
+        def pluginClasspathResource = getClass().classLoader.findResource("plugin-classpath.txt")
+        if (pluginClasspathResource == null) {
+            // try again via file reference
+            pluginClasspathResource = new File("build/createClasspathManifest/plugin-classpath.txt")
+            if (pluginClasspathResource == null) {
+                throw new IllegalStateException("Did not find plugin classpath resource, run `integTestClasses` build task.")
+            }
+        }
+        pluginClasspath = pluginClasspathResource.readLines().collect { new File(it) }
+    }
+
+
+    BuildResult run(String task) {
+        run(null, task);
+    }
+
+    BuildResult run(String gradleVersion, String task) {
+        def writer = new StringWriter();
+        GradleRunner runner = newRunner(task, writer, gradleVersion)
+        def result = runner.build()
+        println writer;
+        return result;
+    }
+
+    BuildResult fail(String task) {
+        def writer = new StringWriter();
+        GradleRunner runner = newRunner(task, writer, null)
+        def result = runner.buildAndFail()
+        println writer;
+        return result;
+    }
+
+    private GradleRunner newRunner(String task, StringWriter writer, String gradleVersion) {
+        def runner = GradleRunner.create()
+                .withProjectDir(testProjectDir.root)
+                .withArguments(task)
+                .withPluginClasspath(pluginClasspath)
+                .forwardStdOutput(writer)
+        if (gradleVersion) {
+            runner.withGradleVersion(gradleVersion)
+        }
+        runner
+    }
+
+}
diff --git a/src/integTest/groovy/frege/gradle/plugins/FregePluginIntegTest.groovy b/src/integTest/groovy/frege/gradle/plugins/FregePluginIntegTest.groovy
new file mode 100644
index 0000000..e837a2a
--- /dev/null
+++ b/src/integTest/groovy/frege/gradle/plugins/FregePluginIntegTest.groovy
@@ -0,0 +1,128 @@
+package frege.gradle.plugins
+
+import frege.gradle.integtest.fixtures.AbstractFregeIntegrationSpec
+import org.gradle.testkit.runner.BuildResult
+import spock.lang.Unroll
+import static org.gradle.testkit.runner.TaskOutcome.*
+
+class FregePluginIntegTest extends AbstractFregeIntegrationSpec {
+
+    def setup() {
+        buildFile << """
+            plugins {
+                id 'org.frege-lang'
+            }
+
+            repositories {
+                jcenter()
+            }
+        """
+    }
+
+    def "can handle non existing source directories"() {
+        given:
+        buildFile << """
+        dependencies {
+            compile "org.frege-lang:frege:$DEFAULT_FREGE_VERSION"
+        }
+        """
+
+        when:
+        def result = run("classes")
+        then:
+        result.task(":compileFrege").outcome == UP_TO_DATE
+    }
+
+    @Unroll
+    def "can compile and run frege code (gradle: #gradleVersion, frege: #fregeVersion)"() {
+        given:
+        buildFile << """
+        dependencies {
+            compile "org.frege-lang:frege:$fregeVersion"
+        }
+        ${sayHelloTask()}
+        """
+
+        def fregeSourceFile = testProjectDir.newFile("src/main/frege/org/frege/HelloFrege.fr")
+
+        fregeSourceFile << """
+        module org.frege.HelloFrege where
+
+        greeting = "Hello Frege!"
+
+        main _ = do
+            println greeting
+        """
+
+        when:
+        def result = run(gradleVersion, "sayHello")
+
+        then:
+        result.output.contains("Hello Frege!")
+        result.task(":sayHello").outcome == SUCCESS
+
+        where:
+        fregeVersion          | gradleVersion
+        DEFAULT_FREGE_VERSION | "2.9"
+        DEFAULT_FREGE_VERSION | "2.8"
+        "3.22.367-g2737683"   | "2.9"
+        "3.22.367-g2737683"   | "2.8"
+    }
+
+    def "can reference java from frege"() {
+        given:
+        buildFile << """
+        dependencies {
+            compile "org.frege-lang:frege:$DEFAULT_FREGE_VERSION"
+        }
+        ${sayHelloTask()}
+        """
+
+        and:
+        javaCode()
+        fregeCallingJava()
+        when:
+        BuildResult result = run("sayHello")
+        then:
+        result.task(":compileJava").outcome == SUCCESS
+        result.task(":compileFrege").outcome == SUCCESS
+        result.output.contains("hello from java")
+    }
+
+    def fregeCallingJava() {
+
+        File fregeSourceFile = testProjectDir.newFile("src/main/frege/org/frege/HelloFrege.fr")
+        fregeSourceFile << """
+        module org.frege.HelloFrege where
+
+        data StaticHello = pure native org.frege.StaticHello where
+            pure native helloJava org.frege.StaticHello.helloJava:: () -> String
+
+
+        main _ = do
+            println(StaticHello.helloJava())
+
+        """
+    }
+
+    def javaCode(String sourceRoot = "java") {
+        def javaSourceFile = testProjectDir.newFile("src/main/$sourceRoot/org/frege/StaticHello.java")
+
+        javaSourceFile << """
+        package org.frege;
+
+        public class StaticHello {
+            public static String helloJava() {
+                return "hello from java";
+            }
+        }
+        """
+    }
+
+    def sayHelloTask() {
+        return """ task sayHello(type: JavaExec) {
+            classpath = sourceSets.main.runtimeClasspath
+            main = 'org.frege.HelloFrege'
+        } """
+    }
+}
\ No newline at end of file
diff --git a/src/integTest/groovy/frege/gradle/tasks/FregeCompileIntegTest.groovy b/src/integTest/groovy/frege/gradle/tasks/FregeCompileIntegTest.groovy
new file mode 100644
index 0000000..58e21ba
--- /dev/null
+++ b/src/integTest/groovy/frege/gradle/tasks/FregeCompileIntegTest.groovy
@@ -0,0 +1,74 @@
+package frege.gradle.tasks
+import frege.gradle.integtest.fixtures.AbstractFregeIntegrationSpec
+
+import static org.gradle.testkit.runner.TaskOutcome.FAILED
+
+class FregeCompileIntegTest extends AbstractFregeIntegrationSpec {
+
+    List<File> pluginClasspath
+
+    def setup() {
+        buildFile << """
+            plugins {
+                id 'org.frege-lang.base'
+            }
+
+            import frege.gradle.tasks.FregeCompile
+
+            repositories { jcenter() }
+
+            configurations { frege {} }
+
+            dependencies {
+                frege "org.frege-lang:frege:$DEFAULT_FREGE_VERSION"
+            }
+
+            task compile(type: FregeCompile) {
+                destinationDir = file("frege-output")
+                source("frege-src")
+                module = "frege-src"
+                classpath = configurations.frege
+                fregePath = configurations.frege
+            }
+        """
+
+        testProjectDir.newFolder("frege-src")
+    }
+
+    def "shows compile errors"() {
+        given:
+        simpleFrege()
+        failingFrege()
+        when:
+        def result = fail("compile")
+
+        then:
+        result.task(":compile").outcome == FAILED
+        result.output.contains("Failing.fr:6: can't resolve `Hello`")
+    }
+
+    def failingFrege() {
+        def failingFrege = testProjectDir.newFile("frege-src/Failing.fr")
+        failingFrege << """
+
+        module Failing where
+
+        failingFun _ = do
+            println(Hello)
+        """
+    }
+
+    def simpleFrege() {
+
+        def helloFrege = testProjectDir.newFile("frege-src/Hello.fr")
+        helloFrege << """
+
+        module Hello where
+
+        import frege.prelude.PreludeBase
+
+        main _ = do
+            println("Hello From Frege")
+        """
+    }
+}
diff --git a/src/integTest/groovy/frege/plugin/FregePluginIntegTest.groovy b/src/integTest/groovy/frege/plugin/FregePluginIntegTest.groovy
deleted file mode 100644
index 40afe4a..0000000
--- a/src/integTest/groovy/frege/plugin/FregePluginIntegTest.groovy
+++ /dev/null
@@ -1,161 +0,0 @@
-package frege.plugin
-import org.gradle.testkit.runner.GradleRunner
-import org.junit.Rule
-import org.junit.rules.TemporaryFolder
-import spock.lang.Specification
-import spock.lang.Unroll
-
-import static org.gradle.testkit.runner.TaskOutcome.SUCCESS
-
-class FregePluginIntegTest extends Specification {
-
-    public static final String DEFAULT_FREGE_VERSION = "3.23.370-g898bc8c"
-    @Rule
-    final TemporaryFolder testProjectDir = new TemporaryFolder()
-    File buildFile
-
-    List<File> pluginClasspath
-
-    def setup() {
-        buildFile = testProjectDir.newFile('build.gradle')
-
-        buildFile << """
-            plugins {
-                id 'org.frege-lang'
-            }
-
-            repositories {
-                jcenter()
-            }
-        """
-        def pluginClasspathResource = getClass().classLoader.findResource("plugin-classpath.txt")
-        if (pluginClasspathResource == null) {
-            // try again via file reference
-            pluginClasspathResource = new File("build/createClasspathManifest/plugin-classpath.txt")
-            if (pluginClasspathResource == null) {
-                throw new IllegalStateException("Did not find plugin classpath resource, run `integTestClasses` build task.")
-            }
-        }
-        pluginClasspath = pluginClasspathResource.readLines().collect { new File(it) }
-    }
-
-    def "can handle non existing source directories"() {
-        given:
-        buildFile << """
-            dependencies {
-                compile "org.frege-lang:frege:$DEFAULT_FREGE_VERSION"
-            }
-        """
-
-        when:
-        def result = GradleRunner.create()
-                .withProjectDir(testProjectDir.root)
-                .withArguments('classes')
-                .withPluginClasspath(pluginClasspath)
-                .build()
-        then:
-        result.task(":compileFrege") != null
-    }
-
-    @Unroll
-    def "can compile and run frege code (gradle: #gradleVersion, frege: #fregeVersion)"() {
-        given:
-        buildFile << """
-            dependencies {
-                compile "org.frege-lang:frege:$fregeVersion"
-            }
-            ${sayHelloTask()}
-        """
-
-        testProjectDir.newFolder("src", "main", "frege", "org", "frege")
-        def fregeSourceFile = testProjectDir.newFile("src/main/frege/org/frege/HelloFrege.fr")
-
-        fregeSourceFile << """
-module org.frege.HelloFrege where
-
-greeting = "Hello Frege!"
-
-main _ = do
-    println greeting
-"""
-
-        when:
-        def result = GradleRunner.create()
-                .withGradleVersion(gradleVersion)
-                .withProjectDir(testProjectDir.root)
-                .withArguments('sayHello')
-                .withPluginClasspath(pluginClasspath)
-                .build()
-
-        then:
-        result.output.contains("Hello Frege!")
-        result.task(":sayHello").outcome == SUCCESS
-
-        where:
-        fregeVersion          | gradleVersion
-        DEFAULT_FREGE_VERSION | "2.9"
-        DEFAULT_FREGE_VERSION | "2.8"
-        "3.22.367-g2737683"   | "2.9"
-        "3.22.367-g2737683"   | "2.8"
-    }
-
-
-    def "can reference java from frege"() {
-        given:
-        buildFile << """
-            dependencies {
-                compile "org.frege-lang:frege:$DEFAULT_FREGE_VERSION"
-            }
-
-            ${sayHelloTask()}
-        """
-
-        and:
-        testProjectDir.newFolder("src", "main", "frege", "org", "frege")
-
-        def fregeSourceFile = testProjectDir.newFile("src/main/frege/org/frege/HelloFrege.fr")
-
-        fregeSourceFile << """
-module org.frege.HelloFrege where
-
-data StaticHello = pure native org.frege.StaticHello where
-    pure native helloJava org.frege.StaticHello.helloJava :: () -> String
-
-main _ = do
-    println(StaticHello.helloJava())
-
-"""
-        testProjectDir.newFolder("src", "main", "java", "org", "frege")
-        def javaSourceFile = testProjectDir.newFile("src/main/java/org/frege/StaticHello.java")
-
-        javaSourceFile << """
-package org.frege;
-
-public class StaticHello {
-    public static String helloJava() {
-        return "hello from java";
-    }
-}
-"""
-
-        when:
-        def result = GradleRunner.create()
-                .withProjectDir(testProjectDir.root)
-                .withArguments('sayHello')
-                .withPluginClasspath(pluginClasspath)
-                .build()
-        then:
-        result.task(":compileJava").outcome == SUCCESS
-        result.task(":compileFrege").outcome == SUCCESS
-
-        result.output.contains("hello from java")
-    }
-
-
-    def sayHelloTask() {
-        return """task sayHello(type: JavaExec){
-            classpath = sourceSets.main.runtimeClasspath
-            main = 'org.frege.HelloFrege'
-        }"""
-    }
-}
\ No newline at end of file