test cases running with Maven from CLI and IDE

Author: LorenzBuehmann

sansa-inference-tests/pom.xml

@@ -54,6 +54,11 @@
       <groupId>org.scalatest</groupId>
       <artifactId>scalatest_${scala.binary.version}</artifactId>
     </dependency>
+
+    <dependency>
+      <groupId>com.typesafe.scala-logging</groupId>
+      <artifactId>scala-logging_${scala.binary.version}</artifactId>
+    </dependency>
   </dependencies>
 
   <build>

sansa-inference-tests/src/test/scala/net/sansa_stack/test/conformance/ConformanceTestBase.scala

@@ -1,16 +1,18 @@
 package net.sansa_stack.test.conformance
 
-import java.io.File
+import java.io.{File, StringWriter}
+import java.nio.file.{Path, Paths}
 
 import net.sansa_stack.inference.data.{RDF, RDFOps}
 import org.apache.jena.rdf.model.Model
 import org.apache.jena.shared.PrefixMapping
 import org.junit.runner.RunWith
 import org.scalatest.junit.JUnitRunner
 import org.scalatest.{BeforeAndAfterAll, FlatSpec}
-
 import scala.collection.mutable
 
+import net.sansa_stack.test.conformance.TestCases.getClass
+
 /**
   * The class is to test the conformance of each materialization rule of RDFS(simple) entailment.
   *
@@ -20,15 +22,15 @@ import scala.collection.mutable
 @RunWith(classOf[JUnitRunner])
 abstract class ConformanceTestBase[Rdf <: RDF](val rdfOps: RDFOps[Rdf]) extends FlatSpec with BeforeAndAfterAll {
 
+  val logger = com.typesafe.scalalogging.Logger("ConformanceTestBase")
+
   behavior of ""
 
   // the test case IDs
   def testCaseIds: Set[String]
 
-  // the base directory of the test cases
-  def testsCasesFolder: File = {
-    new File(this.getClass.getClassLoader.getResource(testCasesPath).getPath)
-  }
+  def testsCasesFolder: String = testCasesPath // this.getClass.getClassLoader.getResource(testCasesPath).getPath
+//  def testsCasesFolder: File = null // new File(this.getClass.getClassLoader.getResource(testCasesPath).getPath)
 
   def testCasesPath: String
 
@@ -38,12 +40,10 @@ abstract class ConformanceTestBase[Rdf <: RDF](val rdfOps: RDFOps[Rdf]) extends
     .withDefaultMappings(PrefixMapping.Standard)
 
   // load the test cases
-  private val testCases = TestCases.loadTestCases(testsCasesFolder, testCaseIds)
+  lazy val testCases = TestCases.loadTestCasesJar(testsCasesFolder, testCaseIds)
 
   // scalastyle:off println
   testCases.foreach { testCase =>
-    println(testCase.id)
-
     testCase.id should "produce the same graph" in {
       val triples = new mutable.HashSet[Rdf#Triple]()
 
@@ -71,14 +71,20 @@ abstract class ConformanceTestBase[Rdf <: RDF](val rdfOps: RDFOps[Rdf]) extends
       // remove the input triples such that we can compare only the conclusion graph
       inferredModel.remove(testCase.inputGraph)
 
-      println("#" * 80 + "\ninput:")
-      testCase.inputGraph.write(System.out, "TURTLE")
+      logger.whenDebugEnabled {
+        println("#" * 80 + "\ninput:")
+        testCase.inputGraph.write(System.out, "TURTLE")
+      }
 
-      println("#" * 80 + "\nexpected output:")
-      testCase.outputGraph.write(System.out, "TURTLE")
+      logger.whenDebugEnabled {
+        println("#" * 80 + "\nexpected output:")
+        testCase.outputGraph.write(System.out, "TURTLE")
+      }
 
-      println("#" * 80 + "\ngot output:")
-      inferredModel.write(System.out, "TURTLE")
+      logger.whenDebugEnabled {
+        println("#" * 80 + "\ngot output:")
+        inferredModel.write(System.out, "TURTLE")
+      }
 
       // compare models, i.e. the inferred model should contain exactly the triples of the conclusion graph
       val correctOutput = inferredModel.containsAll(testCase.outputGraph)

sansa-inference-tests/src/test/scala/net/sansa_stack/test/conformance/TestCases.scala

@@ -1,19 +1,27 @@
 package net.sansa_stack.test.conformance
 
 import java.io.File
+import java.nio.file.{FileSystem, Path}
 
-import org.apache.jena.riot.RDFDataMgr
-
+import org.apache.jena.riot.{Lang, RDFDataMgr}
 import scala.collection.mutable.ListBuffer
 import scala.xml.XML
 
+import org.apache.commons.io.IOUtils
+import org.apache.jena.rdf.model.ModelFactory
+import org.scalatest.path
+
 /**
   * Test cases loader.
   *
   * @author Lorenz Buehmann
   */
 object TestCases {
 
+  val logger = com.typesafe.scalalogging.Logger("TestCases")
+
+  var fs: FileSystem = null
+
   /**
     * Loads test cases from the given root folder.
     *
@@ -25,6 +33,8 @@ object TestCases {
 
     val testCases = new ListBuffer[TestCase]()
 
+    println(directory)
+
     directory.listFiles().filter(f => f.isDirectory && (ids.isEmpty || ids.contains(f.getName))).foreach { subDirectory =>
 
       // the files in the directory
@@ -61,4 +71,88 @@ object TestCases {
 
     testCases
   }
+
+  /**
+    * Loads test cases from the given root folder.
+    *
+    * @param directory the root folder containing sub-folders for each test case
+    * @return test cases
+    */
+  def loadTestCasesJar(directory: String, ids: Set[String] = Set.empty): Seq[TestCase] = {
+    logger.info(s"loading test cases from ${directory}...")
+
+    val testCases = new ListBuffer[TestCase]()
+
+    listFiles(directory).filter(f => ids.isEmpty || ids.contains(f.getFileName.toString.replace("/", ""))).map { p =>
+
+      // the files in the directory
+      val files = listFiles(
+        if (p.toUri.getScheme == "jar") p.toString.substring(1) else p.toString, true)
+
+      // get the metadata file
+      val metadataFile = files.filter(_.toString.endsWith(".metadata.properties")).head
+
+      // load metadata XML
+      val metadata = XML.load(metadataFile.toUri.toURL.openStream())
+
+      // id
+      val id = (metadata \\ "entry").filter(n => n.attribute("key").get.text == "testcase.id").text
+
+      // description
+      val description = (metadata \\ "entry").filter(n => n.attribute("key").get.text == "testcase.description").text
+
+      // test case type
+      val entailmentType = (metadata \\ "entry").filter(n => n.attribute("key").get.text == "testcase.type").text
+
+      // currently we support only entailment test cases
+      if (entailmentType == "POSITIVE_ENTAILMENT") {
+        // load input data
+
+        val inputGraph = ModelFactory.createDefaultModel()
+        inputGraph.read(files.filter(_.toString.endsWith(".premisegraph.ttl")).head.toUri.toURL.openStream(), null, "Turtle")
+
+        // load output data
+        val outputGraph = ModelFactory.createDefaultModel()
+        outputGraph.read(files.filter(_.toString.endsWith(".conclusiongraph.ttl")).head.toUri.toURL.openStream(), null, "Turtle")
+
+        testCases += TestCase(id, description, entailmentType, inputGraph, outputGraph)
+      }
+    }
+//    directory.listFiles().filter(f => f.isDirectory && (ids.isEmpty || ids.contains(f.getName))).foreach { subDirectory =>
+
+
+    println(s"loaded ${testCases.size} test cases")
+
+    if(fs != null) fs.close()
+
+    testCases
+  }
+
+  private def listFiles(path: String, subDir: Boolean = false): Seq[Path] = {
+    import java.nio.file.FileSystems
+    import java.nio.file.Files
+    import java.nio.file.Paths
+    import java.util.Collections
+
+//    println(s"path: $path")
+    val uri = if (path.startsWith("/")) new File(path).toURI else classOf[TestCase].getClassLoader.getResource(path).toURI
+//    println(s"uri: $uri")
+    var myPath: Path = null
+    if (uri.getScheme == "jar" && !subDir) {
+      fs = FileSystems.newFileSystem(uri, Collections.emptyMap[String, Any])
+      myPath = fs.getPath(path)
+    }
+    else myPath = Paths.get(uri)
+    val walk = Files.walk(myPath, 1)
+    val it = walk.iterator
+    var files = Seq[Path]()
+    while ({it.hasNext}) {
+      val subPath = it.next()
+      if(!subPath.equals(myPath)) {
+        files :+= subPath
+      }
+    }
+
+    files
+  }
 }