AbstractIdentifiableTypeTest.java

package cz.cvut.kbss.jopa.model.metamodel;

import cz.cvut.kbss.jopa.environment.OWLClassA;
import cz.cvut.kbss.jopa.environment.OWLClassB;
import cz.cvut.kbss.jopa.model.IRI;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;

import java.util.Collections;
import java.util.Set;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.*;

public class AbstractIdentifiableTypeTest {

    private static Class<OWLClassA> cls;
    private static IRI classIri;
    private static String className;

    @Rule
    public ExpectedException thrown = ExpectedException.none();

    private EntityTypeImpl<OWLClassA> et;

    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        cls = OWLClassA.class;
        classIri = IRI.create(OWLClassA.getClassIri());
        className = OWLClassA.class.getName();
    }

    @Before
    public void setUp() throws Exception {
        this.et = new EntityTypeImpl<>(className, cls, classIri);
    }

    @Test
    public void hasSingleIdAttributeReturnsAlwaysTrue() {
        assertTrue(et.hasSingleIdAttribute());
    }

    @Test
    public void getAttributesReturnsDeclaredAttributesPlusInheritedAttributes() {
        final AbstractIdentifiableType<? super OWLClassA> supertype = mock(AbstractIdentifiableType.class);
        et.setSupertype(supertype);
        et.getAttributes();
        verify(supertype).getAttributes();
    }

    @Test
    public void getAttributesReturnsDeclaredAttributesWhenThereIsNoSupertype() {
        final Attribute<OWLClassA, ?> att = mock(Attribute.class);
        et.addDeclaredAttribute("test", att);
        final Set<Attribute<? super OWLClassA, ?>> result = et.getAttributes();
        assertEquals(1, result.size());
        assertTrue(result.contains(att));
    }

    @Test
    public void getAttributeReturnsInheritedAttribute() {
        final AbstractIdentifiableType<? super OWLClassA> supertype = mock(AbstractIdentifiableType.class);
        et.setSupertype(supertype);
        final String attName = "test";
        final Attribute att = mock(Attribute.class);
        when(supertype.getAttribute(attName)).thenReturn(att);
        assertEquals(att, et.getAttribute(attName));
        verify(supertype).getAttribute(attName);
    }

    @Test
    public void getAttributeThrowsIllegalArgumentWhenAttributeIsNotFoundInDeclaredAndInheritedAttributes() {
        final String attName = "unknownAttribute";
        thrown.expect(IllegalArgumentException.class);
        thrown.expectMessage("Attribute " + attName + " is not present in type " + et.toString());
        et.getAttribute(attName);
    }

    @Test
    public void getCollectionThrowsIllegalArgumentWhenElementTypeDoesNotMatch() {
        final CollectionAttribute att = mock(CollectionAttribute.class);
        final String attName = "test";
        when(att.getBindableJavaType()).thenReturn(OWLClassA.class);
        et.addDeclaredAttribute(attName, att);
        thrown.expect(IllegalArgumentException.class);
        thrown.expectMessage("Collection attribute " + attName + " with element type " + OWLClassB.class +
                " is not present in type " + et.toString());
        et.getCollection(attName, OWLClassB.class);
    }

    @Test
    public void getListReturnsListAttribute() {
        final ListAttribute att = mock(ListAttribute.class);
        final String attName = "test";
        when(att.getBindableJavaType()).thenReturn(OWLClassA.class);
        et.addDeclaredAttribute(attName, att);
        final ListAttribute result = et.getList(attName, OWLClassA.class);
        assertEquals(att, result);
    }

    @Test
    public void getSetThrowsIllegalArgumentWhenAttributeIsNotSet() {
        final CollectionAttribute att = mock(CollectionAttribute.class);
        final String attName = "test";
        when(att.getBindableJavaType()).thenReturn(OWLClassA.class);
        et.addDeclaredAttribute(attName, att);
        thrown.expect(IllegalArgumentException.class);
        thrown.expectMessage("Set attribute " + attName + " with element type " + OWLClassA.class +
                " is not present in type " + et.toString());
        et.getSet(attName, OWLClassA.class);
    }

    @Test
    public void getPluralAttributesGetsAlsoInheritedPluralAttributes() {
        final CollectionAttribute att = mock(CollectionAttribute.class);
        when(att.isCollection()).thenReturn(true);
        final ListAttribute listAtt = mock(ListAttribute.class);
        when(listAtt.isCollection()).thenReturn(true);
        final AbstractIdentifiableType<? super OWLClassA> supertype = mock(AbstractIdentifiableType.class);
        et.setSupertype(supertype);
        et.addDeclaredAttribute("test", listAtt);
        when(supertype.getPluralAttributes()).thenReturn(Collections.singleton(att));
        final Set<PluralAttribute<? super OWLClassA, ?, ?>> result = et.getPluralAttributes();
        assertTrue(result.contains(att));
        assertTrue(result.contains(listAtt));
    }

    @Test
    public void getSingularAttributesGetsAlsoInheritedSingularAttributes() {
        final SingularAttribute attOne = mock(SingularAttribute.class);
        when(attOne.isCollection()).thenReturn(false);
        final SingularAttribute attTwo = mock(SingularAttribute.class);
        when(attTwo.isCollection()).thenReturn(false);
        final AbstractIdentifiableType<? super OWLClassA> supertype = mock(AbstractIdentifiableType.class);
        et.setSupertype(supertype);
        et.addDeclaredAttribute("test", attTwo);
        when(supertype.getSingularAttributes()).thenReturn(Collections.singleton(attOne));
        final Set<SingularAttribute<? super OWLClassA, ?>> result = et.getSingularAttributes();
        assertTrue(result.contains(attOne));
        assertTrue(result.contains(attTwo));
    }

    @Test
    public void getSingularAttributeReturnsAttributeWithMatchingNameAndType() {
        final SingularAttribute attOne = mock(SingularAttribute.class);
        when(attOne.isCollection()).thenReturn(false);
        final String attName = "test";
        when(attOne.getJavaType()).thenReturn(OWLClassA.class);
        et.addDeclaredAttribute(attName, attOne);
        final SingularAttribute result = et.getSingularAttribute(attName, OWLClassA.class);
        assertEquals(attOne, result);
    }

    @Test
    public void getSingularAttributeThrowsIllegalARgumentWhenAttributeIsNotSingular() {
        final ListAttribute att = mock(ListAttribute.class);
        final String attName = "test";
        when(att.getBindableJavaType()).thenReturn(OWLClassA.class);
        when(att.isCollection()).thenReturn(true);
        et.addDeclaredAttribute(attName, att);
        thrown.expect(IllegalArgumentException.class);
        thrown.expectMessage(
                "Singular attribute " + attName + " of type " + OWLClassB.class + " is not present in type " +
                        et.toString());
        et.getSingularAttribute(attName, OWLClassB.class);
    }

    @Test
    public void getDeclaredAttributeReturnsAttributeDeclaredInType() {
        final SingularAttribute attOne = mock(SingularAttribute.class);
        when(attOne.isCollection()).thenReturn(false);
        final String attName = "test";
        when(attOne.getJavaType()).thenReturn(OWLClassA.class);
        et.addDeclaredAttribute(attName, attOne);
        final Attribute result = et.getDeclaredAttribute(attName);
        assertEquals(attOne, result);
    }

    @Test
    public void getDeclaredCollectionReturnsDeclaredCollectionAttribute() {
        final CollectionAttribute att = mock(CollectionAttribute.class);
        final String attName = "test";
        when(att.getBindableJavaType()).thenReturn(OWLClassA.class);
        et.addDeclaredAttribute(attName, att);
        final CollectionAttribute result = et.getDeclaredCollection(attName);
        assertEquals(att, result);
    }

    @Test
    public void getDeclaredListThrowsIllegalArgumentWhenListElementTypeDoesNotMatch() {
        final ListAttribute att = mock(ListAttribute.class);
        final String attName = "test";
        when(att.getBindableJavaType()).thenReturn(OWLClassA.class);
        when(att.isCollection()).thenReturn(true);
        et.addDeclaredAttribute(attName, att);
        thrown.expect(IllegalArgumentException.class);
        thrown.expectMessage(
                "List attribute " + attName + " with element type " + OWLClassB.class + " is not declared in type " +
                        et.toString());
        et.getDeclaredList(attName, OWLClassB.class);
    }

    @Test
    public void getDeclaredSetThrowsIllegalArgumentWhenAttributeIsNotSet() {
        final ListAttribute att = mock(ListAttribute.class);
        final String attName = "test";
        when(att.getBindableJavaType()).thenReturn(OWLClassA.class);
        when(att.isCollection()).thenReturn(true);
        et.addDeclaredAttribute(attName, att);
        thrown.expect(IllegalArgumentException.class);
        thrown.expectMessage(
                "Set attribute " + attName + " with element type " + OWLClassB.class + " is not declared in type " +
                        et.toString());
        et.getDeclaredSet(attName, OWLClassB.class);
    }

    @Test
    public void getDeclaredSingularAttributeReturnsDeclaredSingularAttribute() {
        final SingularAttribute att = mock(SingularAttribute.class);
        final String attName = "test";
        when(att.isCollection()).thenReturn(false);
        when(att.getJavaType()).thenReturn(OWLClassA.class);
        et.addDeclaredAttribute(attName, att);
        final SingularAttribute result = et.getDeclaredSingularAttribute(attName);
        assertEquals(att, result);
    }

    @Test
    public void getDeclaredSingularAttributeThrowsIllegalArgumentForInvalidType() {
        final SingularAttribute att = mock(SingularAttribute.class);
        final String attName = "test";
        when(att.isCollection()).thenReturn(false);
        when(att.getJavaType()).thenReturn(OWLClassA.class);
        et.addDeclaredAttribute(attName, att);
        thrown.expect(IllegalArgumentException.class);
        thrown.expectMessage(
                "Singular attribute " + attName + " of type " + OWLClassB.class + " is not declared in type " +
                        et.toString());
        et.getDeclaredSingularAttribute(attName, OWLClassB.class);
    }
}