@Test public void testMultipleDirCreation() { List<IEvent> events = new ArrayList<>(); CreateEvent c1 = new CreateEvent( Config.DEFAULT.getRootTestDir().resolve(Paths.get("myDir1")), "myDir1", null, System.currentTimeMillis()); CreateEvent c2 = new CreateEvent( Config.DEFAULT.getRootTestDir().resolve(Paths.get("myDir2")), "myDir2", null, System.currentTimeMillis()); CreateEvent c3 = new CreateEvent( Config.DEFAULT.getRootTestDir().resolve(Paths.get("myDir3")), "myDir3", null, System.currentTimeMillis()); CreateEvent c4 = new CreateEvent( Config.DEFAULT.getRootTestDir().resolve(Paths.get("myDir4")), "myDir4", null, System.currentTimeMillis()); events.add(c1); events.add(c2); events.add(c3); events.add(c4); List<IEvent> results = moveAggregator.aggregate(events); assertEquals("Results do not contain all dir creation events", 4, results.size()); }
@Test public void testMultipleCreationWithSameHash() { // add a second create event long beforeFirstTimestamp = firstTimestamp - 1000L; CreateEvent createEvent = new CreateEvent( Config.DEFAULT.getRootTestDir().resolve("created2/newFile.txt"), "newFile.txt", fileHash, beforeFirstTimestamp); forceMoveEventList.add(0, createEvent); List<IEvent> results = moveAggregator.aggregate(forceMoveEventList); assertEquals("Result does not contain all unmodified events", 3, results.size()); assertEquals("First event is not the 2nd create event", createEvent, results.get(0)); assertThat( "Second event is not the delete event", results.get(1), instanceOf(DeleteEvent.class)); assertThat( "Third event is not the 1st create event", results.get(2), instanceOf(CreateEvent.class)); }
public class HistoryMoveAggregatorTest { protected static HistoryMoveAggregator moveAggregator; protected static IObjectManager objectManagerMock; protected static List<IEvent> forceMoveEventList; protected static List<IEvent> forceNoMoveEventList; protected static Path oldPath = Config.DEFAULT.getRootTestDir().resolve("modify.txt"); protected static Path newPath = Config.DEFAULT.getRootTestDir().resolve("created/modify.txt"); protected static String fileName = "modify.txt"; protected static String fileHash = "da39a3ee5e6b4b0d3255bfef95601890afd80709"; protected static long firstTimestamp; protected static long secondTimestamp; @BeforeClass public static void setUp() { objectManagerMock = new ObjectManagerMock(); moveAggregator = new HistoryMoveAggregator(objectManagerMock); } @Before public void before() { forceMoveEventList = new ArrayList<>(); forceNoMoveEventList = new ArrayList<>(); firstTimestamp = System.currentTimeMillis(); // this must be greater than HistoryMoveAggregator#EVENT_TIMESTAMP_TOLERANCE secondTimestamp = firstTimestamp + 1100; DeleteEvent deleteEvent = new DeleteEvent(oldPath, fileName, fileHash, firstTimestamp); CreateEvent createEvent = new CreateEvent(newPath, fileName, fileHash, secondTimestamp); forceMoveEventList.add(deleteEvent); forceMoveEventList.add(createEvent); // order the events the other way CreateEvent createEvent2 = new CreateEvent(newPath, fileName, fileHash, firstTimestamp); DeleteEvent deleteEvent2 = new DeleteEvent(oldPath, fileName, fileHash, secondTimestamp); forceNoMoveEventList.add(deleteEvent2); forceNoMoveEventList.add(createEvent2); } @Test public void testMultipleDirCreation() { List<IEvent> events = new ArrayList<>(); CreateEvent c1 = new CreateEvent( Config.DEFAULT.getRootTestDir().resolve(Paths.get("myDir1")), "myDir1", null, System.currentTimeMillis()); CreateEvent c2 = new CreateEvent( Config.DEFAULT.getRootTestDir().resolve(Paths.get("myDir2")), "myDir2", null, System.currentTimeMillis()); CreateEvent c3 = new CreateEvent( Config.DEFAULT.getRootTestDir().resolve(Paths.get("myDir3")), "myDir3", null, System.currentTimeMillis()); CreateEvent c4 = new CreateEvent( Config.DEFAULT.getRootTestDir().resolve(Paths.get("myDir4")), "myDir4", null, System.currentTimeMillis()); events.add(c1); events.add(c2); events.add(c3); events.add(c4); List<IEvent> results = moveAggregator.aggregate(events); assertEquals("Results do not contain all dir creation events", 4, results.size()); } @Test public void testMoveEvent() { List<IEvent> results = moveAggregator.aggregate(forceMoveEventList); assertEquals("Result does not only contain the move event", 1, results.size()); IEvent event = results.get(0); assertThat("Event is not instance of CreateEvent", event, instanceOf(MoveEvent.class)); MoveEvent moveEvent = (MoveEvent) event; assertEquals("Old path is not the same", oldPath, moveEvent.getPath()); assertEquals("New path is not the same", newPath, moveEvent.getNewPath()); assertEquals("New name is not the same", fileName, moveEvent.getName()); assertEquals("New hash is not the same", fileHash, moveEvent.getHash()); assertEquals( "New timestamp is not the expected one", secondTimestamp, moveEvent.getTimestamp()); } @Test public void testNoMoveEvent() { List<IEvent> results = moveAggregator.aggregate(forceNoMoveEventList); assertEquals("Result does not contain both events", 2, results.size()); IEvent firstEvent = results.get(0); IEvent secondEvent = results.get(1); assertThat("First event is not the create event", firstEvent, instanceOf(CreateEvent.class)); assertThat("Second event is not the delete event", secondEvent, instanceOf(DeleteEvent.class)); assertEquals("Create event's path is not the same", newPath, firstEvent.getPath()); assertEquals("Create event's file name is not the same", fileName, firstEvent.getName()); assertEquals("Create event's hash is not the same", fileHash, firstEvent.getHash()); assertEquals( "Create event's timestamp is not the same", firstTimestamp, firstEvent.getTimestamp()); assertEquals("Delete event's path is not the same", oldPath, secondEvent.getPath()); assertEquals("Delete event's file name is not the same", fileName, secondEvent.getName()); assertEquals("Delete event's hash is not the same", fileHash, secondEvent.getHash()); assertEquals( "Delete event's timestamp is not the same", secondTimestamp, secondEvent.getTimestamp()); } @Test public void testSingleEvent() { List<IEvent> singleEvent = new ArrayList<>(); IEvent event = new DeleteEvent(oldPath, fileName, fileHash, secondTimestamp); singleEvent.add(event); List<IEvent> results = moveAggregator.aggregate(singleEvent); assertEquals("Result does not contain the single event", 1, results.size()); assertEquals("Result does not contain the same single event", event, results.get(0)); } @Test public void testMultipleUnrelatedEvents() { long beforeFirstTimestamp = firstTimestamp - 1000L; ModifyEvent modifyEvent = new ModifyEvent(oldPath, fileName, fileHash, beforeFirstTimestamp); forceMoveEventList.add(0, modifyEvent); long afterSecondTimestamp = secondTimestamp + 1000L; ModifyEvent modifyEvent2 = new ModifyEvent(newPath, fileName, fileHash, afterSecondTimestamp); forceMoveEventList.add(modifyEvent2); List<IEvent> results = moveAggregator.aggregate(forceMoveEventList); assertEquals("Results do not contain all events", 3, results.size()); IEvent firstEvent = results.get(0); assertThat("First event is not modify event", firstEvent, instanceOf(ModifyEvent.class)); assertEquals("First event is not the same instance of modify event", modifyEvent, firstEvent); IEvent event = results.get(1); assertThat("Event is not instance of MoveEvent", event, instanceOf(MoveEvent.class)); MoveEvent moveEvent = (MoveEvent) event; assertEquals("Old path is not the same", oldPath, moveEvent.getPath()); assertEquals("New path is not the same", newPath, moveEvent.getNewPath()); assertEquals("New name is not the same", fileName, moveEvent.getName()); assertEquals("New hash is not the same", fileHash, moveEvent.getHash()); assertEquals( "New timestamp is not the expected one", secondTimestamp, moveEvent.getTimestamp()); IEvent thirdEvent = results.get(2); assertThat("Third event is not modify event", thirdEvent, instanceOf(ModifyEvent.class)); assertEquals("Third event is not the same instance of modify event", modifyEvent2, thirdEvent); } @Test public void testMultipleDeletionWithSameHash() { // add a second create event long beforeFirstTimestamp = firstTimestamp - 1000L; DeleteEvent delete = new DeleteEvent( Config.DEFAULT.getRootTestDir().resolve("created2/newFile.txt"), "newFile.txt", fileHash, beforeFirstTimestamp); forceMoveEventList.add(0, delete); List<IEvent> results = moveAggregator.aggregate(forceMoveEventList); assertEquals("Result does not contain all unmodified events", 3, results.size()); assertEquals("First event is not the 2nd delete event", delete, results.get(0)); assertThat( "Second event is not the delete event", results.get(1), instanceOf(DeleteEvent.class)); assertThat( "Third event is not the 1st create event", results.get(2), instanceOf(CreateEvent.class)); } @Test public void testMultipleCreationWithSameHash() { // add a second create event long beforeFirstTimestamp = firstTimestamp - 1000L; CreateEvent createEvent = new CreateEvent( Config.DEFAULT.getRootTestDir().resolve("created2/newFile.txt"), "newFile.txt", fileHash, beforeFirstTimestamp); forceMoveEventList.add(0, createEvent); List<IEvent> results = moveAggregator.aggregate(forceMoveEventList); assertEquals("Result does not contain all unmodified events", 3, results.size()); assertEquals("First event is not the 2nd create event", createEvent, results.get(0)); assertThat( "Second event is not the delete event", results.get(1), instanceOf(DeleteEvent.class)); assertThat( "Third event is not the 1st create event", results.get(2), instanceOf(CreateEvent.class)); } @Test public void testMoveEventWithHistory() throws InputOutputException { Version v1 = new Version("hashOfV1"); ArrayList<Version> versions = new ArrayList<>(); versions.add(v1); PathObject testOldPath = new PathObject( fileName, Naming.getPathWithoutFileName(fileName, oldPath.toString()), PathType.FILE, AccessType.WRITE, false, new Delete(DeleteType.EXISTENT, new ArrayList<>()), null, new HashSet<>(), versions); objectManagerMock.writeObject(testOldPath); DeleteEvent deleteEvent = new DeleteEvent(oldPath, fileName, null, firstTimestamp); CreateEvent createEvent = new CreateEvent(newPath, fileName, v1.getHash(), secondTimestamp); List<IEvent> forceLookupInHistoryList = new ArrayList<>(); forceLookupInHistoryList.add(deleteEvent); forceLookupInHistoryList.add(createEvent); List<IEvent> results = moveAggregator.aggregate(forceLookupInHistoryList); assertEquals("Result does not only contain the move event", 1, results.size()); assertThat("Event is not move event", results.get(0), instanceOf(MoveEvent.class)); } }