/*
 * 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.ace.client.repository.impl;

import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.ace.client.repository.Association;
import org.apache.ace.client.repository.ObjectRepository;
import org.apache.ace.client.repository.RepositoryUtil;
import org.apache.ace.client.repository.helper.bundle.BundleHelper;
import org.apache.ace.client.repository.helper.bundle.impl.BundleHelperImpl;
import org.apache.ace.client.repository.object.Artifact2FeatureAssociation;
import org.apache.ace.client.repository.object.ArtifactObject;
import org.apache.ace.client.repository.object.DeploymentArtifact;
import org.apache.ace.client.repository.object.DeploymentVersionObject;
import org.apache.ace.client.repository.object.DistributionObject;
import org.apache.ace.client.repository.object.Feature2DistributionAssociation;
import org.apache.ace.client.repository.object.FeatureObject;
import org.apache.ace.client.repository.object.TargetObject;
import org.apache.ace.client.repository.repository.Artifact2FeatureAssociationRepository;
import org.apache.ace.client.repository.repository.ArtifactRepository;
import org.apache.ace.client.repository.repository.DeploymentVersionRepository;
import org.apache.ace.client.repository.repository.Distribution2TargetAssociationRepository;
import org.apache.ace.client.repository.repository.DistributionRepository;
import org.apache.ace.client.repository.repository.Feature2DistributionAssociationRepository;
import org.apache.ace.client.repository.repository.FeatureRepository;
import org.apache.ace.client.repository.repository.RepositoryConfiguration;
import org.apache.ace.client.repository.repository.TargetRepository;
import org.apache.ace.test.utils.TestUtils;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Filter;
import org.osgi.framework.FrameworkUtil;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.service.log.LogService;
import org.osgi.service.prefs.Preferences;
import org.osgi.service.prefs.PreferencesService;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

/**
 * Test class for the object model used <code>org.apache.ace.client.repository</code>.
 */
public class ModelTest {

    private ArtifactRepositoryImpl m_artifactRepository;
    private FeatureRepositoryImpl m_featureRepository;
    private Artifact2FeatureAssociationRepositoryImpl m_artifact2FeatureRepository;
    private DistributionRepositoryImpl m_distributionRepository;
    private Feature2DistributionAssociationRepositoryImpl m_feature2DistributionRepository;
    private TargetRepositoryImpl m_targetRepository;
    private Distribution2TargetAssociationRepositoryImpl m_distribution2TargetRepository;
    private DeploymentVersionRepositoryImpl m_deploymentVersionRepository;
    private RepositoryAdminImpl m_repositoryAdmin;

    private BundleHelperImpl m_bundleHelper = new BundleHelperImpl();
    private BundleContext m_mockBundleContext;
    private ChangeNotifier m_mockChangeNotifier;

    /**
     * The artifact object can test functionality coming from RepositoryObjectImpl, and ArtifactRepository checks much
     * of ObjectRepositoryImpl.
     * 
     * @throws InvalidSyntaxException
     */
    @Test()
    public void testArtifactObjectAndRepository() throws InvalidSyntaxException {
        // Create a very simple artifact.
        ArtifactObject a = createBasicArtifactObject("myartifact", "1.0.0", "1");

        // Try to create an illegal one
        try {
            createBasicArtifactObject("");
            assert false : "Creating an artifact with an empty name is not allowed.";
        }
        catch (IllegalArgumentException iae) {
            // expected
        }

        // Even though the artifact is not yet associated to a feature, try to get its features.
        List<FeatureObject> features = a.getFeatures();

        assert features.size() == 0 : "The artifact is not associated, so it should not return any features.";

        assert a.getAttribute(BundleHelper.KEY_SYMBOLICNAME).equals("myartifact") : "We should be able to read an attribute we just put in ourselves.";

        a.addTag("mytag", "myvalue");

        assert a.getTag("mytag").equals("myvalue") : "We should be able to read an attribute we just put in ourselves.";
        assert a.getTag(BundleHelper.KEY_SYMBOLICNAME) == null : "We should not find an attribute value when asking for a tag.";

        a.addTag(BundleHelper.KEY_SYMBOLICNAME, "mytagname");

        assert a.getTag(BundleHelper.KEY_SYMBOLICNAME).equals("mytagname") : "We can adds tags that have the same name as a artifact, but still return another value.";

        Dictionary<String, Object> dict = a.getDictionary();

        assert dict.get("mytag") == "myvalue" : "The dictionary of the object should contain all tags.";
        assert dict.get(BundleHelper.KEY_VERSION).equals("1.0.0") : "The dictionary of the object should contain all attributes; we found " + dict.get(BundleHelper.KEY_VERSION);
        String[] foundNames = (String[]) dict.get(BundleHelper.KEY_SYMBOLICNAME);
        assert foundNames.length == 2 : "For keys which are used both as a value and as a tag, we should get back both from the dictionary in an array.";
        assert (foundNames[0].equals("myartifact") && foundNames[1].equals("mytagname")) ||
            (foundNames[1].equals("myartifact") && foundNames[0].equals("mytagname")) : "The order is undefined, but we should find both the items we put in for '" + BundleHelper.KEY_SYMBOLICNAME + "'.";

        assert m_artifactRepository.get().size() == 1 : "The repository should contain exactly one artifact.";
        assert m_artifactRepository.get().get(0).equals(a) : "The repository should contain exactly our artifact.";

        ArtifactObject b2 = createBasicArtifactObject("myotherartifact", "1");

        assert m_artifactRepository.get(createLocalFilter("(" + BundleHelper.KEY_SYMBOLICNAME + "=myartifact)")).size() == 1 : "When filtering for our artifact, we should find only that.";
        assert m_artifactRepository.get(createLocalFilter("(" + BundleHelper.KEY_VERSION + "=1.0.0)")).size() == 2 : "When filtering for a version, we should find two artifacts.";

        try {
            createBasicArtifactObject("myartifact", "1.0.0");
            assert false : "Adding a artifact which is identical to one already in the repository should be illegal.";
        }
        catch (IllegalArgumentException iae) {
            // expected
        }

        try {
            b2.addAttribute("thenewattribute", "withsomevalue");
        }
        catch (UnsupportedOperationException uoe) {
            assert false : "Adding arbitrary attributes to a artifact object should be allowed.";
        }

        try {
            b2.addAttribute(BundleHelper.KEY_SYMBOLICNAME, "artifact.42");
            assert false : "Changing key attributes in a artifact should not be allowed.";
        }
        catch (UnsupportedOperationException uoe) {
            // expected
        }

        try {
            Map<String, String> attr = new HashMap<>();
            attr.put(BundleHelper.KEY_NAME, "mynewartifact");
            Map<String, String> tags = new HashMap<>();
            m_artifactRepository.create(attr, tags);
            assert false : "Creating a artifact without specifying all mandatory atttributes should be illegal.";
        }
        catch (IllegalArgumentException iae) {
            // expected
        }

        m_artifactRepository.remove(a);

        try {
            a.addTag("mytag", "myvalue");
            assert false : "Deleted objects are not allowed to be changed.";
        }
        catch (IllegalStateException ise) {
            // expected
        }

        assert m_artifactRepository.get().size() == 1 : "After removing our first artifact, the repository should contain one artifact.";
        assert m_artifactRepository.get().get(0).equals(b2) : "After removing our first artifact, the repository should contain only our second artifact.";
    }

    /**
     * Tests that we can create artifacts which contain a certain size (estimate). See ACE-384.
     */
    @Test()
    public void testArtifactObjectSize() {
        ArtifactObject artifactWithSize = createBasicArtifactObject("myartifact", "1.0.0", "10");
        assert artifactWithSize.getSize() == 10 : "The artifact did not have a valid size?!";

        ArtifactObject artifactWithoutSize = createBasicArtifactObject("artifactWithoutSize", "1.0.0", null);
        assert artifactWithoutSize.getSize() == -1L : "The artifact did have a size?!";

        ArtifactObject artifactWithInvalidSize = createBasicArtifactObject("artifactWithInvalidSize", "1.0.0", "xyz");
        assert artifactWithInvalidSize.getSize() == -1L : "The artifact did have a size?!";
    }

    /**
     * Tests the behavior when associating stuff, and removing associations.
     */
    @Test()
    public void testAssociations() {
        initializeRepositoryAdmin();
        // Create two, rather boring, artifacts.
        ArtifactObject b1 = createBasicArtifactObject("artifact1");
        ArtifactObject b2 = createBasicArtifactObject("artifact2");

        // Create three features.
        FeatureObject g1 = createBasicFeatureObject("feature1");
        FeatureObject g2 = createBasicFeatureObject("feature2");
        FeatureObject g3 = createBasicFeatureObject("feature3");

        // Create some associations.
        Artifact2FeatureAssociation b2g1 = m_artifact2FeatureRepository.create(b1, g2);
        assert b2g1 != null;
        Artifact2FeatureAssociation b2g2 = m_artifact2FeatureRepository.create(b2, g1);
        assert b2g2 != null;
        Artifact2FeatureAssociation b2g3 = m_artifact2FeatureRepository.create(b1, g3);
        assert b2g3 != null;
        Artifact2FeatureAssociation b2g4 = m_artifact2FeatureRepository.create(b2, g3);
        assert b2g4 != null;

        // Do some basic checks on the repositories.
        assert m_artifactRepository.get().size() == 2 : "We should have two artifacts in our repository; we found " + m_artifactRepository.get().size() + ".";
        assert m_featureRepository.get().size() == 3 : "We should have three features in our repository; we found " + m_featureRepository.get().size() + ".";
        assert m_artifact2FeatureRepository.get().size() == 4 : "We should have four associations in our repository; we found " + m_artifact2FeatureRepository.get().size() + ".";

        assert (b2g4.getLeft().size() == 1) && b2g4.getLeft().contains(b2) : "The left side of the fourth association should be artifact 2.";
        assert (b2g4.getRight().size() == 1) && b2g4.getRight().contains(g3) : "The right side of the fourth association should be feature 3.";

        // Check the wiring: what is wired to what?
        List<FeatureObject> b1features = b1.getFeatures();
        List<FeatureObject> b2features = b2.getFeatures();

        List<ArtifactObject> g1artifacts = g1.getArtifacts();
        List<ArtifactObject> g2artifacts = g2.getArtifacts();
        List<ArtifactObject> g3artifacts = g3.getArtifacts();
        List<DistributionObject> g1distributions = g1.getDistributions();
        List<DistributionObject> g2distributions = g2.getDistributions();
        List<DistributionObject> g3distributions = g3.getDistributions();

        assert g1distributions.size() == 0 : "Feature one should not have any associations to distributions; we found " + g1distributions.size() + ".";
        assert g2distributions.size() == 0 : "Feature two should not have any associations to distributions; we found " + g2distributions.size() + ".";
        assert g3distributions.size() == 0 : "Feature three should not have any associations to distributions; we found " + g3distributions.size() + ".";

        List<FeatureObject> b1expectedFeatures = new ArrayList<>();
        b1expectedFeatures.add(g2);
        b1expectedFeatures.add(g3);
        List<FeatureObject> b2expectedFeatures = new ArrayList<>();
        b2expectedFeatures.add(g1);
        b2expectedFeatures.add(g3);

        List<ArtifactObject> g1expectedArtifacts = new ArrayList<>();
        g1expectedArtifacts.add(b2);
        List<ArtifactObject> g2expectedArtifacts = new ArrayList<>();
        g2expectedArtifacts.add(b1);
        List<ArtifactObject> g3expectedArtifacts = new ArrayList<>();
        g3expectedArtifacts.add(b1);
        g3expectedArtifacts.add(b2);

        assert b1features.containsAll(b1expectedFeatures) && b1expectedFeatures.containsAll(b1features) : "b1 should be associated to exactly features 2 and 3.";
        assert b2features.containsAll(b2expectedFeatures) && b2expectedFeatures.containsAll(b2features) : "b2 should be associated to exactly features 1 and 3.";

        assert g1artifacts.containsAll(g1expectedArtifacts) && g1expectedArtifacts.containsAll(g1artifacts) : "g1 should be associated to exactly artifact 2.";
        assert g2artifacts.containsAll(g2expectedArtifacts) && g2expectedArtifacts.containsAll(g2artifacts) : "g2 should be associated to exactly artifact 1.";
        assert g3artifacts.containsAll(g3expectedArtifacts) && g3expectedArtifacts.containsAll(g3artifacts) : "g3 should be associated to exactly artifacts 1 and 2.";

        m_artifact2FeatureRepository.remove(b2g4);

        b1features = b1.getFeatures();
        b2features = b2.getFeatures();
        g1artifacts = g1.getArtifacts();
        g2artifacts = g2.getArtifacts();
        g3artifacts = g3.getArtifacts();

        b2expectedFeatures.remove(g3);
        g3expectedArtifacts.remove(b2);

        assert b1features.containsAll(b1expectedFeatures) && b1expectedFeatures.containsAll(b1features) : "b1 should be associated to exactly features 2 and 3.";
        assert b2features.containsAll(b2expectedFeatures) && b2expectedFeatures.containsAll(b2features) : "b2 should be associated to exactly feature 1.";

        assert g1artifacts.containsAll(g1expectedArtifacts) && g1expectedArtifacts.containsAll(g1artifacts) : "g1 should be associated to exactly artifact 2.";
        assert g2artifacts.containsAll(g2expectedArtifacts) && g2expectedArtifacts.containsAll(g2artifacts) : "g2 should be associated to exactly artifact 1.";
        assert g3artifacts.containsAll(g3expectedArtifacts) && g3expectedArtifacts.containsAll(g3artifacts) : "g3 should be associated to exactly artifact 1.";
    }

    @Test()
    public void testAssociationsWithCardinality() {
        ArtifactObject a1 = createBasicArtifactObject("a1");
        FeatureObject f1 = createBasicFeatureObject("f1");
        FeatureObject f2 = createBasicFeatureObject("f2");
        FeatureObject f3 = createBasicFeatureObject("f3");

        Map<String, String> props = new HashMap<>();
        props.put(Association.LEFT_ENDPOINT, "(" + BundleHelper.KEY_SYMBOLICNAME + "=a1)");
        props.put(Association.LEFT_CARDINALITY, "1");
        props.put(Association.RIGHT_ENDPOINT, "(" + FeatureObject.KEY_NAME + "=f*)");
        props.put(Association.RIGHT_CARDINALITY, "2");
        Map<String, String> tags = new HashMap<>();

        try {
            m_artifact2FeatureRepository.create(props, tags);
            assert false : "There are three matches for the feature, but we have a cardinality of 2; we should expect a NPE because no comparator is provided.";
        }
        catch (NullPointerException npe) {
            // expected
        }

        props.put(Association.RIGHT_CARDINALITY, "3");

        Artifact2FeatureAssociation bg = m_artifact2FeatureRepository.create(props, tags);
        assert bg != null : "Assocating artifact to feature failed?!";

        assert a1.getFeatures().size() == 3 : "The artifact should be associated to three features.";
        assert (f1.getArtifacts().size() == 1) && f1.getArtifacts().contains(a1) : "g1 should be associated to only b1.";
        assert (f2.getArtifacts().size() == 1) && f2.getArtifacts().contains(a1) : "g1 should be associated to only b1.";
        assert (f3.getArtifacts().size() == 1) && f3.getArtifacts().contains(a1) : "g1 should be associated to only b1.";
    }

    @Test()
    public void testAssociationsWithLists() {
        ArtifactObject b1 = createBasicArtifactObject("b1");
        ArtifactObject b2 = createBasicArtifactObject("b2");
        ArtifactObject b3 = createBasicArtifactObject("b3");
        FeatureObject g1 = createBasicFeatureObject("g1");
        FeatureObject g2 = createBasicFeatureObject("g2");
        FeatureObject g3 = createBasicFeatureObject("g3");

        List<ArtifactObject> artifacts = new ArrayList<>();
        artifacts.add(b1);
        artifacts.add(b2);
        List<FeatureObject> features = new ArrayList<>();
        features.add(g1);
        features.add(g3);

        Artifact2FeatureAssociation bg = m_artifact2FeatureRepository.create(artifacts, features);

        assert bg.getLeft().size() == 2 : "We expect two artifacts on the left side of the association.";
        assert bg.getRight().size() == 2 : "We expect two features on the right side of the association.";

        assert bg.getLeft().contains(b1) : "b1 should be on the left side of the association.";
        assert bg.getLeft().contains(b2) : "b2 should be on the left side of the association.";
        assert !bg.getLeft().contains(b3) : "b3 should not be on the left side of the association.";
        assert bg.getRight().contains(g1) : "g1 should be on the right side of the association.";
        assert !bg.getRight().contains(g2) : "g2 should not be on the right side of the association.";
        assert bg.getRight().contains(g3) : "g3 should be on the right side of the association.";

        List<FeatureObject> foundFeatures = b1.getFeatures();
        assert foundFeatures.size() == 2 : "b1 should be associated with two features.";
        assert foundFeatures.contains(g1) : "b1 should be associated with g1";
        assert !foundFeatures.contains(g2) : "b1 not should be associated with g2";
        assert foundFeatures.contains(g3) : "b1 should be associated with g3";

        foundFeatures = b3.getFeatures();
        assert foundFeatures.size() == 0 : "b3 should not be associated with any features.";

        List<ArtifactObject> foundArtifacts = g3.getArtifacts();
        assert foundArtifacts.size() == 2 : "g1 should be associated with two features.";
        assert foundArtifacts.contains(b1) : "g1 should be associated with b1";
        assert foundArtifacts.contains(b2) : "g1 should be associated with b2";
        assert !foundArtifacts.contains(b3) : "g1 should not be associated with b3";
    }

    @Test()
    public void testDeploymentRepository() {
        DeploymentVersionObject version11 = createBasicDeploymentVersionObject("target1", "1", new String[] { "artifact1", "artifact2" });
        DeploymentVersionObject version12 = createBasicDeploymentVersionObject("target1", "2", new String[] { "artifact3", "artifact4" });
        // Note the different order in adding the versions for target2.
        DeploymentVersionObject version22 = createBasicDeploymentVersionObject("target2", "2", new String[] { "artifactC", "artifactD" });
        DeploymentVersionObject version21 = createBasicDeploymentVersionObject("target2", "1", new String[] { "artifactA", "artifactB" });

        assert m_deploymentVersionRepository.getDeploymentVersions("NotMyTarget").size() == 0 : "The deployment repository should not return" +
            "any versions when we ask for a target that does not exist, but it returns " + m_deploymentVersionRepository.getDeploymentVersions("NotMyTarget").size();

        List<DeploymentVersionObject> for1 = m_deploymentVersionRepository.getDeploymentVersions("target1");
        assert for1.size() == 2 : "We expect two versions for target1, but we find " + for1.size();
        assert for1.get(0) == version11 : "The first version for target1 should be version11";
        assert for1.get(1) == version12 : "The second version for target1 should be version12";

        List<DeploymentVersionObject> for2 = m_deploymentVersionRepository.getDeploymentVersions("target2");
        assert for2.size() == 2 : "We expect two versions for target2, but we find " + for2.size();
        assert for2.get(0) == version21 : "The first version for target2 should be version21";
        assert for2.get(1) == version22 : "The second version for target2 should be version22";

        assert m_deploymentVersionRepository.getMostRecentDeploymentVersion("NotMyTarget") == null : "The most recent version for a non-existent target should not exist.";
        assert m_deploymentVersionRepository.getMostRecentDeploymentVersion("target1") == version12 : "The most recent version for target1 should be version12";
        assert m_deploymentVersionRepository.getMostRecentDeploymentVersion("target2") == version22 : "The most recent version for target2 should be version22";
    }

    @Test()
    public void testDeploymentRepositoryFilter() {

        String gwId = "\\ ( * ) target1)";
        DeploymentVersionObject version1 = createBasicDeploymentVersionObject(gwId, "1", new String[] { "artifact1", "artifact2" });

        List<DeploymentVersionObject> for1 = m_deploymentVersionRepository.getDeploymentVersions(gwId);
        assert for1.size() == 1 : "We expect one version for" + gwId + ", but we find " + for1.size();
        assert for1.get(0) == version1 : "The only version for" + gwId + "should be version1";
    }

    @Test()
    public void testDeploymentVersion() throws IOException {
        DeploymentVersionObject version = createBasicDeploymentVersionObject("target1", "1", new String[] { "artifact1", "artifact2" });

        assert version.getDeploymentArtifacts().length == 2 : "We expect to find two artifacts, but we find " + version.getDeploymentArtifacts().length;
        assert version.getDeploymentArtifacts()[0].getUrl().equals("artifact1");
        assert version.getDeploymentArtifacts()[1].getUrl().equals("artifact2");

        ((DeploymentArtifactImpl) version.getDeploymentArtifacts()[0]).addDirective("myDirective", "myValue");

        try {
            createBasicDeploymentVersionObject("target1", "1", new String[] { "artifact1", "artifact2" });
            assert false : "Creating a deployment version with a target and version that already exists should not be allowed.";
        }
        catch (IllegalArgumentException iae) {
            // expected
        }

        assert m_deploymentVersionRepository.get().size() == 1 : "The disallowed version should not be in the repository; we find " + m_deploymentVersionRepository.get().size();
        assert m_deploymentVersionRepository.get().get(0) == version : "Only our newly created version object should be in the repository.";

        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        RepositorySet deployment = new RepositorySet(null, null, null, null, new ObjectRepositoryImpl[] { m_deploymentVersionRepository }, null, "", true);
        new RepositorySerializer(deployment).toXML(buffer);
        initializeRepositoryAdmin();

        assert m_deploymentVersionRepository.get().size() == 0;

        deployment = new RepositorySet(null, null, null, null, new ObjectRepositoryImpl[] { m_deploymentVersionRepository }, null, "", true);
        new RepositorySerializer(deployment).fromXML(new ByteArrayInputStream(buffer.toByteArray()));

        assert m_deploymentVersionRepository.get().size() == 1 : "The disallowed version should not be in the repository.";
        assert m_deploymentVersionRepository.get().get(0).equals(version) : "Only our newly created version object should be in the repository.";

        assert m_deploymentVersionRepository.get().get(0).getDeploymentArtifacts().length == 2 : "We expect to find two artifacts, but we find " + m_deploymentVersionRepository.get().get(0).getDeploymentArtifacts().length;
        assert m_deploymentVersionRepository.get().get(0).getDeploymentArtifacts()[0].getUrl().equals("artifact1");
        assert m_deploymentVersionRepository.get().get(0).getDeploymentArtifacts()[0].getKeys().length == 1 : "We expect to find one directive in the first artifact.";
        assert m_deploymentVersionRepository.get().get(0).getDeploymentArtifacts()[0].getDirective("myDirective").equals("myValue") : "The directive should be 'myValue'.";
        assert m_deploymentVersionRepository.get().get(0).getDeploymentArtifacts()[1].getUrl().equals("artifact2");
    }

    /**
     * Not a full-fledged testcase, but a quick test of the correctness of the specified classes for distributions,
     * targets and their associations. In essence, this test 'touches' all code which uses generic code which has been
     * tested by TestAssociations.
     */
    @Test()
    public void testDistribution2TargetAssociations() {
        initializeRepositoryAdmin();
        DistributionObject d1 = createBasicDistributionObject("distribution1");
        TargetObject t1 = createBasicTargetObject("target1");
        m_distribution2TargetRepository.create(d1, t1);

        assert d1.getFeatures().size() == 0 : "Distribution 1 should not be associated with any features; it is associated with " + d1.getFeatures().size() + ".";
        assert d1.getTargets().size() == 1 : "Distribution 1 should be associated with exactly one target; it is associated with " + d1.getTargets().size() + ".";

        assert t1.getDistributions().size() == 1 : "Target 1 should be associated with exactly one distribution; it is associated with " + t1.getDistributions().size() + ".";
    }

    /**
     * Tests the correctness of the equals() in RepositoryObject.
     */
    @Test()
    public void testEquals() {
        List<ArtifactObject> artifacts = new ArrayList<>();
        artifacts.add(createBasicArtifactObject("artifact1"));
        artifacts.add(createBasicArtifactObject("artifact2"));
        artifacts.get(1).addTag("thetag", "thevalue");
        artifacts.add(createBasicArtifactObject("artifact3"));

        List<ArtifactObject> backupArtifacts = new ArrayList<>();
        backupArtifacts.addAll(artifacts);

        for (ArtifactObject b : backupArtifacts) {
            artifacts.remove(b);
        }

        assert artifacts.size() == 0 : "The artifacts list should be empty; if not, the ArtifactObject's equals() could be broken.";
    }

    /**
     * Not a full-fledged testcase, but a quick test of the correctness of the specified classes for features,
     * distributions and their associations. In essence, this test 'touches' all code which uses generic code which has
     * been tested by TestAssociations.
     */
    @Test()
    public void TestFeature2DistributionAssociations() {
        initializeRepositoryAdmin();
        FeatureObject f1 = createBasicFeatureObject("feature1");
        DistributionObject d1 = createBasicDistributionObject("distribution1");
        Feature2DistributionAssociation f2d1 = m_feature2DistributionRepository.create(f1, d1);

        assert (f2d1.getLeft().size() == 1) && f2d1.getLeft().contains(f1) : "Left side of the association should be our feature.";
        assert (f2d1.getRight().size() == 1) && f2d1.getRight().contains(d1) : "Right side of the association should be our distribution.";

        assert f1.getArtifacts().size() == 0 : "Feature 1 should not be associated with any artifacts; it is associated with " + f1.getArtifacts().size() + ".";
        assert f1.getDistributions().size() == 1 : "Feature 1 should be associated with exactly one distribution; it is associated with " + f1.getDistributions().size() + ".";

        assert d1.getFeatures().size() == 1 : "Distribution 1 should be associated with exactly one feature; it is associated with " + d1.getFeatures().size() + ".";
        assert d1.getTargets().size() == 0 : "Distribution 1 should not be associated with any targets; it is associated with " + d1.getTargets().size() + ".";
    }

    @Test()
    public void testGetAssociationsWith() {
        initializeRepositoryAdmin();
        ArtifactObject a1 = createBasicArtifactObject("artifact1");
        FeatureObject f1 = createBasicFeatureObject("feature1");
        Artifact2FeatureAssociation a2f1 = m_artifact2FeatureRepository.create(a1, f1);

        List<Artifact2FeatureAssociation> b1Associations = a1.getAssociationsWith(f1);
        List<Artifact2FeatureAssociation> g1Associations = f1.getAssociationsWith(a1);

        assert b1Associations.size() == 1 : "The artifact has exactly one association to the feature, but it shows " + b1Associations.size() + ".";
        assert b1Associations.get(0) == a2f1 : "The artifact's association should be the one we created.";

        assert g1Associations.size() == 1 : "The feature has exactly one association to the artifact.";
        assert g1Associations.get(0) == a2f1 : "The feature's association should be the one we created.";
    }

    @Test()
    public void testLimitedNumberOfDeploymentVersions() throws IOException {
        RepositoryConfigurationImpl repoConfig = new RepositoryConfigurationImpl();
        repoConfig.setDeploymentVersionLimit(3); // only keep the 3 most recent deployment versions...

        m_deploymentVersionRepository = new DeploymentVersionRepositoryImpl(m_mockChangeNotifier, repoConfig);
        TestUtils.configureObject(m_deploymentVersionRepository, BundleContext.class, m_mockBundleContext);

        // Add several bundles, but not enough to get any deployment version purged...
        DeploymentVersionObject target1_v1 = createBasicDeploymentVersionObject("target1", "1", new String[] { "artifact1", "artifact2" });
        DeploymentVersionObject target1_v2 = createBasicDeploymentVersionObject("target1", "2", new String[] { "artifact1", "artifact2" });
        DeploymentVersionObject target1_v3 = createBasicDeploymentVersionObject("target1", "3", new String[] { "artifact1", "artifact2" });
        DeploymentVersionObject target2_v1 = createBasicDeploymentVersionObject("target2", "1", new String[] { "artifact3", "artifact4" });
        DeploymentVersionObject target2_v2 = createBasicDeploymentVersionObject("target2", "2", new String[] { "artifact3", "artifact5" });

        List<DeploymentVersionObject> repo = m_deploymentVersionRepository.get();
        // All created deployment versions should be present...
        assertEquals(repo.size(), 5);
        assertTrue(repo.contains(target1_v1));
        assertTrue(repo.contains(target1_v2));
        assertTrue(repo.contains(target1_v3));
        assertTrue(repo.contains(target2_v1));
        assertTrue(repo.contains(target2_v2));

        // Add a new deployment version, which should cause the oldest (= version 1) of target1 to be purged...
        DeploymentVersionObject target1_v4 = createBasicDeploymentVersionObject("target1", "4", new String[] { "artifact1", "artifact2" });

        repo = m_deploymentVersionRepository.get();
        // Still 5 deployment versions, without version 1 of target1...
        assertEquals(repo.size(), 5);
        assertFalse(repo.contains(target1_v1));
        assertTrue(repo.contains(target1_v2));
        assertTrue(repo.contains(target1_v3));
        assertTrue(repo.contains(target1_v4));
        assertTrue(repo.contains(target2_v1));
        assertTrue(repo.contains(target2_v2));

        // Add yet another deployment version, which should cause the oldest (= version 2) of target1 to be purged...
        DeploymentVersionObject target1_v5 = createBasicDeploymentVersionObject("target1", "5", new String[] { "artifact1", "artifact2" });

        repo = m_deploymentVersionRepository.get();
        // Still 5 deployment versions, without versions 1 & 2 of target1...
        assertEquals(repo.size(), 5);
        assertFalse(repo.contains(target1_v1));
        assertFalse(repo.contains(target1_v2));
        assertTrue(repo.contains(target1_v3));
        assertTrue(repo.contains(target1_v4));
        assertTrue(repo.contains(target1_v5));
        assertTrue(repo.contains(target2_v1));
        assertTrue(repo.contains(target2_v2));
    }

    @Test()
    public void testModelFiltering() throws InvalidSyntaxException {
        initializeRepositoryAdmin();
        // Create an empty artifact repository.
        Map<String, String> attributes = new HashMap<>();
        attributes.put("myattribute", "theattribute");
        attributes.put("name", "attname");
        Map<String, String> tags = new HashMap<>();

        assert m_featureRepository != null : "Something has gone wrong injecting the feature repository.";
        FeatureObject g1 = m_featureRepository.create(attributes, tags);
        g1.addTag("mytag", "thetag");
        g1.addTag("name", "tagname");
        g1.addTag("difficult", ")diffi)c*ul\\t");

        assert m_featureRepository.get(createLocalFilter("(myattribute=*)")).size() == 1 : "There should be a myattribute in b1.";
        assert m_featureRepository.get(createLocalFilter("(myattribute=theattribute)")).size() == 1 : "There should be myattribute=theattribute in b1.";
        assert m_featureRepository.get(createLocalFilter("(myattribute=thetag)")).size() == 0 : "There should not be myattribute=thetag in b1.";
        assert m_featureRepository.get(createLocalFilter("(mytag=*)")).size() == 1 : "There should be a mytag in b1.";
        assert m_featureRepository.get(createLocalFilter("(mytag=thetag)")).size() == 1 : "There should be mytag=thetag in b1.";
        assert m_featureRepository.get(createLocalFilter("(mytag=theattribute)")).size() == 0 : "There should not be mytag=theattribute in b1.";

        assert m_featureRepository.get(createLocalFilter("(name=*)")).size() == 1 : "There should be a name parameter in b1.";
        assert m_featureRepository.get(createLocalFilter("(name=attname)")).size() == 1 : "There should be a name=attname in b1.";
        assert m_featureRepository.get(createLocalFilter("(name=tagname)")).size() == 1 : "There should be a name=tagname in b1.";
        assert m_featureRepository.get(createLocalFilter("(name=thetag)")).size() == 0 : "There should not be name=thetag in b1.";

        try {
            m_featureRepository.get(createLocalFilter("(difficult=)diffi)c*ul\\t"));
            assert false : "The non-escaped difficult string should raise an error.";
        }
        catch (InvalidSyntaxException ex) {
            // expected
        }
        assert m_featureRepository.get(createLocalFilter("(difficult=" + RepositoryUtil.escapeFilterValue(")diffi)c*ul\\t") + ")")).size() == 1 : "The 'difficult' string should be correctly escaped, and thus return exactly one match.";
    }

    @Test()
    public void testRepositorySerialization() throws IOException {
        createBasicArtifactObject("myartifact", "1");
        createBasicArtifactObject("myartifact", "2");

        // Write the store to a stream, reset the repository, and re-read it.
        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        RepositorySet store = new RepositorySet(null, null, null, null, new ObjectRepositoryImpl[] { m_artifactRepository, m_artifact2FeatureRepository, m_featureRepository }, null, "", true);
        new RepositorySerializer(store).toXML(buffer);
        initializeRepositoryAdmin();
        store = new RepositorySet(null, null, null, null, new ObjectRepositoryImpl[] { m_artifactRepository, m_artifact2FeatureRepository, m_featureRepository }, null, "", true);
        new RepositorySerializer(store).fromXML(new ByteArrayInputStream(buffer.toByteArray()));

        assert m_artifactRepository.get().size() == 2 : "We expect to find 2 artifacts, but we find " + m_artifactRepository.get().size();
    }

    @Test()
    public void testSerialization() throws IOException {
        ArtifactObject b1 = createBasicArtifactObject("artifact1");
        ArtifactObject b2 = createBasicArtifactObject("artifact2");
        ArtifactObject b3 = createBasicArtifactObject("artifact3");

        FeatureObject g1 = createBasicFeatureObject("feature1");
        FeatureObject g2 = createBasicFeatureObject("feature2");

        m_artifact2FeatureRepository.create(b1, g1);
        m_artifact2FeatureRepository.create(b2, g2);
        m_artifact2FeatureRepository.create(b3, g2);

        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        RepositorySet store = new RepositorySet(null, null, null, null, new ObjectRepositoryImpl[] { m_artifactRepository, m_featureRepository, m_artifact2FeatureRepository }, null, "", true);
        new RepositorySerializer(store).toXML(buffer);
        initializeRepositoryAdmin();
        store = new RepositorySet(null, null, null, null, new ObjectRepositoryImpl[] { m_artifactRepository, m_featureRepository, m_artifact2FeatureRepository }, null, "", true);
        new RepositorySerializer(store).fromXML(new ByteArrayInputStream(buffer.toByteArray()));

        assert m_artifactRepository.get().size() == 3 : "We expect to find 3 artifacts, but we find " + m_artifactRepository.get().size();
        assert m_featureRepository.get().size() == 2 : "We expect to find 2 features, but we find " + m_featureRepository.get().size();
        assert m_artifact2FeatureRepository.get().size() == 3 : "We expect to find 3 associations, but we find " + m_artifact2FeatureRepository.get().size();
        assert b1.isAssociated(g1, FeatureObject.class) : "After serialization, b1 should still be associated with g1.";
        assert !b1.isAssociated(g2, FeatureObject.class) : "After serialization, b1 should not be associated with g1.";
        assert !b2.isAssociated(g1, FeatureObject.class) : "After serialization, b2 should not be associated with g2.";
        assert b2.isAssociated(g2, FeatureObject.class) : "After serialization, b2 should still be associated with g2.";
        assert !b3.isAssociated(g1, FeatureObject.class) : "After serialization, b3 should not be associated with g2.";
        assert b3.isAssociated(g2, FeatureObject.class) : "After serialization, b3 should still be associated with g2.";
    }

    @Test()
    public void testUnlimitedNumberOfDeploymentVersions() throws IOException {
        RepositoryConfiguration repoConfig = new RepositoryConfigurationImpl();

        m_deploymentVersionRepository = new DeploymentVersionRepositoryImpl(m_mockChangeNotifier, repoConfig);
        TestUtils.configureObject(m_deploymentVersionRepository, BundleContext.class, m_mockBundleContext);

        DeploymentVersionObject target1_v1 = createBasicDeploymentVersionObject("target1", "1", new String[] { "artifact1", "artifact2" });
        DeploymentVersionObject target1_v2 = createBasicDeploymentVersionObject("target1", "2", new String[] { "artifact1", "artifact2" });
        DeploymentVersionObject target1_v3 = createBasicDeploymentVersionObject("target1", "3", new String[] { "artifact1", "artifact2" });
        DeploymentVersionObject target2_v1 = createBasicDeploymentVersionObject("target2", "1", new String[] { "artifact3", "artifact4" });
        DeploymentVersionObject target2_v2 = createBasicDeploymentVersionObject("target2", "2", new String[] { "artifact3", "artifact5" });

        List<DeploymentVersionObject> repo = m_deploymentVersionRepository.get();
        assertEquals(repo.size(), 5);
        assertTrue(repo.contains(target1_v1));
        assertTrue(repo.contains(target1_v2));
        assertTrue(repo.contains(target1_v3));
        assertTrue(repo.contains(target2_v1));
        assertTrue(repo.contains(target2_v2));

        DeploymentVersionObject target1_v4 = createBasicDeploymentVersionObject("target1", "4", new String[] { "artifact1", "artifact2" });

        repo = m_deploymentVersionRepository.get();
        assertEquals(repo.size(), 6);
        assertTrue(repo.contains(target1_v1));
        assertTrue(repo.contains(target1_v2));
        assertTrue(repo.contains(target1_v3));
        assertTrue(repo.contains(target1_v4));
        assertTrue(repo.contains(target2_v1));
        assertTrue(repo.contains(target2_v2));

        DeploymentVersionObject target1_v5 = createBasicDeploymentVersionObject("target1", "5", new String[] { "artifact1", "artifact2" });

        repo = m_deploymentVersionRepository.get();
        assertEquals(repo.size(), 7);
        assertTrue(repo.contains(target1_v1));
        assertTrue(repo.contains(target1_v2));
        assertTrue(repo.contains(target1_v3));
        assertTrue(repo.contains(target1_v4));
        assertTrue(repo.contains(target1_v5));
        assertTrue(repo.contains(target2_v1));
        assertTrue(repo.contains(target2_v2));
    }
    
    @Test()
    public void testConcurrentAccessToObjectRepository() throws Exception {
        initializeRepositoryAdmin();
        // adds 10 features
        for (int i = 0; i < 10; i++) {
            createBasicFeatureObject("feature-" + i);
        }
        // asks for a list
        List<FeatureObject> list = m_featureRepository.get();
        // then adds another feature
        createBasicFeatureObject("feature-X");
        // and makes sure the returned list still has 10 features, not 11, and not
        // throwing any concurrent modification exceptions
        assertEquals(list.size(), 10);
        Iterator<FeatureObject> iterator = list.iterator();
        for (int i = 0; i < 10; i++) {
            assertTrue(iterator.hasNext());
            assertTrue(iterator.next() != null);
        }
        assertFalse(iterator.hasNext());
        // remove item from the list
        list.remove(0);
        // get a new list, ensure there are still 11 features
        list = m_featureRepository.get();
        assertEquals(list.size(), 11);
    }

    private ArtifactObject createBasicArtifactObject(String symbolicName) {
        return createBasicArtifactObject(symbolicName, null);
    }

    private ArtifactObject createBasicArtifactObject(String symbolicName, String version) {
        return createBasicArtifactObject(symbolicName, version, null);
    }

    private ArtifactObject createBasicArtifactObject(String symbolicName, String version, String size) {
        Map<String, String> attr = new HashMap<>();
        attr.put(BundleHelper.KEY_SYMBOLICNAME, symbolicName);
        attr.put(ArtifactObject.KEY_MIMETYPE, BundleHelper.MIMETYPE);
        attr.put(ArtifactObject.KEY_URL, "http://" + symbolicName + "-v" + ((version == null) ? "null" : version));
        if (size != null) {
            attr.put(ArtifactObject.KEY_SIZE, size); // bytes
        }
        Map<String, String> tags = new HashMap<>();
        if (version != null) {
            attr.put(BundleHelper.KEY_VERSION, version);
        }
        return m_artifactRepository.create(attr, tags);
    }

    private DeploymentVersionObject createBasicDeploymentVersionObject(String targetID, String version, String[] artifacts) {
        Map<String, String> attr = new HashMap<>();
        attr.put(DeploymentVersionObject.KEY_TARGETID, targetID);
        attr.put(DeploymentVersionObject.KEY_VERSION, version);
        Map<String, String> tags = new HashMap<>();

        List<DeploymentArtifactImpl> deploymentArtifacts = new ArrayList<>();
        for (String s : artifacts) {
            deploymentArtifacts.add(new DeploymentArtifactImpl(s, -1L));
        }
        return m_deploymentVersionRepository.create(attr, tags, deploymentArtifacts.toArray(new DeploymentArtifact[0]));
    }

    private DistributionObject createBasicDistributionObject(String name) {
        Map<String, String> attr = new HashMap<>();
        attr.put(DistributionObject.KEY_NAME, name);
        Map<String, String> tags = new HashMap<>();

        return m_distributionRepository.create(attr, tags);
    }

    private FeatureObject createBasicFeatureObject(String name) {
        Map<String, String> attr = new HashMap<>();
        attr.put(FeatureObject.KEY_NAME, name);
        Map<String, String> tags = new HashMap<>();

        return m_featureRepository.create(attr, tags);
    }

    private TargetObject createBasicTargetObject(String id) {
        Map<String, String> attr = new HashMap<>();
        attr.put(TargetObject.KEY_ID, id);
        Map<String, String> tags = new HashMap<>();

        return m_targetRepository.create(attr, tags);
    }

    private Filter createLocalFilter(String filter) throws InvalidSyntaxException {
        return FrameworkUtil.createFilter(filter);
    }

    @BeforeMethod(alwaysRun = true)
    private void initializeRepositoryAdmin() {
        m_mockBundleContext = TestUtils.createMockObjectAdapter(BundleContext.class, new Object() {
            @SuppressWarnings("unused")
            public Filter createFilter(String filter) throws InvalidSyntaxException {
                return createLocalFilter(filter);
            }
        });

        m_mockChangeNotifier = TestUtils.createNullObject(ChangeNotifier.class);

        RepositoryConfiguration repoConfig = new RepositoryConfigurationImpl();

        m_artifactRepository = new ArtifactRepositoryImpl(m_mockChangeNotifier, repoConfig);
        TestUtils.configureObject(m_artifactRepository, LogService.class);
        TestUtils.configureObject(m_artifactRepository, BundleContext.class, m_mockBundleContext);
        m_artifactRepository.addHelper(BundleHelper.MIMETYPE, m_bundleHelper);
        m_featureRepository = new FeatureRepositoryImpl(m_mockChangeNotifier, repoConfig);
        TestUtils.configureObject(m_featureRepository, BundleContext.class, m_mockBundleContext);
        m_artifact2FeatureRepository = new Artifact2FeatureAssociationRepositoryImpl(m_artifactRepository, m_featureRepository, m_mockChangeNotifier, repoConfig);
        TestUtils.configureObject(m_artifact2FeatureRepository, BundleContext.class, m_mockBundleContext);
        m_distributionRepository = new DistributionRepositoryImpl(m_mockChangeNotifier, repoConfig);
        TestUtils.configureObject(m_distributionRepository, BundleContext.class, m_mockBundleContext);
        m_feature2DistributionRepository = new Feature2DistributionAssociationRepositoryImpl(m_featureRepository, m_distributionRepository, m_mockChangeNotifier, repoConfig);
        TestUtils.configureObject(m_feature2DistributionRepository, BundleContext.class, m_mockBundleContext);
        m_targetRepository = new TargetRepositoryImpl(m_mockChangeNotifier, repoConfig);
        TestUtils.configureObject(m_targetRepository, BundleContext.class, m_mockBundleContext);
        m_distribution2TargetRepository = new Distribution2TargetAssociationRepositoryImpl(m_distributionRepository, m_targetRepository, m_mockChangeNotifier, repoConfig);
        TestUtils.configureObject(m_distribution2TargetRepository, BundleContext.class, m_mockBundleContext);
        m_deploymentVersionRepository = new DeploymentVersionRepositoryImpl(m_mockChangeNotifier, repoConfig);
        TestUtils.configureObject(m_deploymentVersionRepository, BundleContext.class, m_mockBundleContext);

        m_repositoryAdmin = new RepositoryAdminImpl("testSessionID", repoConfig);

        Map<Class<? extends ObjectRepository<?>>, ObjectRepositoryImpl<?, ?>> repos = new HashMap<>();
        repos.put(ArtifactRepository.class, m_artifactRepository);
        repos.put(Artifact2FeatureAssociationRepository.class, m_artifact2FeatureRepository);
        repos.put(FeatureRepository.class, m_featureRepository);
        repos.put(Feature2DistributionAssociationRepository.class, m_feature2DistributionRepository);
        repos.put(DistributionRepository.class, m_distributionRepository);
        repos.put(Distribution2TargetAssociationRepository.class, m_distribution2TargetRepository);
        repos.put(TargetRepository.class, m_targetRepository);
        repos.put(DeploymentVersionRepository.class, m_deploymentVersionRepository);

        m_repositoryAdmin.initialize(repos);
        TestUtils.configureObject(m_repositoryAdmin, Preferences.class);
        TestUtils.configureObject(m_repositoryAdmin, PreferencesService.class);
    }
}