VIVO-823 Create several ModelMaker decorators, with tests
This commit is contained in:
Jim Blake
parent
553bd417f7
commit
04f763109e
10 changed files with 1690 additions and 0 deletions
|
|
@ -0,0 +1,223 @@
|
|||
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
|
||||
|
||||
package edu.cornell.mannlib.vitro.webapp.modelaccess.adapters;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.junit.Assert.fail;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import stubs.com.hp.hpl.jena.rdf.model.ModelMaker.ModelMakerStub;
|
||||
|
||||
import com.hp.hpl.jena.rdf.model.Model;
|
||||
import com.hp.hpl.jena.rdf.model.ModelFactory;
|
||||
import com.hp.hpl.jena.rdf.model.ModelMaker;
|
||||
import com.hp.hpl.jena.rdf.model.ModelReader;
|
||||
import com.hp.hpl.jena.shared.AlreadyExistsException;
|
||||
import com.hp.hpl.jena.shared.CannotCreateException;
|
||||
import com.hp.hpl.jena.shared.DoesNotExistException;
|
||||
|
||||
import edu.cornell.mannlib.vitro.testing.AbstractTestClass;
|
||||
|
||||
/**
|
||||
* TODO
|
||||
*/
|
||||
public class ListCachingModelMakerTest extends AbstractTestClass {
|
||||
private static final String URI_ONE = "http://model.one";
|
||||
private static final String URI_TWO = "http://model.two";
|
||||
private static final String URI_NONE = "http://model.does.not.exist";
|
||||
|
||||
private static final Model MODEL_ONE = createModel();
|
||||
private static final Model MODEL_TWO = createModel();
|
||||
private static final Model MODEL_DEFAULT = createModel();
|
||||
private static final Model MODEL_FRESH = createModel();
|
||||
|
||||
private ModelMaker rigorous;
|
||||
private ModelMaker relaxed;
|
||||
private ModelMaker mm;
|
||||
private ModelReader modelReader;
|
||||
|
||||
private static Model createModel() {
|
||||
return ModelFactory.createDefaultModel();
|
||||
}
|
||||
|
||||
@Before
|
||||
public void setup() {
|
||||
rigorous = ModelMakerStub.rigorous(MODEL_DEFAULT, MODEL_FRESH)
|
||||
.put(URI_ONE, MODEL_ONE).put(URI_TWO, MODEL_TWO);
|
||||
relaxed = ModelMakerStub.relaxed(MODEL_DEFAULT, MODEL_FRESH)
|
||||
.put(URI_ONE, MODEL_ONE).put(URI_TWO, MODEL_TWO);
|
||||
relaxed(); // call rigorous() to override, if desired.
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// The tests
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
@Test(expected = NullPointerException.class)
|
||||
public void nullInnerModel() {
|
||||
new ListCachingModelMaker(null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void listModels() {
|
||||
assertList(URI_ONE, URI_TWO);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hasModelExist() {
|
||||
assertTrue(mm.hasModel(URI_ONE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hasModelNonExist() {
|
||||
assertFalse(mm.hasModel(URI_NONE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createModelExist() {
|
||||
assertEquals(MODEL_ONE, mm.createModel(URI_ONE));
|
||||
assertList(URI_ONE, URI_TWO);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createModelNonExist() {
|
||||
assertEquals(MODEL_FRESH, mm.createModel(URI_NONE));
|
||||
assertList(URI_ONE, URI_TWO, URI_NONE);
|
||||
}
|
||||
|
||||
@Test(expected = AlreadyExistsException.class)
|
||||
public void createModelStrictExist() {
|
||||
mm.createModel(URI_ONE, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createModelStrictNonExist() {
|
||||
assertEquals(MODEL_FRESH, mm.createModel(URI_NONE, true));
|
||||
assertList(URI_ONE, URI_TWO, URI_NONE);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void openModelExist() {
|
||||
assertEquals(MODEL_TWO, mm.openModel(URI_TWO));
|
||||
assertList(URI_ONE, URI_TWO);
|
||||
}
|
||||
|
||||
@Test(expected = DoesNotExistException.class)
|
||||
public void openModelRigorousNonExist() {
|
||||
rigorous();
|
||||
mm.openModel(URI_NONE);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void openModelRelaxedNonExist() {
|
||||
assertEquals(MODEL_FRESH, mm.openModel(URI_NONE));
|
||||
assertList(URI_ONE, URI_TWO, URI_NONE);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void openModelIfPresentExist() {
|
||||
assertEquals(MODEL_TWO, mm.openModelIfPresent(URI_TWO));
|
||||
assertList(URI_ONE, URI_TWO);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void openModelIfPresentNonExist() {
|
||||
assertNull(mm.openModelIfPresent(URI_NONE));
|
||||
assertList(URI_ONE, URI_TWO);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void openModelStrictExist() {
|
||||
assertEquals(MODEL_ONE, mm.openModel(URI_ONE, true));
|
||||
assertList(URI_ONE, URI_TWO);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void openModelNonStrictExist() {
|
||||
assertEquals(MODEL_ONE, mm.openModel(URI_ONE, false));
|
||||
assertList(URI_ONE, URI_TWO);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void openModelNonStrictNonExist() {
|
||||
assertEquals(MODEL_FRESH, mm.openModel(URI_NONE, false));
|
||||
assertList(URI_ONE, URI_TWO, URI_NONE);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void removeModelExist() {
|
||||
mm.removeModel(URI_ONE);
|
||||
assertList(URI_TWO);
|
||||
}
|
||||
|
||||
@Test(expected = DoesNotExistException.class)
|
||||
public void removeModelNonExist() {
|
||||
mm.removeModel(URI_NONE);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getModelExist() {
|
||||
assertEquals(MODEL_TWO, mm.getModel(URI_TWO));
|
||||
assertList(URI_ONE, URI_TWO);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getModelRigorousNonExist() {
|
||||
rigorous();
|
||||
assertNull(mm.getModel(URI_NONE));
|
||||
assertList(URI_ONE, URI_TWO);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getModelRelaxedNonExist() {
|
||||
assertEquals(MODEL_FRESH, mm.getModel(URI_NONE));
|
||||
assertList(URI_ONE, URI_TWO, URI_NONE);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getModelLoadIfAbsentExist() {
|
||||
assertEquals(MODEL_TWO, mm.getModel(URI_TWO, modelReader));
|
||||
assertList(URI_ONE, URI_TWO);
|
||||
}
|
||||
|
||||
@Test(expected = CannotCreateException.class)
|
||||
public void getModelLoadIfAbsentRigorousNonExist() {
|
||||
rigorous();
|
||||
mm.getModel(URI_NONE, modelReader);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getModelLoadIfAbsentRelaxedNonExist() {
|
||||
assertEquals(MODEL_FRESH, mm.getModel(URI_NONE, modelReader));
|
||||
assertList(URI_ONE, URI_TWO, URI_NONE);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// Helper methods
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
private void relaxed() {
|
||||
mm = new ListCachingModelMaker(relaxed);
|
||||
}
|
||||
|
||||
private void rigorous() {
|
||||
mm = new ListCachingModelMaker(rigorous);
|
||||
}
|
||||
|
||||
private void assertList(String... expectedArray) {
|
||||
Set<String> expected = new HashSet<>(Arrays.asList(expectedArray));
|
||||
Set<String> actual = mm.listModels().toSet();
|
||||
assertEquals(expected, actual);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,174 @@
|
|||
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
|
||||
|
||||
package edu.cornell.mannlib.vitro.webapp.modelaccess.adapters;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import java.io.StringReader;
|
||||
import java.lang.reflect.InvocationHandler;
|
||||
import java.lang.reflect.Method;
|
||||
import java.lang.reflect.Proxy;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import stubs.com.hp.hpl.jena.rdf.model.ModelMaker.ModelMakerStub;
|
||||
|
||||
import com.hp.hpl.jena.graph.Graph;
|
||||
import com.hp.hpl.jena.graph.impl.CollectionGraph;
|
||||
import com.hp.hpl.jena.rdf.model.Model;
|
||||
import com.hp.hpl.jena.rdf.model.ModelFactory;
|
||||
import com.hp.hpl.jena.rdf.model.Property;
|
||||
import com.hp.hpl.jena.rdf.model.Resource;
|
||||
import com.hp.hpl.jena.rdf.model.ResourceFactory;
|
||||
import com.hp.hpl.jena.rdf.model.Statement;
|
||||
|
||||
import edu.cornell.mannlib.vitro.testing.AbstractTestClass;
|
||||
|
||||
/**
|
||||
* TODO
|
||||
*/
|
||||
public class MemoryMappingModelMakerTest extends AbstractTestClass {
|
||||
private static final String URI_MAPPED = "http://memory.mapped.model";
|
||||
private static final String URI_UNMAPPED = "http://unmapped.model";
|
||||
private static final String MODEL_CONTENTS = "@prefix : <http://z#> . \n"
|
||||
+ ":a :b :c .";
|
||||
|
||||
private GraphModelStructure unmapped;
|
||||
private GraphModelStructure mapped;
|
||||
private ModelMakerStub innerModelMaker;
|
||||
private MemoryMappingModelMaker mmmm;
|
||||
|
||||
@Before
|
||||
public void setup() {
|
||||
unmapped = new GraphModelStructure(URI_UNMAPPED, MODEL_CONTENTS);
|
||||
mapped = new GraphModelStructure(URI_MAPPED, MODEL_CONTENTS);
|
||||
|
||||
innerModelMaker = ModelMakerStub.rigorous(createModel(), createModel());
|
||||
innerModelMaker.put(mapped.uri, mapped.model);
|
||||
innerModelMaker.put(unmapped.uri, unmapped.model);
|
||||
|
||||
mmmm = new MemoryMappingModelMaker(innerModelMaker, mapped.uri);
|
||||
|
||||
unmapped.methodCalls.clear();
|
||||
mapped.methodCalls.clear();
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// tests
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
public void unmappedRead() {
|
||||
assertModelContents(unmapped, "[http://z#a, http://z#b, http://z#c]");
|
||||
assertMethodCalls(unmapped, "find");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mappedRead() {
|
||||
assertModelContents(mapped, "[http://z#a, http://z#b, http://z#c]");
|
||||
assertMethodCalls(mapped);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void unmappedWrite() {
|
||||
mmmm.openModel(URI_UNMAPPED).add(newStatement());
|
||||
assertModelContents(unmapped, "[http://z#a, http://z#b, http://z#c]",
|
||||
"[http://z#new, http://z#to, http://z#you]");
|
||||
assertMethodCalls(unmapped, "add", "find");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mappedWrite() {
|
||||
mmmm.openModel(URI_MAPPED).add(newStatement());
|
||||
assertModelContents(mapped, "[http://z#a, http://z#b, http://z#c]",
|
||||
"[http://z#new, http://z#to, http://z#you]");
|
||||
assertMethodCalls(mapped, "add");
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// Helper methods
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
private static Model createModel() {
|
||||
return ModelFactory.createDefaultModel();
|
||||
}
|
||||
|
||||
private void assertModelContents(GraphModelStructure gms,
|
||||
String... expected) {
|
||||
Set<Statement> stmts = mmmm.openModel(gms.uri).listStatements().toSet();
|
||||
assertStatements(stmts, expected);
|
||||
}
|
||||
|
||||
private void assertStatements(Set<Statement> stmts, String... expected) {
|
||||
Set<String> actual = new HashSet<>();
|
||||
for (Statement stmt : stmts) {
|
||||
actual.add(stmt.toString());
|
||||
}
|
||||
assertEquals(new HashSet<>(Arrays.asList(expected)), actual);
|
||||
}
|
||||
|
||||
private void assertMethodCalls(GraphModelStructure gms, String... expected) {
|
||||
assertEquals(Arrays.asList(expected), gms.methodCalls);
|
||||
}
|
||||
|
||||
public Statement newStatement() {
|
||||
Resource s = ResourceFactory.createResource("http://z#new");
|
||||
Property p = ResourceFactory.createProperty("http://z#to");
|
||||
Resource o = ResourceFactory.createResource("http://z#you");
|
||||
return ResourceFactory.createStatement(s, p, o);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// Helper classes
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
private static class GraphModelStructure {
|
||||
final String uri;
|
||||
final Graph graph;
|
||||
final List<String> methodCalls;
|
||||
final RecordingInvocationHandler handler;
|
||||
final Graph proxy;
|
||||
final Model model;
|
||||
|
||||
public GraphModelStructure(String uri, String contents) {
|
||||
this.uri = uri;
|
||||
graph = new CollectionGraph();
|
||||
methodCalls = new ArrayList<>();
|
||||
handler = new RecordingInvocationHandler(graph, methodCalls);
|
||||
proxy = wrapGraph();
|
||||
model = ModelFactory.createModelForGraph(proxy);
|
||||
model.read(new StringReader(contents), null, "TURTLE");
|
||||
}
|
||||
|
||||
private Graph wrapGraph() {
|
||||
ClassLoader classLoader = Model.class.getClassLoader();
|
||||
Class<?>[] interfaces = new Class<?>[] { Graph.class };
|
||||
return (Graph) Proxy.newProxyInstance(classLoader, interfaces,
|
||||
handler);
|
||||
}
|
||||
}
|
||||
|
||||
private static class RecordingInvocationHandler implements
|
||||
InvocationHandler {
|
||||
private final Object inner;
|
||||
private final List<String> methodCalls;
|
||||
|
||||
public RecordingInvocationHandler(Object inner, List<String> methodCalls) {
|
||||
this.inner = inner;
|
||||
this.methodCalls = methodCalls;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Object invoke(Object proxy, Method method, Object[] args)
|
||||
throws Throwable {
|
||||
methodCalls.add(method.getName());
|
||||
return method.invoke(inner, args);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,259 @@
|
|||
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
|
||||
|
||||
package edu.cornell.mannlib.vitro.webapp.modelaccess.adapters;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import stubs.com.hp.hpl.jena.rdf.model.ModelMaker.ModelMakerStub;
|
||||
|
||||
import com.hp.hpl.jena.rdf.model.Model;
|
||||
import com.hp.hpl.jena.rdf.model.ModelFactory;
|
||||
import com.hp.hpl.jena.rdf.model.ModelMaker;
|
||||
import com.hp.hpl.jena.shared.AlreadyExistsException;
|
||||
import com.hp.hpl.jena.shared.CannotCreateException;
|
||||
import com.hp.hpl.jena.shared.DoesNotExistException;
|
||||
|
||||
import edu.cornell.mannlib.vitro.testing.AbstractTestClass;
|
||||
import edu.cornell.mannlib.vitro.webapp.modelaccess.adapters.UnionModelsModelMaker.UnionSpec;
|
||||
|
||||
/**
|
||||
* Test the functionality of the UnionModelsModelMaker.
|
||||
*/
|
||||
public class UnionModelsModelMakerTest extends AbstractTestClass {
|
||||
private static final String URI_ONE = "http://model.one";
|
||||
private static final String URI_TWO = "http://model.two";
|
||||
private static final String URI_THREE = "http://model.three";
|
||||
private static final String URI_UNION = "http://model.union";
|
||||
private static final String URI_NONE = "http://model.does.not.exist";
|
||||
|
||||
private static final Model MODEL_ONE = createModel();
|
||||
private static final Model MODEL_TWO = createModel();
|
||||
private static final Model MODEL_THREE = createModel();
|
||||
private static final Model MODEL_DEFAULT = createModel();
|
||||
private static final Model MODEL_FRESH = createModel();
|
||||
|
||||
private static Model createModel() {
|
||||
return ModelFactory.createDefaultModel();
|
||||
}
|
||||
|
||||
private ModelMaker inner;
|
||||
private ModelMaker mm;
|
||||
|
||||
@Before
|
||||
public void setup() {
|
||||
/*
|
||||
* Use a rigorous inner model maker, but it doesn't make much difference.
|
||||
*/
|
||||
inner = ModelMakerStub.rigorous(MODEL_DEFAULT, MODEL_FRESH)
|
||||
.put(URI_ONE, MODEL_ONE).put(URI_TWO, MODEL_TWO)
|
||||
.put(URI_THREE, MODEL_THREE);
|
||||
|
||||
mm = new UnionModelsModelMaker(inner, UnionSpec.base(URI_ONE)
|
||||
.plus(URI_TWO).yields(URI_UNION));
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
@Test(expected = NullPointerException.class)
|
||||
public void nullInnerModel() {
|
||||
new UnionModelsModelMaker(null, UnionSpec.base(URI_ONE).plus(URI_TWO)
|
||||
.yields(URI_UNION));
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void duplicateUnionUri() {
|
||||
new UnionModelsModelMaker(inner, UnionSpec.base(URI_ONE).plus(URI_TWO)
|
||||
.yields(URI_UNION), UnionSpec.base(URI_ONE).plus(URI_THREE)
|
||||
.yields(URI_UNION));
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void nestedUnions() {
|
||||
new UnionModelsModelMaker(inner, UnionSpec.base(URI_ONE).plus(URI_TWO)
|
||||
.yields(URI_UNION), UnionSpec.base(URI_UNION).plus(URI_THREE)
|
||||
.yields("http://nestedUnion"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hasModelActual() {
|
||||
assertTrue(mm.hasModel(URI_ONE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hasModelNone() {
|
||||
assertFalse(mm.hasModel(URI_NONE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hasModelUnion() {
|
||||
assertTrue(mm.hasModel(URI_UNION));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void listModels() {
|
||||
assertExpectedModelsList(URI_ONE, URI_TWO, URI_THREE, URI_UNION);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createModelActual() {
|
||||
assertEquals(MODEL_ONE, mm.createModel(URI_ONE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createModelNone() {
|
||||
assertEquals(MODEL_FRESH, mm.createModel(URI_NONE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createModelUnion() {
|
||||
assertTrue(isUnionModel(mm.createModel(URI_UNION)));
|
||||
}
|
||||
|
||||
@Test(expected = AlreadyExistsException.class)
|
||||
public void createModelActualStrict() {
|
||||
mm.createModel(URI_ONE, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createModelNoneStrict() {
|
||||
assertEquals(MODEL_FRESH, mm.createModel(URI_NONE, true));
|
||||
}
|
||||
|
||||
@Test(expected = AlreadyExistsException.class)
|
||||
public void createModelUnionStrict() {
|
||||
mm.createModel(URI_UNION, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void openModelActual() {
|
||||
assertEquals(MODEL_ONE, mm.openModel(URI_ONE));
|
||||
}
|
||||
|
||||
@Test(expected = DoesNotExistException.class)
|
||||
public void openModelNone() {
|
||||
mm.openModel(URI_NONE);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void openModelUnion() {
|
||||
assertTrue(isUnionModel(mm.openModel(URI_UNION)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void openModelActualStrict() {
|
||||
assertEquals(MODEL_ONE, mm.openModel(URI_ONE, true));
|
||||
}
|
||||
|
||||
@Test(expected = DoesNotExistException.class)
|
||||
public void openModelNoneStrict() {
|
||||
mm.openModel(URI_NONE, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void openModelUnionStrict() {
|
||||
assertTrue(isUnionModel(mm.openModel(URI_UNION, true)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void openModelIfPresentActual() {
|
||||
assertEquals(MODEL_ONE, mm.openModelIfPresent(URI_ONE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void openModelIfPresentNone() {
|
||||
assertNull(mm.openModelIfPresent(URI_NONE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void openModelIfPresentUnion() {
|
||||
assertTrue(isUnionModel(mm.openModelIfPresent(URI_UNION)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void removeModelActual() {
|
||||
mm.removeModel(URI_ONE);
|
||||
assertExpectedModelsList(URI_TWO, URI_THREE, URI_UNION);
|
||||
}
|
||||
|
||||
@Test(expected = DoesNotExistException.class)
|
||||
public void removeModelNone() {
|
||||
mm.removeModel(URI_NONE);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void removeModelUnion() {
|
||||
mm.removeModel(URI_UNION);
|
||||
assertExpectedModelsList(URI_ONE, URI_TWO, URI_THREE);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getModelActual() {
|
||||
assertEquals(MODEL_ONE, mm.getModel(URI_ONE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getModelNone() {
|
||||
assertEquals(null, mm.getModel(URI_NONE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getModelUnion() {
|
||||
assertTrue(isUnionModel(mm.getModel(URI_UNION)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getModelLoadIfAbsentActual() {
|
||||
assertEquals(MODEL_ONE, mm.getModel(URI_ONE, null));
|
||||
}
|
||||
|
||||
@Test(expected = CannotCreateException.class)
|
||||
public void getModelLoadIfAbsentNone() {
|
||||
mm.getModel(URI_NONE, null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getModelLoadIfAbsentUnion() {
|
||||
assertTrue(isUnionModel(mm.getModel(URI_UNION, null)));
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// Helper methods
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* No easy way to assert that this is actually the union model, but we can
|
||||
* assert that it is not null, and not any model we know of.
|
||||
*/
|
||||
private boolean isUnionModel(Model m) {
|
||||
Model[] knownModels = { MODEL_ONE, MODEL_TWO, MODEL_THREE,
|
||||
MODEL_DEFAULT, MODEL_FRESH };
|
||||
if (m == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (Model knownModel : knownModels) {
|
||||
if (m == knownModel) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private void assertExpectedModelsList(String... uris) {
|
||||
Set<String> expected = new HashSet<>(Arrays.asList(uris));
|
||||
assertEquals(expected, mm.listModels().toSet());
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue