ValueFactoryTest.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.stanbol.entityhub.test.model;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertTrue;

import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;

import org.apache.stanbol.entityhub.servicesapi.model.Reference;
import org.apache.stanbol.entityhub.servicesapi.model.Representation;
import org.apache.stanbol.entityhub.servicesapi.model.Text;
import org.apache.stanbol.entityhub.servicesapi.model.UnsupportedTypeException;
import org.apache.stanbol.entityhub.servicesapi.model.ValueFactory;
import org.apache.stanbol.entityhub.servicesapi.yard.Yard;
import org.junit.Test;

/**
 * General tests for instantiation of model instances by using the different value factory methods. This also
 * tests the construction of implementation of {@link Reference}, {@link Text} and {@link Representation}. For
 * the immutable {@link Text} and {@link Reference} this tests are sufficient. For Representations there is an
 * own Test class
 * 
 * @author Rupert Westenthaler
 * 
 */
public abstract class ValueFactoryTest {
    /**
     * Subclasses must implement this method and provide a {@link ValueFactory} instance that is used to test
     * the actual model implementation
     * 
     * @return the {@link ValueFactory} for the Entityhub model implementation to be tested
     */
    protected abstract ValueFactory getValueFactory();

    /**
     * Returns an instance of a unsupported Type to be parsed to {@link ValueFactory#createReference(Object)}.
     * Used to check if this Method correctly throws an {@link UnsupportedTypeException}
     * 
     * @return an instance of an unsupported type or <code>null</code> if all types are supported
     */
    protected abstract Object getUnsupportedReferenceType();

    /**
     * Returns an instance of a unsupported Type to be parsed to {@link ValueFactory#createText(Object)}. Used
     * to check if this Method correctly throws an {@link UnsupportedTypeException}
     * 
     * @return an instance of an unsupported type or <code>null</code> if all types are supported
     */
    protected abstract Object getUnsupportedTextType();

    @Test(expected = IllegalArgumentException.class)
    public void testNullReference() {
        testRef(null);
    }

    @Test(expected = UnsupportedTypeException.class)
    public void testUnsupportedReferenceType() {
        Object unsupported = getUnsupportedReferenceType();
        if (unsupported != null) {
            testRef(unsupported);
        } else {
            // no unsupported types ... this test is not necessary
            // -> create a dummy exception
            // TODO: is there a way to deactivate a test if not valid
            throw new UnsupportedTypeException(Object.class,
                    "dummy exception to successfully complete this unnecessary test");
        }
    }

    @Test(expected = IllegalArgumentException.class)
    public void testEmptyStringReference() {
        testRef("");
    }

    @Test
    public void testStringReference() {
        Object refObject = "urn:test.1";
        Reference ref = testRef(refObject);
        assertEquals(ref.getReference(), refObject);
    }

    @Test
    public void testIRIerence() throws URISyntaxException {
        URI refObject = new URI("http://www.test.org/uriTest");
        Reference ref = testRef(refObject);
        assertEquals(ref.getReference(), refObject.toString());
    }

    @Test
    public void testURLReference() throws MalformedURLException {
        URL refObject = new URL("http://www.test.org/urlTest");
        Reference ref = testRef(refObject);
        assertEquals(ref.getReference(), refObject.toString());
    }

    @Test(expected = IllegalArgumentException.class)
    public void testNullText() {
        testText(null, "en");
    }

    @Test
    public void testNullLanguage() {
        testText("test", null);
    }

    @Test(expected = UnsupportedTypeException.class)
    public void testUnsupportedTextType() {
        Object unsupported = getUnsupportedTextType();
        if (unsupported != null) {
            getValueFactory().createText(unsupported);
        } else {
            // no unsupported types ... this test is not necessary
            // -> create a dummy exception
            // TODO: is there a way to deactivate a test if not valid
            throw new UnsupportedTypeException(Object.class,
                    "dummy exception to successfully complete this unnecessary test");
        }
    }

    @Test
    public void testNormalText() {
        testText("test", "en");
    }

    /**
     * Some Systems use an empty string for the default language, other use <code>null</code>. Text does
     * currently not define that <code>null</code> need to be used as default language. However it does define
     * that <code>null</code> is a valid value for the language!
     * <p>
     * Based on that Entityhub allows implementations to convert an empty language to <code>null</code> but
     * does NOT allow to to convert <code>null</code> to an empty string.
     * <p>
     * This test currently assures, that parsing an empty string as language results in an empty string OR
     * <code>null</code>. It also tests that parsing an empty string as language does not result in an
     * Exception.
     */
    @Test
    public void testEmptyLanguageText() {
        testText("test", "");
    }

    /**
     * One can not create a Representation with <code>null</code> as ID. NOTE: automatic generation of IDs is
     * supported by the {@link Yard#create()} but not by the {@link Representation} itself.
     */
    @Test(expected = IllegalArgumentException.class)
    public void testNullIdRepresentation() {
        testRepresentation(null);
    }

    /**
     * One can not create a Representation with an emtpy ID
     */
    @Test(expected = IllegalArgumentException.class)
    public void testEmptyIdRepresentation() {
        testRepresentation("");
    }

    @Test
    public void testMultipleInstanceForSameID() {
        Representation rep = testRepresentation("urn:testSameId");
        Representation rep1 = testRepresentation("urn:testSameId");
        // check that multiple calls with the same ID create different instances
        // -> this is very important to allow mapping of Representations (e.g.
        // when they are stored within a cache
        assertNotSame(rep, rep1);
        // if an ID is parsed, than the two instance should be equal
        assertTrue(rep.equals(rep1));
        assertTrue(rep.hashCode() == rep1.hashCode()); // check the hash code
    }

    private Representation testRepresentation(String id) {
        ValueFactory vf = getValueFactory();
        Representation rep = vf.createRepresentation(id);
        assertNotNull(rep);
        assertNotNull(rep.getId());
        if (id != null) {
            assertEquals(rep.getId(), id);
        }
        return rep;
    }

    /**
     * Internally used to create and text {@link Text}s for the different tests
     * 
     * @param textString
     *            the natural language text as string
     * @param language
     *            the language
     * @return the created {@link Text} instance that can be used to perform further tests.
     */
    private Text testText(String textString, String language) {
        ValueFactory vf = getValueFactory();
        Text text = vf.createText(textString, language);
        assertNotNull(text.getText());
        assertNotNull(text.getText());
        assertEquals(text.getText(), textString);
        if (language == null) {
            assertTrue(text.getLanguage() == null);
        } else if (language.isEmpty()) {
            // implementations are free to change an empty language string to null
            // NOTE that it is not allowed to change NULL to an empty String!
            assertTrue(text.getLanguage() == null || text.getLanguage().isEmpty());
        } else {
            assertNotNull(text.getLanguage());
            assertEquals(text.getLanguage(), language);
        }
        return text;
    }

    /**
     * Internally used to create and test {@link Reference}s for the different tests
     * 
     * @param refObject
     *            the object representing the reference
     * @return the created {@link Reference} that can be used to perform further tests.
     */
    private Reference testRef(Object refObject) {
        ValueFactory vf = getValueFactory();
        Reference ref = vf.createReference(refObject);
        // check not null
        assertNotNull(ref);
        // check reference is not null
        assertNotNull(ref.getReference());
        return ref;
    }

}