--- /dev/null
+/*
+ * Copyright 2005 the original author or authors.
+ *
+ * Licensed 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.wamblee.photos.model;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.TreeMap;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.wamblee.cache.Cache;
+import org.wamblee.cache.ForeverCache;
+import org.wamblee.io.FileSystemUtils;
+import org.wamblee.io.TestData;
+import org.wamblee.photos.model.filesystem.FileSystemAlbum;
+import static org.junit.Assert.*;
+
+/**
+ * Test of the file based album.
+ */
+public class AlbumTest {
+
+ private static final String ADDED_METHOD = "photoAdded";
+ private static final String REMOVED_METHOD = "photoRemoved";
+
+ private static final String TEST_RESOURCES = "src/test/resources/albumdata";
+
+ private String resourcesPath;
+ private TestData _testData;
+ private Cache _cache;
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see junit.framework.TestCase#setUp()
+ */
+
+ @Before
+ public void setUp() throws Exception {
+ _testData = new TestData(this);
+ _testData.clean();
+
+ _cache = createCache();
+ _cache.clear(); // Just to make sure we don't have any caching left from the previous
+
+ URL url = Thread.currentThread().getContextClassLoader().getResource(".");
+ String path = url.toString();
+ assertTrue(path.startsWith("file:"));
+ path = path.substring("file:".length());
+ resourcesPath = path + "../../" + TEST_RESOURCES;
+ System.out.println(resourcesPath);
+ }
+
+ private void copyDir(File aSource) {
+ FileSystemUtils.copyDir(aSource, getTestOutputDir());
+ }
+
+ protected Cache createCache() {
+ return new ForeverCache();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see junit.framework.TestCase#tearDown()
+ */
+ @After
+ public void tearDown() throws Exception {
+ // Empty
+ }
+
+ private File getTestAlbumData() {
+ File dir = new File(resourcesPath);
+ assertTrue(dir.exists());
+ return dir;
+ }
+
+ private File getTestOutputDir() {
+ return new File(_testData.getRoot(), "data");
+ }
+
+ /**
+ * Verifies that a non-existing album cannot be opened.
+ */
+ @Test
+ public void testNonExistingAlbum() {
+ File dir = new File(_testData.getRoot(), "NonExisting");
+ try {
+ Album album = new FileSystemAlbum(dir, "", _cache);
+ }
+ catch (IOException e) {
+ return; // ok
+ }
+ fail();
+ }
+
+ /**
+ * List photos in a given album. Verify that all entries are returned and
+ * that the relative paths of the photos are correct.
+ */
+ @Test
+ public void testListPhotos() throws IOException {
+ File _dir = new File(getTestAlbumData(), "Album1");
+
+ File dir = getTestOutputDir();
+ copyDir(_dir);
+ Album album = new FileSystemAlbum(dir, "/", _cache);
+
+ int nentries = album.size();
+ assertEquals(3, nentries);
+ Map<String, PhotoEntry> map = new TreeMap<String, PhotoEntry>();
+ for (int i = 0; i < nentries; i++) {
+ PhotoEntry entry = album.getEntry(i);
+ map.put(entry.getId(), entry);
+ }
+ PhotoEntry e1 = map.get("100_0179");
+ PhotoEntry e2 = map.get("100_0162");
+ PhotoEntry e3 = map.get("Nested");
+ assertNotNull(e1);
+ assertNotNull(e2);
+ assertNotNull(e3);
+ assertTrue(e1 instanceof Photo);
+ assertTrue(e2 instanceof Photo);
+ assertTrue(e3 instanceof Album);
+ Album nestedAlbum = (Album) e3;
+ assertEquals(1, nestedAlbum.size());
+ PhotoEntry e4 = nestedAlbum.getEntry(0);
+ assertEquals("mondeo", e4.getId());
+ assertTrue(e4 instanceof Photo);
+
+ // Checking access based on path
+ assertEquals(album, album.getEntry("/"));
+ assertEquals(e1, album.getEntry("/100_0179"));
+ assertEquals(e2, album.getEntry("/100_0162"));
+ assertEquals(e3, album.getEntry("/Nested"));
+ assertEquals(e4, album.getEntry("/Nested/mondeo"));
+
+ // Verify that the photos have the correct ids
+ assertEquals("100_0179", e1.getId());
+ assertEquals("100_0162", e2.getId());
+ assertEquals("Nested", e3.getId());
+ assertEquals("mondeo", e4.getId());
+
+ // Verify that the photos have the correct paths
+ assertEquals("/100_0179", e1.getPath());
+ assertEquals("/100_0162", e2.getPath());
+ assertEquals("/Nested", e3.getPath());
+ assertEquals("/Nested/mondeo", e4.getPath());
+ }
+
+ /**
+ * List the contents of an album. Verify that non JPEG files are skipped.
+ */
+ @Test
+ public void testSkipNonJpegFiles() throws IOException {
+ File _dir = new File(getTestAlbumData(), "Album2");
+
+ File dir = getTestOutputDir();
+ copyDir(_dir);
+ Album album = new FileSystemAlbum(dir, "/", _cache);
+ assertEquals(0, album.size());
+ }
+
+ /**
+ * Verify that a photo with a missing thumbnail is not listed.
+ */
+ @Test
+ public void testThumbNailMissing() throws IOException {
+ File _dir = new File(getTestAlbumData(), "AlbumMissingThumbnail");
+
+ File dir = getTestOutputDir();
+ copyDir(_dir);
+ Album album = new FileSystemAlbum(dir, "/", _cache);
+ assertEquals(0, album.size());
+ }
+
+ /**
+ * Verify that a photo with a missing fullsize photo is not listed.
+ */
+ @Test
+ public void testPhotoMissing() throws IOException {
+ File _dir = new File(getTestAlbumData(), "AlbumPhotoMissing");
+ File dir = getTestOutputDir();
+ copyDir(_dir);
+ Album album = new FileSystemAlbum(dir, "/", _cache);
+ assertEquals(0, album.size());
+ }
+
+ private InputStream getImage(File dir) throws IOException {
+ return new BufferedInputStream(new FileInputStream(dir));
+ }
+
+ /**
+ * Add a photo to the root album and verify it is added correctly and can be
+ * retrieved using a path.
+ */
+ @Test
+ public void testAddPhotoToRootAlbum() throws IOException {
+ File dir = new File(_testData.getRoot(), "AlbumNew");
+
+ assertTrue(dir.mkdir());
+ assertTrue(new File(dir, FileSystemAlbum.PHOTOS_DIR).mkdir());
+ assertTrue(new File(dir, FileSystemAlbum.THUMBNAILS_DIR).mkdir());
+
+ Album album = new FileSystemAlbum(dir, "/", _cache);
+
+ File image = new File(getTestAlbumData(), "a.jpg");
+ album.addImage("xyz", getImage(image));
+ assertTrue(album.getEntry("/xyz") != null);
+
+ Album album2 = new FileSystemAlbum(dir, "/", new ForeverCache<String, ArrayList<PhotoEntry>>());
+ assertTrue(album2.getEntry("/xyz") != null);
+ }
+
+ /**
+ * Add a photo twice, and verify that the second time an IO Exception occurs.
+ */
+ @Test
+ public void testDoublePhotoNotAllowed() throws IOException {
+ File dir = new File(_testData.getRoot(), "AlbumNew");
+
+ assertTrue(dir.mkdir());
+ assertTrue(new File(dir, FileSystemAlbum.PHOTOS_DIR).mkdir());
+ assertTrue(new File(dir, FileSystemAlbum.THUMBNAILS_DIR).mkdir());
+
+ Album album = new FileSystemAlbum(dir, "/", _cache);
+
+ File image = new File(getTestAlbumData(), "a.jpg");
+ album.addImage("xyz", getImage(image));
+ assertTrue(album.getEntry("/xyz") != null);
+
+ try {
+ album.addImage("xyz", getImage(image));
+ fail();
+ }
+ catch (IOException e) {
+ return; // ok, test succeeded.
+ }
+ }
+
+ /**
+ * Adds an album and adds a photo to it. Verifies that they are added.
+ */
+ @Test
+ public void testAddAlbum() throws IOException {
+ File dir = new File(_testData.getRoot(), "AlbumNew");
+
+ assertTrue(dir.mkdir());
+ assertTrue(new File(dir, FileSystemAlbum.PHOTOS_DIR).mkdir());
+ assertTrue(new File(dir, FileSystemAlbum.THUMBNAILS_DIR).mkdir());
+
+ Album album = new FileSystemAlbum(dir, "/", _cache);
+
+ File sub = new File(dir, "sub");
+ album.addAlbum("sub");
+ assertTrue(album.getEntry("/sub") != null);
+ assertTrue(sub.isDirectory());
+ assertTrue(new File(sub, FileSystemAlbum.PHOTOS_DIR).isDirectory());
+ assertTrue(new File(sub, FileSystemAlbum.THUMBNAILS_DIR).isDirectory());
+
+ Album album2 = new FileSystemAlbum(dir, "/", new ForeverCache<String, ArrayList<PhotoEntry>>());
+ PhotoEntry entry = album2.getEntry("/sub");
+
+ assertTrue(entry != null);
+ assertTrue(entry instanceof Album);
+ }
+
+ /**
+ * Tests that adding an album which already exists is not allowed.
+ */
+ @Test
+ public void testAddAlreadyExistingAlbum() throws IOException {
+ File dir = new File(_testData.getRoot(), "AlbumNew");
+
+ assertTrue(dir.mkdir());
+ assertTrue(new File(dir, FileSystemAlbum.PHOTOS_DIR).mkdir());
+ assertTrue(new File(dir, FileSystemAlbum.THUMBNAILS_DIR).mkdir());
+
+ Album album = new FileSystemAlbum(dir, "/", _cache);
+
+ File sub = new File(dir, "sub");
+ album.addAlbum("sub");
+ assertTrue(album.getEntry("/sub") != null);
+ assertTrue(sub.isDirectory());
+
+ try {
+ album.addAlbum("sub");
+ }
+ catch (IOException e) {
+ return; // ok.
+ }
+ }
+
+ /**
+ * Tries to remove a non-empty album and verifies the directory is not
+ * removed. Removes all photos in the album and verifies the photos have
+ * been removed. Verfies that the album can be removed after that.
+ */
+ @Test
+ public void testRemove() throws IOException {
+ File dir = getTestOutputDir();
+ File origDir = new File(getTestAlbumData(), "AlbumRemove");
+ copyDir(origDir);
+ Album album = new FileSystemAlbum(dir, "/", _cache);
+ try {
+ album.removeEntry("Nested");
+ }
+ catch (IOException e) {
+ Album nested = (Album) album.getEntry("/Nested");
+ nested.removeEntry("mondeo");
+ album.removeEntry("Nested");
+ return;
+ }
+ fail();
+ }
+}
git://wamblee.org / photos / blobdiff