org.apache.ace.obr/test/org/apache/ace/obr/storage/file/BundleFileStoreTest.java - ace - Git at Google

 /*
  * 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.obr.storage.file;

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.Arrays;
 import java.util.Dictionary;
 import java.util.Hashtable;
 import java.util.Random;
 import java.util.jar.Attributes;
 import java.util.jar.JarOutputStream;
 import java.util.jar.Manifest;
 import java.util.zip.ZipEntry;

 import org.apache.ace.obr.metadata.MetadataGenerator;
 import org.apache.ace.obr.storage.OBRFileStoreConstants;
 import org.apache.ace.test.utils.FileUtils;
 import org.apache.ace.test.utils.TestUtils;
 import org.osgi.framework.Constants;
 import org.osgi.service.cm.ConfigurationException;
 import org.osgi.service.log.LogService;
 import org.testng.annotations.AfterMethod;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;

 public class BundleFileStoreTest {

     private BundleFileStore m_bundleStore;
     private MockMetadataGenerator m_metadata;

     private File m_directory;

     private File m_bundleSubstitute1;
     private File m_bundleSubstitute1Larger;
     private File m_bundleSubstitute2;
     private File m_bundleSubstitute3;
     private File m_bundleRepositoryFile;

     @BeforeMethod(alwaysRun = true)
     protected void setUp() throws Exception {
         m_bundleStore = new BundleFileStore();

         m_directory = FileUtils.createTempFile(null);
         m_directory.mkdir();

         Dictionary<String, Object> props = new Hashtable<>();

         props.put(OBRFileStoreConstants.FILE_LOCATION_KEY, m_directory.getAbsolutePath());
         m_bundleStore.updated(props);

         // set a null object on for log
         TestUtils.configureObject(m_bundleStore, LogService.class);

         // create a mock MetadataGenerator
         m_metadata = new MockMetadataGenerator();
         TestUtils.configureObject(m_bundleStore, MetadataGenerator.class, m_metadata);

         // create some bundles to work with
         m_bundleSubstitute1 = createFileWithContent(m_directory.getAbsoluteFile(), "bundleSub1.jar", 1000);
         m_bundleSubstitute2 = createFileWithContent(m_directory.getAbsoluteFile(), "bundleSub2.jar", 2000);
         m_bundleSubstitute3 = createFileWithContent(m_directory.getAbsoluteFile(), "bundleSub3.jar", 3000);
         m_bundleRepositoryFile = createFileWithContent(m_directory.getAbsoluteFile(), "index.xml", 1000);
     }

     @AfterMethod(alwaysRun = true)
     public void tearDown() throws Exception {
         m_bundleSubstitute1.delete();
         m_bundleSubstitute2.delete();
         m_bundleSubstitute3.delete();
         m_bundleRepositoryFile.delete();
         m_directory.delete();
     }

     /**
      * Test whether the metadata is generated when getting a bundle from the repository.
      */
     @Test()
     public void getBundle() throws Exception {
         m_bundleStore.get(m_bundleSubstitute1.getName());
         assert !m_metadata.generated() : "During getting a bundle, the metadata should not be regenerated.";
     }

     /**
      * Test that the bundle store reutrns null for non-existing files.
      */
     @Test()
     public void getNonExistingBundle() throws Exception {
         assert m_bundleStore.get("blaat") == null : "Getting an non-existing file did not result in null?";
     }

     /**
      * Test whether retrieving the index.xml results in a call to the (mock) metadata generator, and the original file
      * should correspond with the retrieved file.
      */
     @Test()
     public void getRepositoryFile() throws Exception {
         InputStream newInputStream = m_bundleStore.get("index.xml");
         assert m_metadata.generated() : "During getting the repository file, the metadata should be regenerated.";

         byte[] orgContentBuffer = new byte[1000];
         newInputStream.read(orgContentBuffer);

         FileInputStream orgInputStream = new FileInputStream(m_bundleRepositoryFile);
         byte[] newContentBuffer = new byte[1000];
         orgInputStream.read(newContentBuffer);
         orgInputStream.close();

         assert Arrays.equals(orgContentBuffer, newContentBuffer) : "The original index.xml content should equal the newly retrieved content.";
     }

     /**
      * Test whether the BundleStore notices the set of bundles has changed (bundle updated), and makes a call to the
      * (mock) metadata generator.
      */
     @Test()
     public void updateBundle() throws Exception {
         m_bundleStore.get("index.xml");
         assert m_metadata.numberOfCalls() == 1 : "The MetadataGenerator should be called once";

         m_bundleSubstitute1Larger = createFileWithContent(m_directory.getAbsoluteFile(), "bundleSub1.jar", 2000);

         m_bundleStore.get("index.xml");
         assert m_metadata.numberOfCalls() == 2 : "The MetadataGenerator should be called twice";

         // test specific tear down
         m_bundleSubstitute1Larger.delete();
     }

     /**
      * Test whether the BundleStore notices the set of bundles has changed (bundle added), and makes a call to the
      * (mock) metadata generator. Also a call should be made when a bundle is replaced by another one (number of bundles
      * stay the same, but one bundle is replaced by another).
      */
     @Test()
     public void addBundle() throws Exception {
         m_bundleStore.get("index.xml");
         assert m_metadata.numberOfCalls() == 1 : "The MetadataGenerator should be called once";

         File bundleSubstituteX = createFileWithContent(m_directory.getAbsoluteFile(), "bundleSubX.jar", 2000);

         m_bundleStore.get("index.xml");
         assert m_metadata.numberOfCalls() == 2 : "The MetadataGenerator should be called twice";

         bundleSubstituteX.delete();

         File bundleSubstituteY = createFileWithContent(m_directory.getAbsoluteFile(), "bundleSubY.jar", 2000);

         m_bundleStore.get("index.xml");
         assert m_metadata.numberOfCalls() == 3 : "The MetadataGenerator should be called three times";

         // test specific tear down
         bundleSubstituteY.delete();
     }

     /**
      * Test whether the BundleStore notices the set of bundles has not changed, and thus will not make a call to the
      * (mock) metadata generator.
      */
     @Test()
     public void replaceWithSameBundle() throws Exception {
         m_bundleStore.get("bundleSub1.jar");
         assert m_metadata.numberOfCalls() == 0 : "The MetadataGenerator should not be called";

         FileInputStream inputStream = new FileInputStream(m_bundleSubstitute1);
         byte[] buffer = new byte[1000];
         inputStream.read(buffer);
         inputStream.close();
         m_bundleSubstitute1.delete();

         File newFile = new File(m_directory, "bundleSub1.jar");
         FileOutputStream outputStream = new FileOutputStream(newFile);

         outputStream.write(buffer);
         outputStream.close();

         m_bundleStore.get("bundleSub1.jar");
         assert m_metadata.numberOfCalls() == 0 : "The MetadataGenerator should still not be called";
     }

     /**
      * Test whether changing the directory where the bundles are stored, does not result in a call to the (mock)
      * metadata generator, as the metadata will only be regenerated after getting a file.
      */
     @Test()
     public void updateConfigurationWithValidConfiguration() throws Exception {
         File subDir = new File(m_directory.getAbsolutePath(), "changedDirectory");
         subDir.mkdir();

         Dictionary<String, Object> props = new Hashtable<>();

         props.put(OBRFileStoreConstants.FILE_LOCATION_KEY, subDir.getAbsolutePath());
         try {
             m_bundleStore.updated(props);
         }
         catch (ConfigurationException e) {
             assert false : "Reconfiguring directory failed, directory was '" + m_directory + "' but should be '" + subDir + "'";
         }

         assert !m_metadata.generated() : "After changing the directory, the metadata should not be regenerated.";

         // test specific tear down
         subDir.delete();
     }

     /**
      * Test whether changing the directory where the bundles are stored to something that is not a directory, this
      * should fail.
      */
     @Test()
     public void updateConfigurationWithIsNotDirectory() throws Exception {
         boolean exceptionThrown = false;

         File file = new File(m_directory.getAbsolutePath(), "file");
         file.createNewFile();

         Dictionary<String, Object> props = new Hashtable<>();

         props.put(OBRFileStoreConstants.FILE_LOCATION_KEY, file.getAbsolutePath());
         try {
             m_bundleStore.updated(props);
         }
         catch (ConfigurationException e) {
             // exception should be thrown as attempting to configure with File that is no directory
             exceptionThrown = true;
         }
         assert exceptionThrown : "Reconfiguring directory succeeded, but should fail as it is no directory";

         // test specific tear down
         file.delete();
     }

     @Test()
     public void putBundle() throws Exception {
         File bundle = createTmpResource("foo.bar", "1.0.0");
         String filePath = m_bundleStore.put(new FileInputStream(bundle), null, false);
         assert filePath.equals("foo/foo.bar-1.0.0.jar") : "Path should be 'foo/foo.bar-1.0.0.jar', was " + filePath;
         File file = new File(m_directory, filePath);
         assert file.exists();
     }

     @Test()
     public void putBundleSameDuplicate() throws Exception {
         File bundle = createTmpResource("foo.bar", "1.0.0");
         String filePath = m_bundleStore.put(new FileInputStream(bundle), null, false);
         assert filePath != null;
         String filePath2 = m_bundleStore.put(new FileInputStream(bundle), null, false);
         assert filePath2 != null;
         assert filePath2.equals(filePath);
     }

     @Test()
     public void putBundleDifferentDuplicate() throws Exception {
         File bundle = createTmpResource("foo.bar", "1.0.0", new byte[] { 1 });
         File bundle2 = createTmpResource("foo.bar", "1.0.0", new byte[] { 2 });
         String filePath = m_bundleStore.put(new FileInputStream(bundle), null, false);
         assert filePath != null;
         String filePath2 = m_bundleStore.put(new FileInputStream(bundle2), null, false);
         assert filePath2 == null;
     }

     @Test(expectedExceptions = { IOException.class }, expectedExceptionsMessageRegExp = "Not a valid bundle and no filename found.*")
     public void putBundleFail() throws Exception {
         File bundle = createTmpResource(null, "1.0.0");
         String filePath = m_bundleStore.put(new FileInputStream(bundle), null, false);
         assert filePath.equals("foo/bar/foo.bar-1.0.0.jar") : "Path should be 'foo/bar/foo.bar-1.0.0.jar', was " + filePath;
         File file = new File(m_directory, filePath);
         assert file.exists();
     }

     @Test()
     public void putRemoveArtifact() throws Exception {
         File bundle = createTmpResource(null, null);
         String filePath = m_bundleStore.put(new FileInputStream(bundle), "foo.bar-2.3.7.test1.xxx", false);
         assert filePath.equals("foo/foo.bar-2.3.7.test1.xxx");
         File file = new File(m_directory, filePath);
         assert file.exists();
     }

     @Test()
     public void putArtifactDefaultVersion() throws Exception {
         File bundle = createTmpResource(null, null);
         String filePath = m_bundleStore.put(new FileInputStream(bundle), "foo.bar.xxx", false);
         assert filePath.equals("foo/foo.bar.xxx");
         File file = new File(m_directory, filePath);
         assert file.exists();
     }

     @Test()
     public void putArtifactMavenVersion() throws Exception {
         File bundle = createTmpResource(null, null);
         String filePath = m_bundleStore.put(new FileInputStream(bundle), "foo.bar-2.3.7-test1.xxx", false);
         assert filePath.equals("foo/foo.bar-2.3.7-test1.xxx");
         File file = new File(m_directory, filePath);
         assert file.exists();
     }

     @Test(expectedExceptions = { IOException.class }, expectedExceptionsMessageRegExp = "Not a valid bundle and no filename found.*")
     public void putArtifactFail1() throws Exception {
         File bundle = createTmpResource(null, null);
         m_bundleStore.put(new FileInputStream(bundle), null, false);
     }

     @Test(expectedExceptions = { IOException.class }, expectedExceptionsMessageRegExp = "Not a valid bundle and no filename found.*")
     public void putArtifactFail2() throws Exception {
         File bundle = createTmpResource(null, null);
         m_bundleStore.put(new FileInputStream(bundle), "", false);
     }

     @Test()
     public void removeBundle() throws Exception {
         File bundle = createTmpResource("foo.bar", "1.0.0");
         String filePath = m_bundleStore.put(new FileInputStream(bundle), null, false);
         File file = new File(m_directory, filePath);
         assert file.exists();
         assert m_bundleStore.remove(filePath);
         assert !file.exists();
     }

     @Test()
     public void removeBundleFaill() throws Exception {
         File file = new File(m_directory, "no/such/file");
         assert !file.exists();
         assert !m_bundleStore.remove("no/such/file");
     }

     @Test()
     public void removeArtifact() throws Exception {
         File bundle = createTmpResource(null, null);
         String filePath = m_bundleStore.put(new FileInputStream(bundle), "foo.bar-2.3.7.test1.xxx", false);
         assert filePath.equals("foo/foo.bar-2.3.7.test1.xxx");
         File file = new File(m_directory, filePath);
         assert file.exists();
         assert m_bundleStore.remove("foo/foo.bar-2.3.7.test1.xxx");
         assert !file.exists();
     }

     /**
      * Test whether not configuring the directory (so retrieving the directory returns null), results in a
      * ConfigurationException. Updating with null as dictionary should only clean up things, and nothing else.
      */
     @Test()
     public void updateConfigurationWithNull() throws Exception {
         boolean exceptionThrown = false;

         Dictionary<String, Object> props = new Hashtable<>();

         try {
             m_bundleStore.updated(props);
         }
         catch (ConfigurationException e) {
             exceptionThrown = true;
         }
         assert exceptionThrown : "Reconfiguring directory succeeded but should fail, as property is supposed to be missing";
         assert !m_metadata.generated() : "After changing the directory, the metadata should not be regenerated.";

         exceptionThrown = false;
         try {
             m_bundleStore.updated(null);
         }
         catch (ConfigurationException e) {
             exceptionThrown = true;
         }
         assert !exceptionThrown : "Reconfiguring succeeded as the bundle should only do the clean up, and not throw exception";
         assert !m_metadata.generated() : "After changing the directory, the metadata should not be regenerated.";
     }

     /**
      * Test whether not configuring the directory (so retrieving the directory returns null), results in a
      * ConfigurationException.
      */
     @Test()
     public void updateConfigurationWithSameDirectory() throws Exception {

         Dictionary<String, Object> props = new Hashtable<>();

         props.put(OBRFileStoreConstants.FILE_LOCATION_KEY, m_directory.getAbsolutePath());
         try {
             m_bundleStore.updated(props);
         }
         catch (ConfigurationException e) {
             assert false : "Nothing should happen, as the directory did not change";
         }
         assert !m_metadata.generated() : "After changing the directory, the metadata should not be regenerated.";
     }

     private File createTmpResource(String symbolicName, String version) throws IOException {
         return createTmpResource(symbolicName, version, null);
     }

     private File createTmpResource(String symbolicName, String version, byte[] data) throws IOException {
         File tmpFile = File.createTempFile("tmpbundle-", "jar");
         tmpFile.deleteOnExit();

         Manifest manifest = new Manifest();
         manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
         if (symbolicName != null) {
             manifest.getMainAttributes().putValue(Constants.BUNDLE_SYMBOLICNAME, symbolicName);
         }
         if (version != null) {
             manifest.getMainAttributes().putValue(Constants.BUNDLE_VERSION, version);
         }
         JarOutputStream target = new JarOutputStream(new FileOutputStream(tmpFile), manifest);
         if (data != null) {
             target.putNextEntry(new ZipEntry("data"));
             target.write(data, 0, data.length);
         }
         target.close();
         return tmpFile;
     }

     private File createFileWithContent(File baseDir, String filename, int size) throws IOException {
         OutputStream fileOut = null;
         File file = new File(baseDir, filename);
         try {
             fileOut = new FileOutputStream(file);
             byte[] byteArray = new byte[size];
             Random randomContentCreator = new Random();
             randomContentCreator.nextBytes(byteArray);
             fileOut.write(byteArray);
             return file;
         }
         finally {
             try {
                 if (fileOut != null) {
                     fileOut.close();
                 }
             }
             catch (IOException e) {
                 throw e;
             }
         }
     }
 }
	/*
	* 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.obr.storage.file;

	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.util.Arrays;
	import java.util.Dictionary;
	import java.util.Hashtable;
	import java.util.Random;
	import java.util.jar.Attributes;
	import java.util.jar.JarOutputStream;
	import java.util.jar.Manifest;
	import java.util.zip.ZipEntry;

	import org.apache.ace.obr.metadata.MetadataGenerator;
	import org.apache.ace.obr.storage.OBRFileStoreConstants;
	import org.apache.ace.test.utils.FileUtils;
	import org.apache.ace.test.utils.TestUtils;
	import org.osgi.framework.Constants;
	import org.osgi.service.cm.ConfigurationException;
	import org.osgi.service.log.LogService;
	import org.testng.annotations.AfterMethod;
	import org.testng.annotations.BeforeMethod;
	import org.testng.annotations.Test;

	public class BundleFileStoreTest {

	private BundleFileStore m_bundleStore;
	private MockMetadataGenerator m_metadata;

	private File m_directory;

	private File m_bundleSubstitute1;
	private File m_bundleSubstitute1Larger;
	private File m_bundleSubstitute2;
	private File m_bundleSubstitute3;
	private File m_bundleRepositoryFile;

	@BeforeMethod(alwaysRun = true)
	protected void setUp() throws Exception {
	m_bundleStore = new BundleFileStore();

	m_directory = FileUtils.createTempFile(null);
	m_directory.mkdir();

	Dictionary<String, Object> props = new Hashtable<>();

	props.put(OBRFileStoreConstants.FILE_LOCATION_KEY, m_directory.getAbsolutePath());
	m_bundleStore.updated(props);

	// set a null object on for log
	TestUtils.configureObject(m_bundleStore, LogService.class);

	// create a mock MetadataGenerator
	m_metadata = new MockMetadataGenerator();
	TestUtils.configureObject(m_bundleStore, MetadataGenerator.class, m_metadata);

	// create some bundles to work with
	m_bundleSubstitute1 = createFileWithContent(m_directory.getAbsoluteFile(), "bundleSub1.jar", 1000);
	m_bundleSubstitute2 = createFileWithContent(m_directory.getAbsoluteFile(), "bundleSub2.jar", 2000);
	m_bundleSubstitute3 = createFileWithContent(m_directory.getAbsoluteFile(), "bundleSub3.jar", 3000);
	m_bundleRepositoryFile = createFileWithContent(m_directory.getAbsoluteFile(), "index.xml", 1000);
	}

	@AfterMethod(alwaysRun = true)
	public void tearDown() throws Exception {
	m_bundleSubstitute1.delete();
	m_bundleSubstitute2.delete();
	m_bundleSubstitute3.delete();
	m_bundleRepositoryFile.delete();
	m_directory.delete();
	}

	/**
	* Test whether the metadata is generated when getting a bundle from the repository.
	*/
	@Test()
	public void getBundle() throws Exception {
	m_bundleStore.get(m_bundleSubstitute1.getName());
	assert !m_metadata.generated() : "During getting a bundle, the metadata should not be regenerated.";
	}

	/**
	* Test that the bundle store reutrns null for non-existing files.
	*/
	@Test()
	public void getNonExistingBundle() throws Exception {
	assert m_bundleStore.get("blaat") == null : "Getting an non-existing file did not result in null?";
	}

	/**
	* Test whether retrieving the index.xml results in a call to the (mock) metadata generator, and the original file
	* should correspond with the retrieved file.
	*/
	@Test()
	public void getRepositoryFile() throws Exception {
	InputStream newInputStream = m_bundleStore.get("index.xml");
	assert m_metadata.generated() : "During getting the repository file, the metadata should be regenerated.";

	byte[] orgContentBuffer = new byte[1000];
	newInputStream.read(orgContentBuffer);

	FileInputStream orgInputStream = new FileInputStream(m_bundleRepositoryFile);
	byte[] newContentBuffer = new byte[1000];
	orgInputStream.read(newContentBuffer);
	orgInputStream.close();

	assert Arrays.equals(orgContentBuffer, newContentBuffer) : "The original index.xml content should equal the newly retrieved content.";
	}

	/**
	* Test whether the BundleStore notices the set of bundles has changed (bundle updated), and makes a call to the
	* (mock) metadata generator.
	*/
	@Test()
	public void updateBundle() throws Exception {
	m_bundleStore.get("index.xml");
	assert m_metadata.numberOfCalls() == 1 : "The MetadataGenerator should be called once";

	m_bundleSubstitute1Larger = createFileWithContent(m_directory.getAbsoluteFile(), "bundleSub1.jar", 2000);

	m_bundleStore.get("index.xml");
	assert m_metadata.numberOfCalls() == 2 : "The MetadataGenerator should be called twice";

	// test specific tear down
	m_bundleSubstitute1Larger.delete();
	}

	/**
	* Test whether the BundleStore notices the set of bundles has changed (bundle added), and makes a call to the
	* (mock) metadata generator. Also a call should be made when a bundle is replaced by another one (number of bundles
	* stay the same, but one bundle is replaced by another).
	*/
	@Test()
	public void addBundle() throws Exception {
	m_bundleStore.get("index.xml");
	assert m_metadata.numberOfCalls() == 1 : "The MetadataGenerator should be called once";

	File bundleSubstituteX = createFileWithContent(m_directory.getAbsoluteFile(), "bundleSubX.jar", 2000);

	m_bundleStore.get("index.xml");
	assert m_metadata.numberOfCalls() == 2 : "The MetadataGenerator should be called twice";

	bundleSubstituteX.delete();

	File bundleSubstituteY = createFileWithContent(m_directory.getAbsoluteFile(), "bundleSubY.jar", 2000);

	m_bundleStore.get("index.xml");
	assert m_metadata.numberOfCalls() == 3 : "The MetadataGenerator should be called three times";

	// test specific tear down
	bundleSubstituteY.delete();
	}

	/**
	* Test whether the BundleStore notices the set of bundles has not changed, and thus will not make a call to the
	* (mock) metadata generator.
	*/
	@Test()
	public void replaceWithSameBundle() throws Exception {
	m_bundleStore.get("bundleSub1.jar");
	assert m_metadata.numberOfCalls() == 0 : "The MetadataGenerator should not be called";

	FileInputStream inputStream = new FileInputStream(m_bundleSubstitute1);
	byte[] buffer = new byte[1000];
	inputStream.read(buffer);
	inputStream.close();
	m_bundleSubstitute1.delete();

	File newFile = new File(m_directory, "bundleSub1.jar");
	FileOutputStream outputStream = new FileOutputStream(newFile);

	outputStream.write(buffer);
	outputStream.close();

	m_bundleStore.get("bundleSub1.jar");
	assert m_metadata.numberOfCalls() == 0 : "The MetadataGenerator should still not be called";
	}

	/**
	* Test whether changing the directory where the bundles are stored, does not result in a call to the (mock)
	* metadata generator, as the metadata will only be regenerated after getting a file.
	*/
	@Test()
	public void updateConfigurationWithValidConfiguration() throws Exception {
	File subDir = new File(m_directory.getAbsolutePath(), "changedDirectory");
	subDir.mkdir();

	Dictionary<String, Object> props = new Hashtable<>();

	props.put(OBRFileStoreConstants.FILE_LOCATION_KEY, subDir.getAbsolutePath());
	try {
	m_bundleStore.updated(props);
	}
	catch (ConfigurationException e) {
	assert false : "Reconfiguring directory failed, directory was '" + m_directory + "' but should be '" + subDir + "'";
	}

	assert !m_metadata.generated() : "After changing the directory, the metadata should not be regenerated.";

	// test specific tear down
	subDir.delete();
	}

	/**
	* Test whether changing the directory where the bundles are stored to something that is not a directory, this
	* should fail.
	*/
	@Test()
	public void updateConfigurationWithIsNotDirectory() throws Exception {
	boolean exceptionThrown = false;

	File file = new File(m_directory.getAbsolutePath(), "file");
	file.createNewFile();

	Dictionary<String, Object> props = new Hashtable<>();

	props.put(OBRFileStoreConstants.FILE_LOCATION_KEY, file.getAbsolutePath());
	try {
	m_bundleStore.updated(props);
	}
	catch (ConfigurationException e) {
	// exception should be thrown as attempting to configure with File that is no directory
	exceptionThrown = true;
	}
	assert exceptionThrown : "Reconfiguring directory succeeded, but should fail as it is no directory";

	// test specific tear down
	file.delete();
	}

	@Test()
	public void putBundle() throws Exception {
	File bundle = createTmpResource("foo.bar", "1.0.0");
	String filePath = m_bundleStore.put(new FileInputStream(bundle), null, false);
	assert filePath.equals("foo/foo.bar-1.0.0.jar") : "Path should be 'foo/foo.bar-1.0.0.jar', was " + filePath;
	File file = new File(m_directory, filePath);
	assert file.exists();
	}

	@Test()
	public void putBundleSameDuplicate() throws Exception {
	File bundle = createTmpResource("foo.bar", "1.0.0");
	String filePath = m_bundleStore.put(new FileInputStream(bundle), null, false);
	assert filePath != null;
	String filePath2 = m_bundleStore.put(new FileInputStream(bundle), null, false);
	assert filePath2 != null;
	assert filePath2.equals(filePath);
	}

	@Test()
	public void putBundleDifferentDuplicate() throws Exception {
	File bundle = createTmpResource("foo.bar", "1.0.0", new byte[] { 1 });
	File bundle2 = createTmpResource("foo.bar", "1.0.0", new byte[] { 2 });
	String filePath = m_bundleStore.put(new FileInputStream(bundle), null, false);
	assert filePath != null;
	String filePath2 = m_bundleStore.put(new FileInputStream(bundle2), null, false);
	assert filePath2 == null;
	}

	@Test(expectedExceptions = { IOException.class }, expectedExceptionsMessageRegExp = "Not a valid bundle and no filename found.*")
	public void putBundleFail() throws Exception {
	File bundle = createTmpResource(null, "1.0.0");
	String filePath = m_bundleStore.put(new FileInputStream(bundle), null, false);
	assert filePath.equals("foo/bar/foo.bar-1.0.0.jar") : "Path should be 'foo/bar/foo.bar-1.0.0.jar', was " + filePath;
	File file = new File(m_directory, filePath);
	assert file.exists();
	}

	@Test()
	public void putRemoveArtifact() throws Exception {
	File bundle = createTmpResource(null, null);
	String filePath = m_bundleStore.put(new FileInputStream(bundle), "foo.bar-2.3.7.test1.xxx", false);
	assert filePath.equals("foo/foo.bar-2.3.7.test1.xxx");
	File file = new File(m_directory, filePath);
	assert file.exists();
	}

	@Test()
	public void putArtifactDefaultVersion() throws Exception {
	File bundle = createTmpResource(null, null);
	String filePath = m_bundleStore.put(new FileInputStream(bundle), "foo.bar.xxx", false);
	assert filePath.equals("foo/foo.bar.xxx");
	File file = new File(m_directory, filePath);
	assert file.exists();
	}

	@Test()
	public void putArtifactMavenVersion() throws Exception {
	File bundle = createTmpResource(null, null);
	String filePath = m_bundleStore.put(new FileInputStream(bundle), "foo.bar-2.3.7-test1.xxx", false);
	assert filePath.equals("foo/foo.bar-2.3.7-test1.xxx");
	File file = new File(m_directory, filePath);
	assert file.exists();
	}

	@Test(expectedExceptions = { IOException.class }, expectedExceptionsMessageRegExp = "Not a valid bundle and no filename found.*")
	public void putArtifactFail1() throws Exception {
	File bundle = createTmpResource(null, null);
	m_bundleStore.put(new FileInputStream(bundle), null, false);
	}

	@Test(expectedExceptions = { IOException.class }, expectedExceptionsMessageRegExp = "Not a valid bundle and no filename found.*")
	public void putArtifactFail2() throws Exception {
	File bundle = createTmpResource(null, null);
	m_bundleStore.put(new FileInputStream(bundle), "", false);
	}

	@Test()
	public void removeBundle() throws Exception {
	File bundle = createTmpResource("foo.bar", "1.0.0");
	String filePath = m_bundleStore.put(new FileInputStream(bundle), null, false);
	File file = new File(m_directory, filePath);
	assert file.exists();
	assert m_bundleStore.remove(filePath);
	assert !file.exists();
	}

	@Test()
	public void removeBundleFaill() throws Exception {
	File file = new File(m_directory, "no/such/file");
	assert !file.exists();
	assert !m_bundleStore.remove("no/such/file");
	}

	@Test()
	public void removeArtifact() throws Exception {
	File bundle = createTmpResource(null, null);
	String filePath = m_bundleStore.put(new FileInputStream(bundle), "foo.bar-2.3.7.test1.xxx", false);
	assert filePath.equals("foo/foo.bar-2.3.7.test1.xxx");
	File file = new File(m_directory, filePath);
	assert file.exists();
	assert m_bundleStore.remove("foo/foo.bar-2.3.7.test1.xxx");
	assert !file.exists();
	}

	/**
	* Test whether not configuring the directory (so retrieving the directory returns null), results in a
	* ConfigurationException. Updating with null as dictionary should only clean up things, and nothing else.
	*/
	@Test()
	public void updateConfigurationWithNull() throws Exception {
	boolean exceptionThrown = false;

	Dictionary<String, Object> props = new Hashtable<>();

	try {
	m_bundleStore.updated(props);
	}
	catch (ConfigurationException e) {
	exceptionThrown = true;
	}
	assert exceptionThrown : "Reconfiguring directory succeeded but should fail, as property is supposed to be missing";
	assert !m_metadata.generated() : "After changing the directory, the metadata should not be regenerated.";

	exceptionThrown = false;
	try {
	m_bundleStore.updated(null);
	}
	catch (ConfigurationException e) {
	exceptionThrown = true;
	}
	assert !exceptionThrown : "Reconfiguring succeeded as the bundle should only do the clean up, and not throw exception";
	assert !m_metadata.generated() : "After changing the directory, the metadata should not be regenerated.";
	}

	/**
	* Test whether not configuring the directory (so retrieving the directory returns null), results in a
	* ConfigurationException.
	*/
	@Test()
	public void updateConfigurationWithSameDirectory() throws Exception {

	Dictionary<String, Object> props = new Hashtable<>();

	props.put(OBRFileStoreConstants.FILE_LOCATION_KEY, m_directory.getAbsolutePath());
	try {
	m_bundleStore.updated(props);
	}
	catch (ConfigurationException e) {
	assert false : "Nothing should happen, as the directory did not change";
	}
	assert !m_metadata.generated() : "After changing the directory, the metadata should not be regenerated.";
	}

	private File createTmpResource(String symbolicName, String version) throws IOException {
	return createTmpResource(symbolicName, version, null);
	}

	private File createTmpResource(String symbolicName, String version, byte[] data) throws IOException {
	File tmpFile = File.createTempFile("tmpbundle-", "jar");
	tmpFile.deleteOnExit();

	Manifest manifest = new Manifest();
	manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
	if (symbolicName != null) {
	manifest.getMainAttributes().putValue(Constants.BUNDLE_SYMBOLICNAME, symbolicName);
	}
	if (version != null) {
	manifest.getMainAttributes().putValue(Constants.BUNDLE_VERSION, version);
	}
	JarOutputStream target = new JarOutputStream(new FileOutputStream(tmpFile), manifest);
	if (data != null) {
	target.putNextEntry(new ZipEntry("data"));
	target.write(data, 0, data.length);
	}
	target.close();
	return tmpFile;
	}

	private File createFileWithContent(File baseDir, String filename, int size) throws IOException {
	OutputStream fileOut = null;
	File file = new File(baseDir, filename);
	try {
	fileOut = new FileOutputStream(file);
	byte[] byteArray = new byte[size];
	Random randomContentCreator = new Random();
	randomContentCreator.nextBytes(byteArray);
	fileOut.write(byteArray);
	return file;
	}
	finally {
	try {
	if (fileOut != null) {
	fileOut.close();
	}
	}
	catch (IOException e) {
	throw e;
	}
	}
	}
	}