/**
* Check uploading files and create attachments
*
* @throws Exception
*/
@Test
public void testCreateAttachment() throws Exception {
List<MultipartFile> files = new ArrayList<>();
files.add(multipartFile);
Mockito.when(attachmentFactory.newAttachment()).thenReturn(null);
attachmentService.setAttachment(new Attachment());
attachmentService.setMessageResponse(new MessageResponse());
MessageResponse messageResponse = attachmentService.createAttachment(files);
Mockito.verify(attachmentDao, Mockito.times(1)).createAttachments(argumentCaptor.capture());
Attachment attachment = argumentCaptor.getValue().get(0);
boolean isExistPreview = Files.exists(Paths.get(storagePath + attachment.getPreviewPath()));
boolean isExistImage = Files.exists(Paths.get(storagePath + attachment.getFilePathInStorage()));
Files.delete(Paths.get(storagePath + attachment.getPreviewPath()));
Files.delete(Paths.get(storagePath + attachment.getFilePathInStorage()));
Assert.assertTrue(
attachment.getMimeType().equals("image/png")
&& messageResponse.getCode() == 0
&& isExistPreview
&& isExistImage);
}
@After
public void tearDown() throws Exception {
// Удаляем тестовый фаил
Files.delete(Paths.get(pathTempFile));
// Удаляем тестовые папки и файлы
Files.walkFileTree(
Paths.get(storagePath),
new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
throws IOException {
Files.delete(file);
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
Files.delete(dir);
return FileVisitResult.CONTINUE;
}
});
}
/** Check that a cancelled key will never be queued */
static void testCancel(Path dir) throws IOException {
System.out.println("-- Cancel --");
try (WatchService watcher = FileSystems.getDefault().newWatchService()) {
System.out.format("register %s for events\n", dir);
WatchKey myKey = dir.register(watcher, new WatchEvent.Kind<?>[] {ENTRY_CREATE});
checkKey(myKey, dir);
System.out.println("cancel key");
myKey.cancel();
// create a file in the directory
Path file = dir.resolve("mars");
System.out.format("create: %s\n", file);
Files.createFile(file);
// poll for keys - there will be none
System.out.println("poll...");
try {
WatchKey key = watcher.poll(3000, TimeUnit.MILLISECONDS);
if (key != null) throw new RuntimeException("key should not be queued");
} catch (InterruptedException x) {
throw new RuntimeException(x);
}
// done
Files.delete(file);
System.out.println("OKAY");
}
}
public static void remove() {
Long id = Long.valueOf(params.get("id"));
Files files = Files.findById(id);
if (files.image.getFile().exists()) {
files.image.getFile().delete();
}
files.delete();
renderText("");
}
public void purgeUnusedTempPartitions(TxLog txLog) throws JournalException {
final Tx tx = new Tx();
final String lagPartitionName =
hasIrregularPartition() ? getIrregularPartition().getName() : null;
File[] files =
getLocation()
.listFiles(
new FileFilter() {
public boolean accept(File f) {
return f.isDirectory()
&& f.getName().startsWith(Constants.TEMP_DIRECTORY_PREFIX)
&& (lagPartitionName == null || !lagPartitionName.equals(f.getName()));
}
});
if (files != null) {
Arrays.sort(files);
for (int i = 0; i < files.length; i++) {
if (!txLog.isEmpty()) {
txLog.head(tx);
if (files[i].getName().equals(tx.lagName)) {
continue;
}
}
// get exclusive lock
Lock lock = LockManager.lockExclusive(files[i]);
try {
if (lock != null && lock.isValid()) {
LOGGER.trace("Purging : %s", files[i]);
if (!Files.delete(files[i])) {
LOGGER.info("Could not purge: %s", files[i]);
}
} else {
LOGGER.trace("Partition in use: %s", files[i]);
}
} finally {
LockManager.release(lock);
}
}
}
}
/** Check that deleting a registered directory causes the key to be cancelled and queued. */
static void testAutomaticCancel(Path dir) throws IOException {
System.out.println("-- Automatic Cancel --");
Path subdir = Files.createDirectory(dir.resolve("bar"));
try (WatchService watcher = FileSystems.getDefault().newWatchService()) {
System.out.format("register %s for events\n", subdir);
WatchKey myKey =
subdir.register(
watcher, new WatchEvent.Kind<?>[] {ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY});
System.out.format("delete: %s\n", subdir);
Files.delete(subdir);
takeExpectedKey(watcher, myKey);
System.out.println("reset key");
if (myKey.reset()) throw new RuntimeException("Key was not cancelled");
if (myKey.isValid()) throw new RuntimeException("Key is still valid");
System.out.println("OKAY");
}
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
Path path = null;
String message;
try {
path = Paths.get(req.getParameter("path"));
if (Files.isDirectory(path)) {
deleteDirectory(path);
} else {
Files.delete(path);
}
message = path.toString() + " deleted";
} catch (FileSystemException e) {
message = "Error delete file";
} catch (NullPointerException e) {
message = "Error delete file";
path = Paths.get("/");
}
req.setAttribute("message", message.replace("\\", "/"));
req.getRequestDispatcher("/dir/view?path=" + path.getParent()).forward(req, resp);
}
/** Simple test of each of the standard events */
static void testEvents(Path dir) throws IOException {
System.out.println("-- Standard Events --");
FileSystem fs = FileSystems.getDefault();
Path name = fs.getPath("foo");
try (WatchService watcher = fs.newWatchService()) {
// --- ENTRY_CREATE ---
// register for event
System.out.format("register %s for ENTRY_CREATE\n", dir);
WatchKey myKey = dir.register(watcher, new WatchEvent.Kind<?>[] {ENTRY_CREATE});
checkKey(myKey, dir);
// create file
Path file = dir.resolve("foo");
System.out.format("create %s\n", file);
Files.createFile(file);
// remove key and check that we got the ENTRY_CREATE event
takeExpectedKey(watcher, myKey);
checkExpectedEvent(myKey.pollEvents(), StandardWatchEventKinds.ENTRY_CREATE, name);
System.out.println("reset key");
if (!myKey.reset()) throw new RuntimeException("key has been cancalled");
System.out.println("OKAY");
// --- ENTRY_DELETE ---
System.out.format("register %s for ENTRY_DELETE\n", dir);
WatchKey deleteKey = dir.register(watcher, new WatchEvent.Kind<?>[] {ENTRY_DELETE});
if (deleteKey != myKey) throw new RuntimeException("register did not return existing key");
checkKey(deleteKey, dir);
System.out.format("delete %s\n", file);
Files.delete(file);
takeExpectedKey(watcher, myKey);
checkExpectedEvent(myKey.pollEvents(), StandardWatchEventKinds.ENTRY_DELETE, name);
System.out.println("reset key");
if (!myKey.reset()) throw new RuntimeException("key has been cancalled");
System.out.println("OKAY");
// create the file for the next test
Files.createFile(file);
// --- ENTRY_MODIFY ---
System.out.format("register %s for ENTRY_MODIFY\n", dir);
WatchKey newKey = dir.register(watcher, new WatchEvent.Kind<?>[] {ENTRY_MODIFY});
if (newKey != myKey) throw new RuntimeException("register did not return existing key");
checkKey(newKey, dir);
System.out.format("update: %s\n", file);
try (OutputStream out = Files.newOutputStream(file, StandardOpenOption.APPEND)) {
out.write("I am a small file".getBytes("UTF-8"));
}
// remove key and check that we got the ENTRY_MODIFY event
takeExpectedKey(watcher, myKey);
checkExpectedEvent(myKey.pollEvents(), StandardWatchEventKinds.ENTRY_MODIFY, name);
System.out.println("OKAY");
// done
Files.delete(file);
}
}
/**
* Test that directory can be registered with more than one watch service and that events don't
* interfere with each other
*/
static void testTwoWatchers(Path dir) throws IOException {
System.out.println("-- Two watchers test --");
FileSystem fs = FileSystems.getDefault();
WatchService watcher1 = fs.newWatchService();
WatchService watcher2 = fs.newWatchService();
try {
Path name1 = fs.getPath("gus1");
Path name2 = fs.getPath("gus2");
// create gus1
Path file1 = dir.resolve(name1);
System.out.format("create %s\n", file1);
Files.createFile(file1);
// register with both watch services (different events)
System.out.println("register for different events");
WatchKey key1 = dir.register(watcher1, new WatchEvent.Kind<?>[] {ENTRY_CREATE});
WatchKey key2 = dir.register(watcher2, new WatchEvent.Kind<?>[] {ENTRY_DELETE});
if (key1 == key2) throw new RuntimeException("keys should be different");
// create gus2
Path file2 = dir.resolve(name2);
System.out.format("create %s\n", file2);
Files.createFile(file2);
// check that key1 got ENTRY_CREATE
takeExpectedKey(watcher1, key1);
checkExpectedEvent(key1.pollEvents(), StandardWatchEventKinds.ENTRY_CREATE, name2);
// check that key2 got zero events
WatchKey key = watcher2.poll();
if (key != null) throw new RuntimeException("key not expected");
// delete gus1
Files.delete(file1);
// check that key2 got ENTRY_DELETE
takeExpectedKey(watcher2, key2);
checkExpectedEvent(key2.pollEvents(), StandardWatchEventKinds.ENTRY_DELETE, name1);
// check that key1 got zero events
key = watcher1.poll();
if (key != null) throw new RuntimeException("key not expected");
// reset for next test
key1.reset();
key2.reset();
// change registration with watcher2 so that they are both
// registered for the same event
System.out.println("register for same event");
key2 = dir.register(watcher2, new WatchEvent.Kind<?>[] {ENTRY_CREATE});
// create file and key2 should be queued
System.out.format("create %s\n", file1);
Files.createFile(file1);
takeExpectedKey(watcher2, key2);
checkExpectedEvent(key2.pollEvents(), StandardWatchEventKinds.ENTRY_CREATE, name1);
System.out.println("OKAY");
} finally {
watcher2.close();
watcher1.close();
}
}