From a537432b4cba7c95f69fad6812dfd66d412c89df Mon Sep 17 00:00:00 2001 From: Damien Goutte-Gattat Date: Tue, 20 Feb 2024 23:10:18 +0000 Subject: [PATCH] Add test fixture for KGCLWriter. Add a test fixture for the KGCLWriter class. We only test using a string-backed writer object, so that we do not have to actually write any file anywhere. Also slightly rearrange the KGCLReader test to use a callback-based method as the main helper method, and add a test for the use of a prefix manager derived from a OWL ontology. --- .../incenp/obofoundry/kgcl/KGCLWriter.java | 10 ++ .../obofoundry/kgcl/KGCLReaderTest.java | 70 ++++++--- .../obofoundry/kgcl/KGCLWriterTest.java | 135 ++++++++++++++++++ 3 files changed, 193 insertions(+), 22 deletions(-) create mode 100644 core/src/test/java/org/incenp/obofoundry/kgcl/KGCLWriterTest.java diff --git a/core/src/main/java/org/incenp/obofoundry/kgcl/KGCLWriter.java b/core/src/main/java/org/incenp/obofoundry/kgcl/KGCLWriter.java index d4fda0f..9a5cad9 100644 --- a/core/src/main/java/org/incenp/obofoundry/kgcl/KGCLWriter.java +++ b/core/src/main/java/org/incenp/obofoundry/kgcl/KGCLWriter.java @@ -24,6 +24,7 @@ import java.io.IOException; import java.io.OutputStream; import java.io.OutputStreamWriter; +import java.io.Writer; import java.util.List; import org.incenp.obofoundry.kgcl.model.Change; @@ -50,6 +51,15 @@ public KGCLWriter(OutputStream kgclOutput) { output = new BufferedWriter(new OutputStreamWriter(kgclOutput)); } + /** + * Creates a new instance to write to a character stream writer. + * + * @param kgclOutput The character stream to write to. + */ + public KGCLWriter(Writer kgclOutput) { + output = new BufferedWriter(kgclOutput); + } + /** * Creates a new instance to write to a file. * diff --git a/core/src/test/java/org/incenp/obofoundry/kgcl/KGCLReaderTest.java b/core/src/test/java/org/incenp/obofoundry/kgcl/KGCLReaderTest.java index 15b9add..046b0e5 100644 --- a/core/src/test/java/org/incenp/obofoundry/kgcl/KGCLReaderTest.java +++ b/core/src/test/java/org/incenp/obofoundry/kgcl/KGCLReaderTest.java @@ -18,13 +18,11 @@ package org.incenp.obofoundry.kgcl; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - +import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.List; +import java.util.function.Consumer; import org.incenp.obofoundry.kgcl.model.Change; import org.incenp.obofoundry.kgcl.model.ClassCreation; @@ -50,6 +48,10 @@ import org.incenp.obofoundry.kgcl.model.TextDefinitionReplacement; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import org.semanticweb.owlapi.apibinding.OWLManager; +import org.semanticweb.owlapi.model.OWLOntology; +import org.semanticweb.owlapi.model.OWLOntologyCreationException; +import org.semanticweb.owlapi.model.OWLOntologyManager; import org.semanticweb.owlapi.vocab.OWLRDFVocabulary; class KGCLReaderTest { @@ -60,8 +62,8 @@ class KGCLReaderTest { void testFileParser() throws IOException { KGCLReader reader = new KGCLReader("src/test/resources/sample1.kgcl"); reader.setPrefixManager(util.getPrefixManager()); - assertTrue(reader.read()); - assertEquals(5, reader.getChangeSet().size()); + Assertions.assertTrue(reader.read()); + Assertions.assertEquals(5, reader.getChangeSet().size()); NodeRename c1 = new NodeRename(); c1.setAboutNode(util.getNode("0001")); @@ -172,9 +174,24 @@ void testUnknownPrefixIsOBOStyleID() { testParse("obsolete PFX:0001", change); // Same with no prefix manager at all - KGCLReader reader = new KGCLReader(); - reader.read("obsolete PFX:0001"); - Assertions.assertEquals(change, reader.getChangeSet().get(0)); + testParse(r -> r.read("obsolete PFX:0001"), change); + } + + @Test + void testUsingOntologyDerivedPrefixManager() { + NodeObsoletion change = new NodeObsoletion(); + change.setAboutNode(util.getForeignNode("http://www.co-ode.org/ontologies/pizza/pizza.owl#LaReine")); + + OWLOntologyManager mgr = OWLManager.createOWLOntologyManager(); + try { + OWLOntology ont = mgr.loadOntologyFromOntologyDocument(new File("src/test/resources/pizza.ofn")); + testParse(r -> { + r.setPrefixManager(ont); + r.read("obsolete pizza:LaReine"); + }, change); + } catch ( OWLOntologyCreationException e ) { + Assertions.fail(e); + } } @Test @@ -411,33 +428,42 @@ void testAnnotationChange() { } /* - * Try parsing a KGCL string and check that there is no error. If 'expected' is - * not null, check that the change effectively parsed matches what was expected; - * otherwise, check that no changes at all have been parsed. + * Helper method to test the KGCLReader. It initialises a non-file-based reader, + * calls the specified callback with the reader, then checks that the change + * parsed by the reader matches what was expected. */ - void testParse(String kgcl, Change expected) { + void testParse(Consumer c, Change expected) { KGCLReader reader = new KGCLReader(); - reader.setPrefixManager(util.getPrefixManager()); + c.accept(reader); - assertTrue(reader.read(kgcl)); - assertTrue(reader.getErrors().isEmpty()); + Assertions.assertTrue(reader.getErrors().isEmpty()); List changes = reader.getChangeSet(); if ( expected == null ) { - // The parser should always return an empty list - assertTrue(changes.isEmpty()); + // The parser should always return an empty list. + Assertions.assertTrue(changes.isEmpty()); } else { - assertEquals(1, changes.size()); - assertEquals(expected, changes.get(0)); + Assertions.assertEquals(1, changes.size()); + Assertions.assertEquals(expected, changes.get(0)); } } + /* + * Variant of the previous method to test parsing a single string. + */ + void testParse(String kgcl, Change expected) { + testParse(r -> { + r.setPrefixManager(util.getPrefixManager()); + Assertions.assertTrue(r.read(kgcl)); + }, expected); + } + /* * Try parsing a known bogus KGCL string and check that it fails as expected. */ void testParseFail(String kgcl) { KGCLReader reader = new KGCLReader(); - assertFalse(reader.read(kgcl)); - assertTrue(reader.getErrors().size() > 0); + Assertions.assertFalse(reader.read(kgcl)); + Assertions.assertTrue(reader.getErrors().size() > 0); } } diff --git a/core/src/test/java/org/incenp/obofoundry/kgcl/KGCLWriterTest.java b/core/src/test/java/org/incenp/obofoundry/kgcl/KGCLWriterTest.java new file mode 100644 index 0000000..d585cee --- /dev/null +++ b/core/src/test/java/org/incenp/obofoundry/kgcl/KGCLWriterTest.java @@ -0,0 +1,135 @@ +/* + * KGCL-Java - KGCL library for Java + * Copyright © 2024 Damien Goutte-Gattat + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the Gnu General Public License + * along with this program. If not, see . + */ + +package org.incenp.obofoundry.kgcl; + +import java.io.File; +import java.io.IOException; +import java.io.StringWriter; +import java.util.ArrayList; + +import org.incenp.obofoundry.kgcl.model.Change; +import org.incenp.obofoundry.kgcl.model.ClassCreation; +import org.incenp.obofoundry.kgcl.model.NodeObsoletion; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.semanticweb.owlapi.apibinding.OWLManager; +import org.semanticweb.owlapi.model.OWLOntology; +import org.semanticweb.owlapi.model.OWLOntologyCreationException; +import org.semanticweb.owlapi.model.OWLOntologyManager; + +public class KGCLWriterTest { + + private static final TestUtils util = new TestUtils(); + + @Test + void testWriteSingleChange() { + NodeObsoletion change = new NodeObsoletion(); + change.setAboutNode(util.getNode("0001")); + testSimpleWrite(w -> w.write(change), "obsolete \n"); + } + + @Test + void testWriteChangeset() { + NodeObsoletion c1 = new NodeObsoletion(); + c1.setAboutNode(util.getNode("0001")); + + ClassCreation c2 = new ClassCreation(); + c2.setAboutNode(util.getNode("0002")); + c2.setNewValue("new class"); + + ArrayList changeset = new ArrayList(); + changeset.add(c1); + changeset.add(c2); + + testSimpleWrite(w -> w.write(changeset), + "obsolete \ncreate class \"new class\"\n"); + } + + @Test + void testWriteComment() { + testSimpleWrite(w -> w.write("a comment"), "# a comment\n"); + } + + @Test + void testMultipleWrite() { + NodeObsoletion c1 = new NodeObsoletion(); + c1.setAboutNode(util.getNode("0001")); + + ClassCreation c2 = new ClassCreation(); + c2.setAboutNode(util.getNode("0002")); + c2.setNewValue("new class"); + + testSimpleWrite(w -> { + w.write(c1); + w.write("a comment"); + w.write(c2); + }, "obsolete \n# a comment\ncreate class \"new class\"\n"); + } + + @Test + void testWriteWithPrefixManager() { + NodeObsoletion change = new NodeObsoletion(); + change.setAboutNode(util.getNode("0001")); + + testSimpleWrite(w -> { + w.setPrefixManager(util.getPrefixManager()); + w.write(change); + }, "obsolete EX:0001\n"); + } + + @Test + void testWriteWithOntologyDerivedPrefixManager() { + NodeObsoletion change = new NodeObsoletion(); + change.setAboutNode(util.getForeignNode("http://www.co-ode.org/ontologies/pizza/pizza.owl#LaReine")); + + OWLOntologyManager mgr = OWLManager.createOWLOntologyManager(); + try { + OWLOntology ont = mgr.loadOntologyFromOntologyDocument(new File("src/test/resources/pizza.ofn")); + testSimpleWrite(w -> { + w.setPrefixManager(ont); + w.write(change); + }, "obsolete pizza:LaReine\n"); + } catch ( OWLOntologyCreationException e ) { + Assertions.fail(e); + } + } + + /* + * Helper method to test the KGCLWriter. This creates a string-backed writer, + * calls the provided callback with the writer, then checks that the writer + * wrote what was expected. + */ + private void testSimpleWrite(IKGCLWriterConsumer c, String expected) { + StringWriter writer = new StringWriter(); + KGCLWriter kgclWriter = new KGCLWriter(writer); + try { + c.accept(kgclWriter); + kgclWriter.close(); + } catch ( IOException ioe ) { + Assertions.fail(ioe); + } + + Assertions.assertEquals(expected, writer.toString()); + } +} + +/* The callback passed to the testSimpleWrite method above. */ +interface IKGCLWriterConsumer { + void accept(KGCLWriter writer) throws IOException; +}