source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.repository.content;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.archiva.common.filelock.DefaultFileLockManager;
  23 import org.apache.commons.io.IOUtils;
  24 import org.junit.After;
  25 import org.junit.Before;
  26 import org.junit.Test;
  27
  28 import java.io.IOException;
  29 import java.io.InputStream;
  30 import java.io.OutputStream;
  31 import java.nio.file.Files;
  32 import java.nio.file.Path;
  33
  34 import static org.junit.Assert.*;
  35
  36 public class FilesystemStorageTest {
  37
  38     private FilesystemStorage fsStorage;
  39     private FilesystemAsset file1Asset;
  40     private FilesystemAsset dir1Asset;
  41     private Path baseDir;
  42     private Path file1;
  43     private Path dir1;
  44
  45     @Before
  46     public void init() throws IOException {
  47         baseDir = Files.createTempDirectory("FsStorageTest");
  48         DefaultFileLockManager fl = new DefaultFileLockManager();
  49         fsStorage = new FilesystemStorage(baseDir,fl);
  50         Files.createDirectories(baseDir.resolve("dir1"));
  51         Files.createDirectories(baseDir.resolve("dir2"));
  52         file1 = Files.createFile(baseDir.resolve("dir1/testfile1.dat"));
  53         dir1 = Files.createDirectories(baseDir.resolve("dir1/testdir"));
  54         file1Asset = new FilesystemAsset("/dir1/testfile1.dat", file1);
  55         dir1Asset = new FilesystemAsset("/dir1/testdir", dir1);
  56     }
  57
  58     private class StringResult {
  59         public String getData() {
  60             return data;
  61         }
  62
  63         public void setData(String data) {
  64             this.data = data;
  65         }
  66
  67         String data;
  68     }
  69
  70
  71     @After
  72     public void cleanup() {
  73         try {
  74             Files.deleteIfExists(file1);
  75         } catch (IOException e) {
  76             e.printStackTrace();
  77         }
  78         try {
  79             Files.deleteIfExists(dir1);
  80         } catch (IOException e) {
  81             e.printStackTrace();
  82         }
  83         try {
  84             Files.deleteIfExists(baseDir.resolve("dir1"));
  85         } catch (IOException e) {
  86             e.printStackTrace();
  87         }
  88         try {
  89             Files.deleteIfExists(baseDir.resolve("dir2"));
  90         } catch (IOException e) {
  91             e.printStackTrace();
  92         }
  93         try {
  94             Files.deleteIfExists(baseDir);
  95         } catch (IOException e) {
  96             e.printStackTrace();
  97         }
  98     }
  99
 100
 101
 102
 103     @Test
 104     public void consumeData() throws IOException {
 105         try(OutputStream os = Files.newOutputStream(file1)) {
 106             IOUtils.write("abcdefghijkl", os, "ASCII");
 107         }
 108         StringResult result = new StringResult();
 109         fsStorage.consumeData(file1Asset, is -> consume(is, result), false );
 110         assertEquals("abcdefghijkl" ,result.getData());
 111     }
 112
 113     private void consume(InputStream is, StringResult result) {
 114         try {
 115             result.setData(IOUtils.toString(is, "ASCII"));
 116         } catch (IOException e) {
 117             e.printStackTrace();
 118         }
 119     }
 120
 121
 122     @Test
 123     public void getAsset() {
 124         StorageAsset asset = fsStorage.getAsset("/dir1/testfile1.dat");
 125         assertEquals(file1, asset.getFilePath());
 126     }
 127
 128     @Test
 129     public void addAsset() {
 130         StorageAsset newAsset = fsStorage.addAsset("dir2/test", false);
 131         assertNotNull(newAsset);
 132         assertFalse(newAsset.isContainer());
 133         assertFalse(newAsset.exists());
 134
 135         StorageAsset newDirAsset = fsStorage.addAsset("/dir2/testdir2", true);
 136         assertNotNull(newDirAsset);
 137         assertTrue(newDirAsset.isContainer());
 138         assertFalse(newDirAsset.exists());
 139     }
 140
 141     @Test
 142     public void removeAsset() throws IOException {
 143         assertTrue(Files.exists(file1));
 144         fsStorage.removeAsset(file1Asset);
 145         assertFalse(Files.exists(file1));
 146
 147         assertTrue(Files.exists(dir1));
 148         fsStorage.removeAsset(dir1Asset);
 149         assertFalse(Files.exists(dir1));
 150     }
 151
 152     @Test
 153     public void moveAsset() throws IOException {
 154         Path newFile=null;
 155         Path newDir=null;
 156         try {
 157             assertTrue(Files.exists(file1));
 158             try (OutputStream os = Files.newOutputStream(file1)) {
 159                 IOUtils.write("testakdkkdkdkdk", os, "ASCII");
 160             }
 161             long fileSize = Files.size(file1);
 162             fsStorage.moveAsset(file1Asset, "/dir2/testfile2.dat");
 163             assertFalse(Files.exists(file1));
 164             newFile = baseDir.resolve("dir2/testfile2.dat");
 165             assertTrue(Files.exists(newFile));
 166             assertEquals(fileSize, Files.size(newFile));
 167
 168
 169             assertTrue(Files.exists(dir1));
 170             newDir = baseDir.resolve("dir2/testdir2");
 171             fsStorage.moveAsset(dir1Asset, "dir2/testdir2");
 172             assertFalse(Files.exists(dir1));
 173             assertTrue(Files.exists(newDir));
 174         } finally {
 175             if (newFile!=null) Files.deleteIfExists(newFile);
 176             if (newDir!=null) Files.deleteIfExists(newDir);
 177         }
 178     }
 179
 180     @Test
 181     public void copyAsset() throws IOException {
 182         Path newFile=null;
 183         Path newDir=null;
 184         try {
 185             assertTrue(Files.exists(file1));
 186             try (OutputStream os = Files.newOutputStream(file1)) {
 187                 IOUtils.write("testakdkkdkdkdk", os, "ASCII");
 188             }
 189             long fileSize = Files.size(file1);
 190             fsStorage.copyAsset(file1Asset, "/dir2/testfile2.dat");
 191             assertTrue(Files.exists(file1));
 192             assertEquals(fileSize, Files.size(file1));
 193             newFile = baseDir.resolve("dir2/testfile2.dat");
 194             assertTrue(Files.exists(newFile));
 195             assertEquals(fileSize, Files.size(newFile));
 196
 197
 198             assertTrue(Files.exists(dir1));
 199             newDir = baseDir.resolve("dir2/testdir2");
 200             fsStorage.copyAsset(dir1Asset, "dir2/testdir2");
 201             assertTrue(Files.exists(dir1));
 202             assertTrue(Files.exists(newDir));
 203         } finally {
 204             if (newFile!=null) Files.deleteIfExists(newFile);
 205             if (newDir!=null) Files.deleteIfExists(newDir);
 206         }
 207     }
 208 }