source: TraumaOntologies/src/test/java/tudelft/healthpsychology/traumaontologies/answerstate/OntoPropAnswerStateTest.java

package tudelft.healthpsychology.traumaontologies.answerstate;

import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

import org.junit.Test;

import tudelft.healthpsychology.traumaontologies.questiontypes.TypedQuestion;
import tudelft.utilities.tree.Tree;

public class OntoPropAnswerStateTest {
        private final Tree<String, Collection<Property>, OntologyNode> tree = mock(
                        Tree.class);

        @Test
        public void testOptionNonfinalOntState() {
                // if ontology not yet final, we should get ontology question
                OntologyAnswerState ontoState = mock(OntologyAnswerState.class);
                TypedQuestion options = mock(TypedQuestion.class);
                when(ontoState.getOptions(tree)).thenReturn(options);
                when(options.substitute(any())).thenReturn(options);

                OntoPropAnswerState state = new OntoPropAnswerState(ontoState, null);

                assertEquals(options, state.getOptions(tree));
        }

        @Test(expected = NullPointerException.class)
        public void testOptionFinalOntStateyNullPropState() {
                // if ontology final and propstate=null, we should get NPE
                OntologyAnswerState ontoState = mock(OntologyAnswerState.class);
                when(ontoState.getOptions(tree)).thenReturn(null);
                OntoPropAnswerState state = new OntoPropAnswerState(ontoState, null);

                state.getOptions(tree);
        }

        @Test
        public void testOptionsFinalOntStateNonfinalPropState() {
                // if ontology final and propstate not, we should get propstate next
                OntologyAnswerState ontoState = mock(OntologyAnswerState.class);
                when(ontoState.getOptions(tree)).thenReturn(null);
                PropertiesAnswerState propState = mock(PropertiesAnswerState.class);
                TypedQuestion options = mock(TypedQuestion.class);
                when(options.substitute(any())).thenReturn(options);

                when(propState.getOptions(tree)).thenReturn(options);

                OntoPropAnswerState state = new OntoPropAnswerState(ontoState,
                                propState);

                assertEquals(options, state.getOptions(tree));
        }

        @Test
        public void testOptionsFinalOntStateFinalPropState() {
                // if ontology final and propstate not, we should get propstate next
                OntologyAnswerState ontoState = mock(OntologyAnswerState.class);
                when(ontoState.getOptions(tree)).thenReturn(null);
                PropertiesAnswerState propState = mock(PropertiesAnswerState.class);
                when(propState.getOptions(tree)).thenReturn(null);

                OntoPropAnswerState state = new OntoPropAnswerState(ontoState,
                                propState);
                assertEquals(null, state.getOptions(tree));
        }

        @Test
        public void testWithCollega() {
                OntologyAnswerState ontoState = mock(OntologyAnswerState.class);
                OntologyNode node = mock(OntologyNode.class);
                when(node.toString()).thenReturn("persoon");
                when(ontoState.getNode()).thenReturn("persoon");

                PropertiesAnswerState propState = mock(PropertiesAnswerState.class);

                TypedQuestion options = mock(TypedQuestion.class);
                when(options.fits(any())).thenReturn(true);
                when(ontoState.getOptions(tree)).thenReturn(options);

                OntologyAnswerState newOntoState = mock(OntologyAnswerState.class);
                when(ontoState.with(any(String.class), any())).thenReturn(newOntoState);

                when(newOntoState.getOptions(tree)).thenReturn(null);
                OntologyNode collega = mock(OntologyNode.class);
                when(collega.toString()).thenReturn("collega");
                when(newOntoState.getNode()).thenReturn("collega");

                OntoPropAnswerState state = new OntoPropAnswerState(ontoState,
                                propState);
                OntoPropAnswerState newstate = state.with("Collega", tree);

                assertEquals("collega",
                                newstate.getOntologyAnswer().getNode().toString());
        }

        /**
         * Test that after the ontology is completed, the state of the propState is
         * set correctly.
         */
        @Test
        public void testOntoStateCompletion() {
                OntologyAnswerState ontoState = mock(OntologyAnswerState.class);
                OntologyNode node = mock(OntologyNode.class);
                when(node.toString()).thenReturn("persoon");
                when(ontoState.getNode()).thenReturn("persoon");
                TypedQuestion options = mock(TypedQuestion.class);
                when(options.fits(any())).thenReturn(true);
                when(ontoState.getOptions(tree)).thenReturn(options);

                PropertiesAnswerState propState = null;

                // new ontostate is final
                OntologyAnswerState newOntoState = mock(OntologyAnswerState.class);
                when(ontoState.with(any(String.class), any())).thenReturn(newOntoState);
                when(newOntoState.getOptions(tree)).thenReturn(null);
                OntologyNode collega = mock(OntologyNode.class);
                when(collega.toString()).thenReturn("collega");
                when(newOntoState.getNode()).thenReturn("collega");
                Collection<Property> collegavalues = new HashSet<>();
                Property collegaprop = mock(Property.class);
                when(collegaprop.toString()).thenReturn("collegaprop");
                collegavalues.add(collegaprop);
                when(collega.getAttribute()).thenReturn(collegavalues);

                OntoPropAnswerState state = new OntoPropAnswerState(ontoState,
                                propState);
                OntoPropAnswerState newstate = state.with("Collega", tree);

                assertEquals("collega",
                                newstate.getOntologyAnswer().getNode().toString());
                assertEquals("collega",
                                newstate.getPropertyAnswer().getNode().toString());
        }

        /**
         * Test that when the ontologystate is completed, the propState is merged
         * correctly with existing answers.
         */
        @Test
        public void testOntoStateCompletionWithExistingPropAnswers() {
                OntologyAnswerState ontoState = mock(OntologyAnswerState.class);
                OntologyNode node = mock(OntologyNode.class);
                when(node.toString()).thenReturn("persoon");
                when(ontoState.getNode()).thenReturn("persoon");
                TypedQuestion options = mock(TypedQuestion.class);
                when(options.fits(any())).thenReturn(true);
                when(ontoState.getOptions(tree)).thenReturn(options);

                PropertiesAnswerState propState = mock(PropertiesAnswerState.class);
                TypedQuestion propOptions = mock(TypedQuestion.class);
                when(propState.getOptions(tree)).thenReturn(propOptions);
                OntologyNode propnode = mock(OntologyNode.class);
                Collection<Property> alreadyvalues = new HashSet<>();
                Property prop1 = mock(Property.class);
                when(prop1.toString()).thenReturn("property1");
                alreadyvalues.add(prop1);
                when(propnode.getAttribute()).thenReturn(alreadyvalues);
                when(propState.getNode()).thenReturn("propnode");
                Map<Property, String> alreadymap = new HashMap<>();
                alreadymap.put(prop1, "user's answer 1");
                when(propState.getAnswers()).thenReturn(alreadymap);

                // new ontostate is final
                OntologyAnswerState newOntoState = mock(OntologyAnswerState.class);
                when(ontoState.with(any(String.class), any())).thenReturn(newOntoState);
                when(newOntoState.getOptions(tree)).thenReturn(null);

                // newOntoState, final and reached using ontoState.with()
                OntologyNode collega = mock(OntologyNode.class);
                when(collega.toString()).thenReturn("collega");
                Collection<Property> collegavalues = new HashSet<>();
                Property collegaprop = mock(Property.class);
                when(collegaprop.toString()).thenReturn("collegaprop");
                collegavalues.add(collegaprop);
                when(collega.getAttribute()).thenReturn(collegavalues);
                when(newOntoState.getNode()).thenReturn("collega");

                // finally simulate the step
                OntoPropAnswerState state = new OntoPropAnswerState(ontoState,
                                propState);
                OntoPropAnswerState newstate = state.with("Collega", tree);

                assertEquals("collega",
                                newstate.getOntologyAnswer().getNode().toString());
                // was existing answer merged?
                assertEquals(1, newstate.getPropertyAnswer().getAnswers().size());
                // following too difficult to test?
                // assertEquals(1, newstate.getOptions(tree));
        }

}