EDBIT.java

/**
 * Licensed to the Austrian Association for Software Tool Integration (AASTI)
 * under one or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information regarding copyright
 * ownership. The AASTI 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.openengsb.itests.exam;

import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.junit.Assert.assertThat;
import static org.ops4j.pax.exam.CoreOptions.mavenBundle;
import static org.ops4j.pax.exam.OptionUtils.combine;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.openengsb.core.api.context.ContextHolder;
import org.openengsb.core.api.model.ModelWrapper;
import org.openengsb.core.api.model.OpenEngSBFileModel;
import org.openengsb.core.api.model.OpenEngSBModelEntry;
import org.openengsb.core.api.model.QueryRequest;
import org.openengsb.core.edb.api.EDBCommit;
import org.openengsb.core.edb.api.EDBConstants;
import org.openengsb.core.edb.api.EDBException;
import org.openengsb.core.edb.api.EDBObject;
import org.openengsb.core.edb.api.EngineeringDatabaseService;
import org.openengsb.core.ekb.api.EKBCommit;
import org.openengsb.core.ekb.api.EKBConcurrentException;
import org.openengsb.core.ekb.api.EKBException;
import org.openengsb.core.ekb.api.PersistInterface;
import org.openengsb.core.ekb.api.QueryInterface;
import org.openengsb.itests.exam.models.PrimitivePropertyModelDecorator;
import org.openengsb.itests.exam.models.SubModelDecorator;
import org.openengsb.itests.exam.models.TestModelDecorator;
import org.openengsb.itests.util.AbstractModelUsingExamTestHelper;
import org.ops4j.pax.exam.Configuration;
import org.ops4j.pax.exam.Option;
import org.ops4j.pax.exam.junit.PaxExam;
import org.ops4j.pax.exam.karaf.options.KarafDistributionConfigurationFilePutOption;

@RunWith(PaxExam.class)
public class EDBIT extends AbstractModelUsingExamTestHelper {
    private static final String CONTEXT = "testcontext";
    private EngineeringDatabaseService edbService;
    private QueryInterface query;
    private PersistInterface persist;

    @Configuration
    public static Option[] myConfiguration() throws Exception {
        Option[] options =
            new Option[]{
                new KarafDistributionConfigurationFilePutOption("etc/org.openengsb.ekb.cfg",
                    "modelUpdatePropagationMode", "DEACTIVATED"),
                new KarafDistributionConfigurationFilePutOption("etc/org.openengsb.ekb.cfg",
                    "persistInterfaceLockingMode", "DEACTIVATED"),
                mavenBundle().groupId("org.ops4j.pax.tinybundles").artifactId("tinybundles").versionAsInProject() };
        return combine(baseConfiguration(), options);
    }

    @Before
    public void setup() throws Exception {
        edbService = getOsgiService(EngineeringDatabaseService.class);
        query = getOsgiService(QueryInterface.class);
        persist = getOsgiService(PersistInterface.class);
        registerModelProvider();
        ContextHolder.get().setCurrentContextId(CONTEXT);
    }

    @Test
    public void testIfServiceIsFound_shouldWork() throws Exception {
        assertThat(edbService, notNullValue());
    }

    @Test
    public void testInsert_shouldWork() throws Exception {
        EDBCommit commit = edbService.createEDBCommit(null, null, null);
        EDBObject testObject = new EDBObject("testobject");
        testObject.putEDBObjectEntry("testkey", "testvalue");
        commit.insert(testObject);
        Long testtime = edbService.commit(commit);
        assertThat(testtime.longValue(), not(0L));
    }

    @Test(expected = EDBException.class)
    public void testDoubleCommit_shouldThrowException() throws Exception {
        EDBCommit commit = edbService.createEDBCommit(null, null, null);
        edbService.commit(commit);
        edbService.commit(commit);
    }

    @Test
    public void testRetrieveObject_shouldWork() throws Exception {
        EDBCommit commit = edbService.createEDBCommit(null, null, null);
        EDBObject testObject = new EDBObject("newtestobject");
        testObject.putEDBObjectEntry("newtestkey", "newtestvalue");
        commit.insert(testObject);

        edbService.commit(commit);

        EDBObject obj = edbService.getObject("newtestobject");
        assertThat(obj, notNullValue());
    }

    @Test
    public void testQueryForObject_shouldWork() throws Exception {
        EDBCommit commit = edbService.createEDBCommit(null, null, null);
        EDBObject testObject = new EDBObject("newtestobject1");
        testObject.putEDBObjectEntry("newtestkey1", "newtestvalue1");
        commit.insert(testObject);

        edbService.commit(commit);

        List<EDBObject> objects = edbService.query(QueryRequest.query("newtestkey1", "newtestvalue1"));
        assertThat(objects, notNullValue());
        assertThat(objects.size(), not(0));
    }

    @Test
    public void testOrQueryForModelType_shouldWork() throws Exception {
        TestModelDecorator model1 = getTestModelDecorator();
        model1.setEdbId("orQueryTest/1");
        model1.setName("model1");
        TestModelDecorator model2 = getTestModelDecorator();
        model2.setEdbId("orQueryTest/2");
        model2.setName("model2");
        TestModelDecorator model3 = getTestModelDecorator();
        model3.setEdbId("orQueryTest/3");
        model3.setName("model3");
        model3.setField("test");
        TestModelDecorator model4 = getTestModelDecorator();
        model4.setEdbId("orQueryTest/4");
        model4.setName("model4");
        EKBCommit commit =
            getTestEKBCommit().addInserts(
                Arrays.asList(model1.getModel(), model2.getModel(), model3.getModel(), model4.getModel()));
        persist.commit(commit);

        QueryRequest request =
            QueryRequest.create().orJoined().addParameter("name", "model1").addParameter("name", "model2")
                .addParameter("field", "test");
        List<Object> result = (List<Object>) query.query(getTestModel(), request);
        assertThat(result, notNullValue());
        assertThat(result.size(), is(3));
    }

    @Test(expected = EDBException.class)
    public void testConflictDetection_shouldThrowException() throws Exception {
        EDBCommit commit = edbService.createEDBCommit(null, null, null);
        EDBObject testObject = new EDBObject("newtestobject2");
        testObject.putEDBObjectEntry("newtestkey2", "newtestvalue2");
        commit.insert(testObject);

        edbService.commit(commit);

        commit = edbService.createEDBCommit(null, null, null);

        EDBObject obj = edbService.getObject("newtestobject2");
        obj.putEDBObjectEntry(EDBConstants.MODEL_VERSION, Integer.valueOf(0));
        obj.putEDBObjectEntry("test", "test");

        commit.update(obj);
        edbService.commit(commit);
    }

    @Test
    public void testFileSaving_shouldWork() throws Exception {
        File f = new File("testfile.txt");
        FileWriter fw = new FileWriter(f);
        fw.write("this is a test");
        fw.flush();
        fw.close();

        OpenEngSBFileModel model = new OpenEngSBFileModel();
        model.setFile(f);
        model.setId("testId");

        EKBCommit commit = getTestEKBCommit().addInsert(model);
        persist.commit(commit);

        OpenEngSBFileModel result = query.getModel(OpenEngSBFileModel.class, getModelOid("testId"));

        File newFile = result.getFile();

        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(newFile)));
        String line = reader.readLine();
        reader.close();
        newFile.delete();

        assertThat(result.getFile().getName(), is("testfile.txt"));
        assertThat(line, is("this is a test"));
    }

    @Test(expected = EKBException.class)
    public void testDoubleModelCommit_shouldThrowException() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setEdbId("createevent/1");
        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());

        persist.commit(commit);
        persist.commit(commit);
    }

    @Test
    public void testEKBInsertCommit_shouldSaveModel() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setName("test");
        model.setEdbId("createevent/2");
        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);

        EDBObject obj = edbService.getObject(getModelOid("createevent/2"));
        String name = obj.getString("name");
        Integer version = obj.getObject(EDBConstants.MODEL_VERSION, Integer.class);

        assertThat(name, is("test"));
        assertThat(version, is(1));
    }

    @Test
    public void testEKBInsertCommitAndQueryData_shouldReturnModelObject() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setName("C:\\test");
        model.setEdbId("createevent/5");
        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);

        @SuppressWarnings("unchecked")
        List<Object> result = (List<Object>) query.queryByString(getTestModel(), "name:\"C:\\test\"");
        assertThat(result.isEmpty(), is(false));
        assertThat(result.get(0), instanceOf(getTestModel()));
    }

    @Test
    public void testEKBInsertCommitAndQueryDataWithBackslashes_shouldReturnModelObject() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setName("C:\\\\test");
        model.setEdbId("createevent/6");
        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);

        QueryRequest request = QueryRequest.query("name", "C:\\\\test").wildcardUnaware();
        @SuppressWarnings("unchecked")
        List<Object> result = (List<Object>) query.query(getTestModel(), request);
        assertThat(result.isEmpty(), is(false));
        assertThat(result.get(0), instanceOf(getTestModel()));
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testEKBInsertCommitAndQueryWithContextId_shouldReturnModelOnlyOnCorrectContext() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setName("testmodel");
        model.setEdbId("createevent/7");
        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);
        ContextHolder.get().setCurrentContextId("othercontext");
        TestModelDecorator model2 = getTestModelDecorator();
        model2.setName("testmodel");
        model2.setEdbId("createevent/8");
        commit = getTestEKBCommit().addInsert(model2.getModel());
        persist.commit(commit);

        QueryRequest request = QueryRequest.query("name", "testmodel");
        List<Object> result = (List<Object>) query.query(getTestModel(), request);
        assertThat(result.size(), is(2));
        request.setContextId(CONTEXT);
        result = (List<Object>) query.query(getTestModel(), request);
        assertThat(result.size(), is(1));
        assertThat(new TestModelDecorator(result.get(0)).getEdbId(), is("createevent/7"));
        request.setContextId("othercontext");
        result = (List<Object>) query.query(getTestModel(), request);
        assertThat(result.size(), is(1));
        assertThat(new TestModelDecorator(result.get(0)).getEdbId(), is("createevent/8"));
        request.setContextId("somenonesensecontext");
        result = (List<Object>) query.query(getTestModel(), request);
        assertThat(result.size(), is(0));
        ContextHolder.get().setCurrentContextId(CONTEXT);
    }

    @Test
    public void testEKBUpdateCommit_shouldWork() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setName("test1");
        model.setEdbId("batchevent/1");
        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);

        EDBObject obj = edbService.getObject(getModelOid("batchevent/1"));
        String name1 = obj.getString("name");
        Integer version1 = obj.getObject(EDBConstants.MODEL_VERSION, Integer.class);

        model.setName("test2");
        commit = getTestEKBCommit().addUpdate(model.getModel());
        TestModelDecorator model2 = getTestModelDecorator();
        model2.setName("test3");
        model2.setEdbId("batchevent/2");
        commit.addInsert(model2.getModel());
        persist.commit(commit);

        obj = edbService.getObject(getModelOid("batchevent/1"));
        String name2 = obj.getString("name");
        Integer version2 = obj.getObject(EDBConstants.MODEL_VERSION, Integer.class);
        obj = edbService.getObject(getModelOid("batchevent/2"));
        String name3 = obj.getString("name");
        Integer version3 = obj.getObject(EDBConstants.MODEL_VERSION, Integer.class);

        assertThat(name1, is("test1"));
        assertThat(version1, is(1));
        assertThat(name2, is("test2"));
        assertThat(version2, is(2));
        assertThat(name3, is("test3"));
        assertThat(version3, is(1));
    }

    @Test(expected = EKBException.class)
    public void testEKBDeleteCommitWithNonExistingOid_shouldThrowError() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setEdbId("deleteevent/1");
        EKBCommit commit = getTestEKBCommit().addDelete(model.getModel());
        persist.commit(commit);
    }

    @Test
    public void testEKBUpdateCommit_shouldUpdateModel() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setName("test1");
        model.setEdbId("updateevent/2");
        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);

        EDBObject obj = edbService.getObject(getModelOid("updateevent/2"));
        String name1 = obj.getString("name");
        Integer version1 = obj.getObject(EDBConstants.MODEL_VERSION, Integer.class);
        model.setName("test2");
        commit = getTestEKBCommit().addUpdate(model.getModel());
        persist.commit(commit);

        obj = edbService.getObject(getModelOid("updateevent/2"));
        String name2 = obj.getString("name");
        Integer version2 = obj.getObject(EDBConstants.MODEL_VERSION, Integer.class);

        assertThat(name1, is("test1"));
        assertThat(version1, is(1));
        assertThat(name2, is("test2"));
        assertThat(version2, is(2));
    }

    @Test
    public void testIfLoadingOfCommitsWork_shouldWork() throws Exception {
        EDBCommit commit = edbService.createEDBCommit(null, null, null);
        EDBObject testObject = new EDBObject("commitload/1");
        testObject.putEDBObjectEntry("testkey", "testvalue");
        commit.insert(testObject);
        Long testtime = edbService.commit(commit);
        EDBCommit result = edbService.getCommit(testtime);
        assertThat(result.getInserts().size(), is(1));
    }

    @Test
    public void testEKBConflictCommitEvent_shouldResolveInNoConflict() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setName("test");
        model.setEdbId("updateevent/3");
        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);

        EDBObject obj = edbService.getObject(getModelOid("updateevent/3"));
        Integer version1 = obj.getObject(EDBConstants.MODEL_VERSION, Integer.class);
        OpenEngSBModelEntry entry = new OpenEngSBModelEntry(EDBConstants.MODEL_VERSION, 0, Integer.class);
        ModelWrapper.wrap(model.getModel()).addOpenEngSBModelEntry(entry);
        commit = getTestEKBCommit().addUpdate(model.getModel());
        persist.commit(commit);

        // results in no conflict because the values are the same even if the version is different
        obj = edbService.getObject(getModelOid("updateevent/3"));
        Integer version2 = obj.getObject(EDBConstants.MODEL_VERSION, Integer.class);

        assertThat(version1, is(1));
        assertThat(version2, is(2));
    }

    @Test(expected = EKBException.class)
    public void testEKBConflictCommitEvent_shouldResolveInConflict() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setName("test1");
        model.setEdbId("updateevent/4");
        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);

        model.setName("test2");
        OpenEngSBModelEntry entry = new OpenEngSBModelEntry(EDBConstants.MODEL_VERSION, 0, Integer.class);
        ModelWrapper.wrap(model.getModel()).addOpenEngSBModelEntry(entry);
        commit = getTestEKBCommit().addUpdate(model.getModel());
        persist.commit(commit);
    }

    @Test
    public void testSupportOfSimpleSubModels_shouldWork() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setName("test");
        model.setEdbId("testSub/1");

        SubModelDecorator sub = getSubModelDecorator();
        sub.setName("sub");
        sub.setEdbId("testSub/2");
        model.setSubModel(sub.getModel());

        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);

        EDBObject mainObject = edbService.getObject(getModelOid("testSub/1"));
        EDBObject subObject = edbService.getObject(getModelOid("testSub/2"));

        assertThat(subObject, notNullValue());
        assertThat(mainObject.getString("subModel"), is(getModelOid("testSub/2")));
    }

    @Test
    public void testSupportOfListOfSubModels_shouldWork() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setName("test");
        model.setEdbId("testSub/3");

        SubModelDecorator sub1 = getSubModelDecorator();
        sub1.setName("sub1");
        sub1.setEdbId("testSub/4");
        SubModelDecorator sub2 = getSubModelDecorator();
        sub2.setName("sub2");
        sub2.setEdbId("testSub/5");

        List<Object> subs = new ArrayList<Object>();
        subs.add(sub1.getModel());
        subs.add(sub2.getModel());
        model.setSubs(subs);

        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);

        EDBObject mainObject = edbService.getObject(getModelOid("testSub/3"));
        EDBObject subObject1 = edbService.getObject(getModelOid("testSub/4"));
        EDBObject subObject2 = edbService.getObject(getModelOid("testSub/5"));

        assertThat(subObject1, notNullValue());
        assertThat(subObject2, notNullValue());
        assertThat(mainObject.getString("subs.0"), is(getModelOid("testSub/4")));
        assertThat(mainObject.getString("subs.1"), is(getModelOid("testSub/5")));
    }

    @Test
    public void testComplexModelComposition_persistsAndResolvesModelsCorrectly() throws Exception {
        // prepare
        TestModelDecorator root;
        TestModelDecorator child1;
        TestModelDecorator child2;
        TestModelDecorator child11;
        TestModelDecorator child12;
        TestModelDecorator rRoot;
        TestModelDecorator rChild1;
        TestModelDecorator rChild2;
        TestModelDecorator rChild11;
        TestModelDecorator rChild12;
        SubModelDecorator leaf;
        SubModelDecorator rLeaf;

        root = getTestModelDecorator();
        child1 = getTestModelDecorator();
        child2 = getTestModelDecorator();
        child11 = getTestModelDecorator();
        child12 = getTestModelDecorator();
        leaf = getSubModelDecorator();

        List<Object> rootChildren = new ArrayList<>();
        rootChildren.add(child1.getModel());
        rootChildren.add(child2.getModel());

        List<Object> child1Children = new ArrayList<>();
        child1Children.add(child11.getModel());
        child1Children.add(child12.getModel());

        root.setEdbId("root");
        root.setName("root");
        child1.setEdbId("child1");
        child1.setName("child1");
        child2.setEdbId("child2");
        child2.setName("child2");
        child11.setEdbId("child11");
        child11.setName("child11");
        child12.setEdbId("child12");
        child12.setName("child12");
        leaf.setEdbId("leaf");
        leaf.setName("leaf");

        child11.setSubModel(leaf.getModel());
        child1.setChildren(child1Children);
        root.setChildren(rootChildren);

        // test
        EKBCommit commit = getTestEKBCommit().addInsert(root.getModel());
        persist.commit(commit);

        rRoot = new TestModelDecorator(query.getModel(getTestModel(), getModelOid("root")));

        // assert
        assertThat(rRoot.getEdbId(), is("root"));
        assertThat(rRoot.getChildren(), notNullValue());

        List<?> resultChildren = rRoot.getChildren();
        assertThat(resultChildren.size(), is(2));

        rChild1 = new TestModelDecorator(resultChildren.get(0));
        rChild2 = new TestModelDecorator(resultChildren.get(1));

        assertThat(rChild1.getEdbId(), is("child1"));
        assertThat(rChild1.getChildren(), notNullValue());

        assertThat(rChild2.getEdbId(), is("child2"));

        List<Object> rChild1Children = rChild1.getChildren();
        assertThat(rChild1Children.size(), is(2));

        rChild11 = new TestModelDecorator(rChild1Children.get(0));
        rChild12 = new TestModelDecorator(rChild1Children.get(1));

        assertThat(rChild11.getEdbId(), is("child11"));
        assertThat(rChild12.getEdbId(), is("child12"));

        rLeaf = new SubModelDecorator(rChild11.getSubModel());
        assertThat(rLeaf.getEdbId(), is("leaf"));
    }

    @Test
    public void testComplexModelComposition_cascadesDeleteCorrectly() throws Exception {
        // prepare
        TestModelDecorator root;
        TestModelDecorator child1;
        TestModelDecorator child2;
        TestModelDecorator child11;
        TestModelDecorator child12;
        SubModelDecorator leaf;

        root = getTestModelDecorator();
        child1 = getTestModelDecorator();
        child2 = getTestModelDecorator();
        child11 = getTestModelDecorator();
        child12 = getTestModelDecorator();
        leaf = getSubModelDecorator();

        List<Object> rootChildren = new ArrayList<>();
        rootChildren.add(child1.getModel());
        rootChildren.add(child2.getModel());

        List<Object> child1Children = new ArrayList<>();
        child1Children.add(child11.getModel());
        child1Children.add(child12.getModel());

        root.setEdbId("root/1");
        root.setName("root/1");
        child1.setEdbId("child1/1");
        child1.setName("child1/1");
        child2.setEdbId("child2/1");
        child2.setName("child2/1");
        child11.setEdbId("child11/1");
        child11.setName("child11/1");
        child12.setEdbId("child12/1");
        child12.setName("child12/1");
        leaf.setEdbId("leaf/1");
        leaf.setName("leaf/1");

        child11.setSubModel(leaf.getModel());
        child1.setChildren(child1Children);
        root.setChildren(rootChildren);

        EKBCommit commit = getTestEKBCommit().addInsert(root.getModel());
        persist.commit(commit);

        // test
        commit = getTestEKBCommit().addDelete(root.getModel());
        persist.commit(commit);

        // assert
        EDBObject rRoot = edbService.getObject(getModelOid("root/1"));
        EDBObject rChild1 = edbService.getObject(getModelOid("child1/1"));
        EDBObject rChild2 = edbService.getObject(getModelOid("child2/1"));
        EDBObject rChild11 = edbService.getObject(getModelOid("child11/1"));
        EDBObject rChild12 = edbService.getObject(getModelOid("child12/1"));
        EDBObject rLeaf = edbService.getObject(getModelOid("leaf/1"));

        assertThat(rRoot.isDeleted(), is(true));
        assertThat(rChild1.isDeleted(), is(true));
        assertThat(rChild2.isDeleted(), is(true));
        assertThat(rChild11.isDeleted(), is(true));
        assertThat(rChild12.isDeleted(), is(true));
        assertThat(rLeaf.isDeleted(), is(true));
    }

    @Test
    public void testModelTailIsLoaded_shouldLoadModelTail() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setEdbId("modeltailtest/1");
        model.setName("blub");

        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);

        ModelWrapper result = ModelWrapper.wrap(query.getModel(getTestModel(), getModelOid("modeltailtest/1")));
        Boolean versionPresent = result.retrieveInternalModelVersion() != null;
        assertThat(versionPresent, is(true));
    }

    @Test
    public void testIfModelMetaDataRetrievingWorks_shouldWork() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setName("blub");
        model.setEdbId("modelmetatest/1");

        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);
        ModelWrapper wrapper = ModelWrapper.wrap(query.getModel(getTestModel(), getModelOid("modelmetatest/1")));
        assertThat(wrapper.toOpenEngSBModelEntries(), notNullValue());
        assertThat(wrapper.retrieveInternalModelId(), notNullValue());
        assertThat(wrapper.retrieveInternalModelVersion(), notNullValue());
        assertThat(wrapper.retrieveInternalModelTimestamp(), notNullValue());
    }

    @Test
    public void testIfSubModelIsPersistedAlso_shouldPersistParentAndSubModel() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setEdbId("submodeltest/1");

        SubModelDecorator sub = getSubModelDecorator();
        sub.setName("test");
        sub.setEdbId("submodeltest/1/1");
        model.setSubModel(sub.getModel());

        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);
        model = loadTestModel("submodeltest/1");
        assertThat(model.getModel(), notNullValue());
        sub = new SubModelDecorator(model.getSubModel());
        assertThat(sub.getModel(), notNullValue());
        assertThat(sub.getName(), is("test"));
    }

    @Test
    public void testIfSubModelsArePersistedAlso_shouldPersistParentAndSubModels() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setEdbId("submodeltest/2");
        List<Object> subs = new ArrayList<Object>();
        SubModelDecorator sub = getSubModelDecorator();
        sub.setName("test1");
        sub.setEdbId("submodeltest/2/1");
        subs.add(sub.getModel());
        sub = getSubModelDecorator();
        sub.setName("test2");
        sub.setEdbId("submodeltest/2/2");
        subs.add(sub.getModel());
        model.setSubs(subs);

        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);
        model = loadTestModel("submodeltest/2");
        assertThat(model.getModel(), notNullValue());
        assertThat(model.getSubs(), notNullValue());
        assertThat(model.getSubs().get(0), notNullValue());
        assertThat(model.getSubs().get(1), notNullValue());
        sub = new SubModelDecorator(model.getSubs().get(0));
        assertThat(sub.getName(), is("test1"));
        sub = new SubModelDecorator(model.getSubs().get(1));
        assertThat(sub.getName(), is("test2"));
        sub = loadSubModel("submodeltest/2/1");
        assertThat(sub.getName(), is("test1"));
        sub = loadSubModel("submodeltest/2/2");
        assertThat(sub.getName(), is("test2"));
    }

    @Test
    public void testIfSubModelIsUpdatedAlso_shouldUpdateParentAndSubModel() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setEdbId("submodeltest/3");

        SubModelDecorator sub = getSubModelDecorator();
        sub.setName("test");
        sub.setEdbId("submodeltest/3/1");
        model.setSubModel(sub.getModel());

        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);

        sub.setName("updated");
        commit = getTestEKBCommit().addUpdate(model.getModel());
        persist.commit(commit);

        sub = loadSubModel("submodeltest/3/1");
        assertThat(sub.getModel(), notNullValue());
        assertThat(sub.getName(), is("updated"));
    }

    @Test
    public void testIfSubModelsAreUpdatedAlso_shouldUpdateParentAndSubModels() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setEdbId("submodeltest/4");
        List<Object> subs = new ArrayList<Object>();
        SubModelDecorator sub = getSubModelDecorator();
        sub.setName("test1");
        sub.setEdbId("submodeltest/4/1");
        subs.add(sub.getModel());
        sub = getSubModelDecorator();
        sub.setName("test2");
        sub.setEdbId("submodeltest/4/2");
        subs.add(sub.getModel());
        model.setSubs(subs);

        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);

        subs.clear();
        sub = getSubModelDecorator();
        sub.setName("updatedtest1");
        sub.setEdbId("submodeltest/4/1");
        subs.add(sub.getModel());
        sub = getSubModelDecorator();
        sub.setName("updatedtest2");
        sub.setEdbId("submodeltest/4/2");
        subs.add(sub.getModel());
        sub = getSubModelDecorator();
        sub.setName("insertedtest3");
        sub.setEdbId("submodeltest/4/3");
        subs.add(sub.getModel());
        model.setSubs(subs);
        commit = getTestEKBCommit().addUpdate(model.getModel());
        persist.commit(commit);

        model = new TestModelDecorator(query.getModel(getTestModel(), getModelOid("submodeltest/4")));
        assertThat(model.getModel(), notNullValue());
        assertThat(model.getSubs(), notNullValue());
        assertThat(model.getSubs().get(0), notNullValue());
        assertThat(model.getSubs().get(1), notNullValue());
        assertThat(model.getSubs().get(2), notNullValue());
        sub = new SubModelDecorator(model.getSubs().get(0));
        assertThat(sub.getName(), is("updatedtest1"));
        sub = new SubModelDecorator(model.getSubs().get(1));
        assertThat(sub.getName(), is("updatedtest2"));
        sub = new SubModelDecorator(model.getSubs().get(2));
        assertThat(sub.getName(), is("insertedtest3"));
        sub = loadSubModel("submodeltest/4/1");
        assertThat(sub.getName(), is("updatedtest1"));
        sub = loadSubModel("submodeltest/4/2");
        assertThat(sub.getName(), is("updatedtest2"));
        sub = loadSubModel("submodeltest/4/3");
        assertThat(sub.getName(), is("insertedtest3"));
    }

    @Test
    public void testIfSubModelIsDeletedAlso_shouldDeleteParentAndSubModel() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setEdbId("submodeltest/5");

        SubModelDecorator sub = getSubModelDecorator();
        sub.setName("test");
        sub.setEdbId("submodeltest/5/1");
        model.setSubModel(sub.getModel());

        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);
        commit = getTestEKBCommit().addDelete(model.getModel());
        persist.commit(commit);

        EDBObject testModel = edbService.getObject(getModelOid("submodeltest/5"));
        EDBObject subModel = edbService.getObject(getModelOid("submodeltest/5/1"));
        assertThat(testModel.isDeleted(), is(true));
        assertThat(subModel.isDeleted(), is(true));
    }

    @Test
    public void testIfSubModelsAreDeletedAlso_shouldDeleteParentAndSubModels() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setEdbId("submodeltest/6");
        List<Object> subs = new ArrayList<Object>();
        SubModelDecorator sub = getSubModelDecorator();
        sub.setName("test1");
        sub.setEdbId("submodeltest/6/1");
        subs.add(sub.getModel());
        sub = getSubModelDecorator();
        sub.setName("test2");
        sub.setEdbId("submodeltest/6/2");
        subs.add(sub.getModel());
        model.setSubs(subs);

        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);
        commit = getTestEKBCommit().addDelete(model.getModel());
        persist.commit(commit);

        EDBObject testModel = edbService.getObject(getModelOid("submodeltest/6"));
        EDBObject subModel1 = edbService.getObject(getModelOid("submodeltest/6/1"));
        EDBObject subModel2 = edbService.getObject(getModelOid("submodeltest/6/2"));
        assertThat(testModel.isDeleted(), is(true));
        assertThat(subModel1.isDeleted(), is(true));
        assertThat(subModel2.isDeleted(), is(true));
    }

    @Test
    public void testIfSubModelIsLoadedCorrectly_shouldLoadCorrectVersionOfSubModel() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setEdbId("submodeltest/7");

        SubModelDecorator sub = getSubModelDecorator();
        sub.setName("test");
        sub.setEdbId("submodeltest/7/1");
        model.setSubModel(sub.getModel());

        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);
        Thread.sleep(5);

        sub.setName("test2");
        commit = getTestEKBCommit().addUpdate(sub.getModel());
        persist.commit(commit);

        sub = loadSubModel("submodeltest/7/1");
        assertThat(sub.getModel(), notNullValue());
        assertThat(sub.getName(), is("test2"));

        model = loadTestModel("submodeltest/7");
        assertThat(model.getModel(), notNullValue());
        sub = new SubModelDecorator(model.getSubModel());
        assertThat(sub.getModel(), notNullValue());
        assertThat(sub.getName(), is("test"));
    }

    @Test(expected = EKBException.class)
    public void testRevertInvalidCommit_shouldThrowException() throws Exception {
        persist.revertCommit(UUID.randomUUID().toString());
    }

    @Test
    public void testRevertFunctionality_shouldRevertModelsToOldState() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setEdbId("reverttest/1");
        model.setName("before");
        TestModelDecorator model2 = getTestModelDecorator();
        model2.setEdbId("reverttest/2");
        model2.setName("test");
        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);
        String revision = commit.getRevisionNumber().toString();

        model.setName("middle");
        commit = getTestEKBCommit().addUpdate(model.getModel());
        persist.commit(commit);
        String revision2 = commit.getRevisionNumber().toString();

        commit = getTestEKBCommit().addInsert(model2.getModel());
        persist.commit(commit);
        model.setName("after");
        commit = getTestEKBCommit().addUpdate(model.getModel());
        persist.commit(commit);

        TestModelDecorator result1 =
            new TestModelDecorator(query.getModel(getTestModel(), getModelOid("reverttest/1")));
        persist.revertCommit(revision2);
        TestModelDecorator result2 =
            new TestModelDecorator(query.getModel(getTestModel(), getModelOid("reverttest/1")));
        persist.revertCommit(revision);
        TestModelDecorator result3 =
            new TestModelDecorator(query.getModel(getTestModel(), getModelOid("reverttest/1")));
        assertThat(result1, notNullValue());
        assertThat(result2, notNullValue());
        assertThat(result3, notNullValue());
        assertThat(result1.getName(), is("after"));
        assertThat(result2.getName(), is("middle"));
        assertThat(result3.getName(), is("before"));
    }

    @Test
    public void testLoadingOfEKBCommits_shouldLoadAllInformation() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setEdbId("ekbload/1");
        model.setName("test");
        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        commit.setComment("This is the first comment");
        persist.commit(commit);
        String revision = commit.getRevisionNumber().toString();
        model.setName("test2");
        commit = getTestEKBCommit().addUpdate(model.getModel());
        commit.setComment("This is the second comment");
        persist.commit(commit);
        String revision2 = commit.getRevisionNumber().toString();

        commit = query.loadCommit(revision);
        assertThat(commit, notNullValue());
        assertThat(commit.getInserts().size(), is(1));
        assertThat(commit.getRevisionNumber().toString(), is(revision));
        assertThat(commit.getDomainId(), is(getTestEKBCommit().getDomainId()));
        assertThat(commit.getConnectorId(), is(getTestEKBCommit().getConnectorId()));
        assertThat(commit.getInstanceId(), is(getTestEKBCommit().getInstanceId()));
        assertThat(commit.getComment(), is("This is the first comment"));

        commit = query.loadCommit(revision2);
        assertThat(commit, notNullValue());
        assertThat(commit.getUpdates().size(), is(1));
        assertThat(commit.getRevisionNumber().toString(), is(revision2));
        assertThat(commit.getParentRevisionNumber().toString(), is(revision));
        assertThat(commit.getDomainId(), is(getTestEKBCommit().getDomainId()));
        assertThat(commit.getConnectorId(), is(getTestEKBCommit().getConnectorId()));
        assertThat(commit.getInstanceId(), is(getTestEKBCommit().getInstanceId()));
        assertThat(commit.getComment(), is("This is the second comment"));
    }

    @Test
    public void testPrimitivePropertyTypeConversion_shouldConvertAndPersistWithCorrectType() throws Exception {
        PrimitivePropertyModelDecorator model = getPrimitivePropertyModelDecorator();
        model.setId("ppm/0");
        model.setBooleanByGet(true);
        model.setBooleanByIs(true);
        model.setPrimitiveChar(Character.MAX_VALUE);
        model.setPrimitiveDouble(Double.MAX_VALUE);
        model.setPrimitiveFloat(Float.MAX_VALUE);
        model.setPrimitiveInt(Integer.MAX_VALUE);
        model.setPrimitiveLong(Long.MAX_VALUE);
        model.setPrimitiveShort(Short.MAX_VALUE);

        assertThat(model.isBooleanByIs(), is(true));
        assertThat(model.getBooleanByGet(), is(true));

        EKBCommit commit = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit);

        // check edb object
        EDBObject edbObject = edbService.getObject(getModelOid("ppm/0"));
        // check entry types
        assertThat(edbObject.get("booleanByGet").getType(), is(Boolean.class.getName()));
        assertThat(edbObject.get("booleanByIs").getType(), is(Boolean.class.getName()));
        assertThat(edbObject.get("primitiveChar").getType(), is(Character.class.getName()));
        assertThat(edbObject.get("primitiveShort").getType(), is(Short.class.getName()));
        assertThat(edbObject.get("primitiveInt").getType(), is(Integer.class.getName()));
        assertThat(edbObject.get("primitiveLong").getType(), is(Long.class.getName()));
        assertThat(edbObject.get("primitiveFloat").getType(), is(Float.class.getName()));
        assertThat(edbObject.get("primitiveDouble").getType(), is(Double.class.getName()));

        // check values
        assertThat(edbObject.getBoolean("booleanByGet"), is(true));
        assertThat(edbObject.getBoolean("booleanByIs"), is(true));
        assertThat(edbObject.getChar("primitiveChar"), is(Character.MAX_VALUE));
        assertThat(edbObject.getShort("primitiveShort"), is(Short.MAX_VALUE));
        assertThat(edbObject.getInteger("primitiveInt"), is(Integer.MAX_VALUE));
        assertThat(edbObject.getLong("primitiveLong"), is(Long.MAX_VALUE));
        assertThat(edbObject.getFloat("primitiveFloat"), is(Float.MAX_VALUE));
        assertThat(edbObject.getDouble("primitiveDouble"), is(Double.MAX_VALUE));
    }

    @Test
    public void testDeleteCommitWithLastRevision_shouldDeleteCommit() throws Exception {
        UUID preCommit1Revision = query.getLastRevisionNumberOfContext(CONTEXT);
        TestModelDecorator model1 = getTestModelDecorator();
        model1.setEdbId("deleteCommitTest/1");
        EKBCommit commit = getTestEKBCommit().addInsert(model1.getModel());
        persist.commit(commit);

        UUID preCommit2Revision = query.getLastRevisionNumberOfContext(CONTEXT);
        TestModelDecorator model2 = getTestModelDecorator();
        model2.setEdbId("deleteCommitTest/2");
        commit = getTestEKBCommit().addInsert(model2.getModel());
        commit.addDelete(model1.getModel());
        persist.commit(commit);

        UUID postCommit2Revision = query.getLastRevisionNumberOfContext(CONTEXT);
        persist.deleteCommit(postCommit2Revision, CONTEXT);

        UUID postDelete1Revision = query.getLastRevisionNumberOfContext(CONTEXT);
        assertThat(postDelete1Revision, is(preCommit2Revision));
        QueryRequest request = QueryRequest.query("edbId", "deleteCommitTest/1");
        List<Object> result = (List<Object>) query.query(getTestModel(), request);
        assertThat(result.size(), is(1));
        persist.deleteCommit(preCommit2Revision, CONTEXT);

        UUID postDelete2Revision = query.getLastRevisionNumberOfContext(CONTEXT);
        assertThat(postDelete2Revision, is(preCommit1Revision));
        request = QueryRequest.query("edbId", "deleteCommitTest/1");
        result = (List<Object>) query.query(getTestModel(), request);
        assertThat(result.size(), is(0));
    }

    @Test(expected = EKBConcurrentException.class)
    public void testDeleteCommitWithOldRevision_shouldThrowException() throws Exception {
        TestModelDecorator model = getTestModelDecorator();
        model.setEdbId("deleteCommitTest/3");
        EKBCommit commit1 = getTestEKBCommit().addInsert(model.getModel());
        persist.commit(commit1);

        UUID postFirstCommitRevision = query.getLastRevisionNumberOfContext(CONTEXT);

        TestModelDecorator model2 = getTestModelDecorator();
        model.setEdbId("deleteCommitTest/4");
        EKBCommit commit2 = getTestEKBCommit().addInsert(model2.getModel());
        persist.commit(commit2);

        persist.deleteCommit(postFirstCommitRevision, CONTEXT);
    }

    @Test(expected = EKBException.class)
    public void testDeleteCommitWithWrongRevision_shouldThrowException() {
        persist.deleteCommit(UUID.randomUUID(), CONTEXT);
    }

    private TestModelDecorator loadTestModel(String oid) throws Exception {
        return new TestModelDecorator(query.getModel(getTestModel(), getModelOid(oid)));
    }

    private SubModelDecorator loadSubModel(String oid) throws Exception {
        return new SubModelDecorator(query.getModel(getSubModel(), getModelOid(oid)));
    }

    private TestModelDecorator getTestModelDecorator() throws Exception {
        return new TestModelDecorator(getTestModel().newInstance());
    }

    private SubModelDecorator getSubModelDecorator() throws Exception {
        return new SubModelDecorator(getSubModel().newInstance());
    }

    private PrimitivePropertyModelDecorator getPrimitivePropertyModelDecorator() throws Exception {
        return new PrimitivePropertyModelDecorator(getPrimitivePropertyModel().newInstance());
    }
}