@Test
public void testInstant() {
// millisec since epoch
long timestamp = System.currentTimeMillis();
// point in time - now!
Instant instant = Instant.now();
long secEpoch = instant.getEpochSecond();
// missing milli so divide by 1000
Assert.assertEquals(timestamp / 1000, secEpoch);
Assert.assertEquals(instant.getLong(ChronoField.INSTANT_SECONDS), secEpoch);
Instant timestampInstant = Instant.ofEpochMilli(timestamp);
Assert.assertEquals(timestamp, timestampInstant.truncatedTo(ChronoUnit.MILLIS).toEpochMilli());
// different ways to go into the future
Instant future1 = instant.plusMillis(1000);
Instant future2 = instant.plus(1000, ChronoUnit.MILLIS);
// add Duration instead of Period as this example is dealing with time
Instant future3 = instant.plus(Duration.ofMillis(1000));
Instant future4 = instant.plus(Duration.of(1000, ChronoUnit.MILLIS));
// all futures are the same!
Assert.assertEquals(future1, future2);
Assert.assertEquals(future2, future3);
Assert.assertEquals(future3, future4);
}
/**
* <code>GitDataProviderTest</code> tests the methods of the {@link GitDataProvider}. This is mostly
* a test if the data provider properly notifies the registered {@link CompletionNotifier}s.
*
* @author <a href="mailto:[email protected]">Jaka Bobnar</a>
*/
public class GitDataProviderTest {
private GitDataProvider dataProvider;
private CompletionNotifier notifier;
private Instant date = Instant.now();
private Branch branch = new Branch();
private Branch someBranch = new Branch("someBranch", "someBranch");
private Branch demoBranch = new Branch("demo", "demo");
private BaseLevel branchBase1 = new BaseLevel(new Branch(), "base1", "base1");
private BaseLevel branchBase2 = new BaseLevel(new Branch(), "base2", "base2");
private BaseLevel someBaseLevel = new BaseLevel(someBranch, "sbase2", "sbase2");
private SaveSet branchSaveSet =
new SaveSet(branch, Optional.of(branchBase1), new String[] {"first", "second.bms"}, "someId");
private SaveSet branchSaveSet2 =
new SaveSet(
branch,
Optional.of(branchBase1),
new String[] {"first", "foo", "bar", "second.bms"},
"someId");
private Snapshot branchSnapshot = new Snapshot(branchSaveSet, date, "comment", "owner");
private Snapshot branchSnapshot2 =
new Snapshot(branchSaveSet, date.minusMillis(5000), "another comment", "user");
private Snapshot branchSnapshot3 =
new Snapshot(branchSaveSet, date.plusMillis(5000), "new snapshot", "user");
private SaveSetData bsd =
new SaveSetData(
branchSaveSet,
Arrays.asList(
new SaveSetEntry("pv1", "rb1", "d1", false),
new SaveSetEntry("pv2", "rb2", "d2", false)),
"description");
private VSnapshot snapshot =
new VSnapshot(
branchSnapshot3,
Arrays.asList(new SnapshotEntry("pv1", VDisconnectedData.INSTANCE)),
Instant.now(),
null);
@Before
public void setUp() throws Exception {
GitAPIException exception =
new GitAPIException("Problem") {
private static final long serialVersionUID = 1L;
};
GitManager grm = mock(GitManager.class);
notifier = mock(CompletionNotifier.class);
dataProvider = new GitDataProvider(grm);
dataProvider.addCompletionNotifier(notifier);
Field field = GitDataProvider.class.getDeclaredField("initialized");
field.setAccessible(true);
field.set(dataProvider, Boolean.TRUE);
when(grm.getBranches()).thenReturn(Arrays.asList(branch, demoBranch));
when(grm.getBaseLevels(branch)).thenReturn(Arrays.asList(branchBase1, branchBase2));
when(grm.getBaseLevels(demoBranch)).thenReturn(new ArrayList<>(0));
when(grm.getSaveSets(Optional.of(branchBase1), branch))
.thenReturn(Arrays.asList(branchSaveSet, branchSaveSet2));
when(grm.getSnapshots(branchSaveSet, 0, Optional.empty()))
.thenReturn(Arrays.asList(branchSnapshot, branchSnapshot2));
when(grm.loadSaveSetData(branchSaveSet, Optional.empty())).thenReturn(bsd);
when(grm.createBranch(branch, "someBranch")).thenReturn(someBranch);
when(grm.createBranch(branch, "bla")).thenThrow(exception);
when(grm.saveSaveSet(bsd, "comment")).thenReturn(new Result<SaveSetData>(bsd, ChangeType.SAVE));
when(grm.saveSaveSet(bsd, "comment2"))
.thenReturn(new Result<SaveSetData>(bsd, ChangeType.PULL));
when(grm.saveSaveSet(bsd, "comment3")).thenThrow(exception);
when(grm.deleteSaveSet(branchSaveSet, "comment"))
.thenReturn(new Result<SaveSet>(branchSaveSet, ChangeType.SAVE));
when(grm.deleteSaveSet(branchSaveSet, "comment2"))
.thenReturn(new Result<SaveSet>(branchSaveSet, ChangeType.PULL));
when(grm.deleteSaveSet(branchSaveSet, "comment4"))
.thenReturn(new Result<SaveSet>(null, ChangeType.NONE));
when(grm.deleteSaveSet(branchSaveSet, "comment3")).thenThrow(exception);
when(grm.saveSnapshot(snapshot, "comment"))
.thenReturn(new Result<VSnapshot>(snapshot, ChangeType.SAVE));
when(grm.saveSnapshot(snapshot, "comment2"))
.thenReturn(new Result<VSnapshot>(snapshot, ChangeType.PULL));
when(grm.saveSnapshot(snapshot, "comment3"))
.thenReturn(new Result<VSnapshot>(null, ChangeType.NONE));
when(grm.saveSnapshot(snapshot, "comment4")).thenThrow(exception);
when(grm.tagSnapshot(branchSnapshot, "name", "message"))
.thenReturn(new Result<Snapshot>(branchSnapshot, ChangeType.SAVE));
when(grm.tagSnapshot(branchSnapshot, "name2", "message"))
.thenReturn(new Result<Snapshot>(branchSnapshot, ChangeType.PULL));
when(grm.tagSnapshot(branchSnapshot, "name3", "message"))
.thenReturn(new Result<Snapshot>(null, ChangeType.NONE));
when(grm.tagSnapshot(branchSnapshot, "name4", "message")).thenThrow(exception);
when(grm.loadSnapshotData(branchSnapshot)).thenReturn(snapshot);
when(grm.findSnapshotsByCommentOrUser(
"temp", branch, true, true, Optional.empty(), Optional.empty()))
.thenReturn(Arrays.asList(branchSnapshot, branchSnapshot3));
when(grm.findSnapshotsByCommentOrUser(
"temp", branch, true, false, Optional.empty(), Optional.empty()))
.thenReturn(Arrays.asList(branchSnapshot3));
when(grm.findSnapshotsByCommentOrUser(
"temp", branch, false, true, Optional.empty(), Optional.empty()))
.thenReturn(Arrays.asList(branchSnapshot2));
when(grm.findSnapshotsByTag("temp", branch, Optional.empty(), Optional.empty()))
.thenReturn(Arrays.asList(branchSnapshot));
when(grm.findSnapshotsByTagMessage("temp", branch, Optional.empty(), Optional.empty()))
.thenReturn(Arrays.asList(branchSnapshot2));
when(grm.findSnapshotsByTagName("temp", branch, Optional.empty(), Optional.empty()))
.thenReturn(Arrays.asList(branchSnapshot3));
when(grm.importData(branchSaveSet, someBranch, Optional.of(someBaseLevel), ImportType.SAVE_SET))
.thenReturn(new Result<Boolean>(true, ChangeType.SAVE));
when(grm.importData(
branchSaveSet, someBranch, Optional.of(someBaseLevel), ImportType.ALL_SNAPSHOTS))
.thenReturn(new Result<Boolean>(true, ChangeType.PULL));
when(grm.importData(
branchSaveSet, someBranch, Optional.of(someBaseLevel), ImportType.LAST_SNAPSHOT))
.thenReturn(new Result<Boolean>(false, ChangeType.NONE));
when(grm.synchronise(Optional.empty())).thenReturn(true);
}
@Test
public void testGetBranches() throws DataProviderException {
Branch[] branches = dataProvider.getBranches();
assertEquals("2 branches are defined", 2, branches.length);
assertEquals(branch, branches[0]);
assertEquals(demoBranch, branches[1]);
}
@Test
public void testGetBaseLevels() throws DataProviderException {
BaseLevel[] baseLevels = dataProvider.getBaseLevels(branch);
assertEquals("2 base levels are defined for default branch", 2, baseLevels.length);
assertEquals(branchBase1, baseLevels[0]);
assertEquals(branchBase2, baseLevels[1]);
baseLevels = dataProvider.getBaseLevels(demoBranch);
assertEquals("No base levels in demo branch", 0, baseLevels.length);
}
@Test
public void testGetSaveSets() throws DataProviderException {
SaveSet[] sets = dataProvider.getSaveSets(Optional.of(branchBase1), branch);
assertEquals("2 base levels are defined for default branch", 2, sets.length);
assertEquals(branchSaveSet, sets[0]);
assertEquals(branchSaveSet2, sets[1]);
}
@Test
public void testGetSnapshots() throws DataProviderException {
Snapshot[] snaps = dataProvider.getSnapshots(branchSaveSet, true, Optional.empty());
assertEquals("2 base levels are defined for default branch", 2, snaps.length);
assertEquals(branchSnapshot, snaps[0]);
assertEquals(branchSnapshot2, snaps[1]);
}
@Test
public void testGetSaveSetContent() throws DataProviderException {
SaveSetData data = dataProvider.getSaveSetContent(branchSaveSet);
assertEquals(bsd, data);
}
@Test
public void testCreateNewBranch() throws DataProviderException {
Branch newBranch = dataProvider.createNewBranch(branch, "someBranch");
assertEquals(someBranch, newBranch);
verify(notifier, times(1)).branchCreated(newBranch);
verify(notifier, only()).branchCreated(newBranch);
try {
dataProvider.createNewBranch(branch, "bla");
fail("Exception should happen");
} catch (DataProviderException e) {
assertNotNull(e.getMessage());
}
verify(notifier, times(1)).branchCreated(newBranch);
verify(notifier, only()).branchCreated(newBranch);
}
@Test
public void testSaveSaveSet() throws DataProviderException {
SaveSetData data = dataProvider.saveSaveSet(bsd, "comment");
assertEquals(bsd, data);
verify(notifier, times(1)).saveSetSaved(data);
verify(notifier, only()).saveSetSaved(data);
Mockito.reset(notifier);
data = dataProvider.saveSaveSet(bsd, "comment2");
assertEquals(bsd, data);
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
try {
dataProvider.saveSaveSet(bsd, "comment3");
fail("Exception should happen");
} catch (DataProviderException e) {
assertNotNull(e.getMessage());
}
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
}
@Test
public void testDeleteSaveSet() throws DataProviderException {
boolean b = dataProvider.deleteSaveSet(branchSaveSet, "comment");
assertTrue(b);
verify(notifier, times(1)).saveSetDeleted(branchSaveSet);
verify(notifier, only()).saveSetDeleted(branchSaveSet);
Mockito.reset(notifier);
b = dataProvider.deleteSaveSet(branchSaveSet, "comment4");
assertFalse(b);
verify(notifier, never()).synchronised();
Mockito.reset(notifier);
b = dataProvider.deleteSaveSet(branchSaveSet, "comment2");
assertTrue(b);
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
try {
dataProvider.deleteSaveSet(branchSaveSet, "comment3");
fail("Exception should happen");
} catch (DataProviderException e) {
assertNotNull(e.getMessage());
}
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
}
@Test
public void testSaveSnapshot() throws DataProviderException {
VSnapshot snap = dataProvider.saveSnapshot(snapshot, "comment");
assertTrue(snap.equalsExceptSnapshot(snapshot));
verify(notifier, times(1)).snapshotSaved(snap);
verify(notifier, only()).snapshotSaved(snap);
Mockito.reset(notifier);
snap = dataProvider.saveSnapshot(snapshot, "comment2");
assertTrue(snap.equalsExceptSnapshot(snapshot));
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
try {
dataProvider.saveSnapshot(snapshot, "comment4");
fail("Exception should happen");
} catch (DataProviderException e) {
assertNotNull(e.getMessage());
}
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
Mockito.reset(notifier);
snap = dataProvider.saveSnapshot(snapshot, "comment3");
assertNull(snap);
verify(notifier, never()).synchronised();
}
@Test
public void testTagSnapshot() throws DataProviderException {
Snapshot snap =
dataProvider.tagSnapshot(branchSnapshot, Optional.of("name"), Optional.of("message"));
assertEquals(branchSnapshot, snap);
verify(notifier, times(1)).snapshotTagged(snap);
verify(notifier, only()).snapshotTagged(snap);
Mockito.reset(notifier);
snap = dataProvider.tagSnapshot(branchSnapshot, Optional.of("name2"), Optional.of("message"));
assertEquals(branchSnapshot, snap);
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
try {
dataProvider.tagSnapshot(branchSnapshot, Optional.of("name4"), Optional.of("message"));
fail("Exception should happen");
} catch (DataProviderException e) {
assertNotNull(e.getMessage());
}
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
Mockito.reset(notifier);
snap = dataProvider.tagSnapshot(branchSnapshot, Optional.of("name3"), Optional.of("message"));
assertNull(snap);
verify(notifier, never()).synchronised();
}
@Test
public void testGetSnapshotContent() throws DataProviderException {
VSnapshot data = dataProvider.getSnapshotContent(branchSnapshot);
assertEquals(snapshot, data);
}
@Test
public void testFindSnapshots() throws DataProviderException {
List<SearchCriterion> criteria = dataProvider.getSupportedSearchCriteria();
Snapshot[] snapshots =
dataProvider.findSnapshots(
"temp",
branch,
Arrays.asList(criteria.get(0), criteria.get(3)),
Optional.empty(),
Optional.empty());
assertEquals(2, snapshots.length);
assertEquals(branchSnapshot, snapshots[0]);
assertEquals(branchSnapshot3, snapshots[1]);
snapshots =
dataProvider.findSnapshots(
"temp", branch, Arrays.asList(criteria.get(3)), Optional.empty(), Optional.empty());
assertEquals(1, snapshots.length);
assertEquals(branchSnapshot2, snapshots[0]);
snapshots =
dataProvider.findSnapshots(
"temp", branch, Arrays.asList(criteria.get(0)), Optional.empty(), Optional.empty());
assertEquals(1, snapshots.length);
assertEquals(branchSnapshot3, snapshots[0]);
snapshots =
dataProvider.findSnapshots(
"temp",
branch,
Arrays.asList(criteria.get(0), criteria.get(1), criteria.get(2)),
Optional.empty(),
Optional.empty());
assertEquals(2, snapshots.length);
assertEquals(branchSnapshot3, snapshots[0]);
assertEquals(branchSnapshot, snapshots[1]);
snapshots =
dataProvider.findSnapshots(
"temp",
branch,
Arrays.asList(criteria.get(3), criteria.get(1)),
Optional.empty(),
Optional.empty());
assertEquals(2, snapshots.length);
assertEquals(branchSnapshot3, snapshots[0]);
assertEquals(branchSnapshot2, snapshots[1]);
snapshots =
dataProvider.findSnapshots(
"temp", branch, Arrays.asList(criteria.get(2)), Optional.empty(), Optional.empty());
assertEquals(1, snapshots.length);
assertEquals(branchSnapshot2, snapshots[0]);
}
@Test
public void testImportData() throws DataProviderException {
boolean b =
dataProvider.importData(
branchSaveSet, someBranch, Optional.of(someBaseLevel), ImportType.SAVE_SET);
assertTrue(b);
verify(notifier, times(1)).dataImported(branchSaveSet, someBranch, Optional.of(someBaseLevel));
verify(notifier, only()).dataImported(branchSaveSet, someBranch, Optional.of(someBaseLevel));
Mockito.reset(notifier);
b =
dataProvider.importData(
branchSaveSet, someBranch, Optional.of(someBaseLevel), ImportType.LAST_SNAPSHOT);
assertFalse(b);
verify(notifier, never()).synchronised();
Mockito.reset(notifier);
b =
dataProvider.importData(
branchSaveSet, someBranch, Optional.of(someBaseLevel), ImportType.ALL_SNAPSHOTS);
assertTrue(b);
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
}
@Test
public void testSynchronise() throws DataProviderException {
boolean b = dataProvider.synchronise();
assertTrue(b);
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
}
}