public void Running_Synchronize_has_no_effect_if_there_is_a_sync_folder_without_history()
{
var historyBuilder1 = new HistoryBuilder(m_Group, "folder1");
historyBuilder1.AddFile("file1");
historyBuilder1.CreateSnapshot();
var historyBuilder2 = new HistoryBuilder(m_Group, "folder2");
m_Instance.Synchronize(m_Group);
// check that no actions / conflicts or sync points have been stored
Assert.Empty(m_Group.GetSyncConflictService().Items);
Assert.Empty(m_Group.GetSyncActionService().AllItems);
Assert.Empty(m_Group.GetSyncPointService().Items);
}
public void Synchronizer_creates_conflict_if_a_file_with_pending_syncactions_is_modified()
{
// SCENARIO
// left: A -> B *Sync* -> C *Sync*
// right A *Sync* *Sync*
// 3: A
// ARRANGE
var writeTimeA = DateTime.Now;
var writeTimeB = writeTimeA.AddHours(1);
var writeTimeC = writeTimeA.AddHours(2);
var historyBuilder1 = new HistoryBuilder(m_Group, "history1");
historyBuilder1.AddFile("file1", writeTimeA);
historyBuilder1.CreateSnapshot();
historyBuilder1.RemoveFile("file1");
historyBuilder1.AddFile("file1", writeTimeB);
historyBuilder1.CreateSnapshot();
var historyBuilder2 = new HistoryBuilder(m_Group, "history2");
historyBuilder2.AddFile("file1", writeTimeA);
historyBuilder2.CreateSnapshot();
var historyBuilder3 = new HistoryBuilder(m_Group, "history3");
historyBuilder3.AddFile("file1", writeTimeA);
historyBuilder3.CreateSnapshot();
m_Instance.Synchronize(m_Group);
historyBuilder1.RemoveFile("file1");
historyBuilder1.AddFile("file1", writeTimeC);
historyBuilder1.CreateSnapshot();
// ACT
m_Instance.Synchronize(m_Group);
// ASSERT: The pending sync action cannot be applied => create a conflict for the file
var conflicts = m_Group.GetSyncConflictService().Items.ToArray();
Assert.Single(conflicts);
// snapshot ids must be null (there were no previous sync at the time the non-applicable sync action was created)
Assert.Null(conflicts.Single().SnapshotId);
Assert.Empty(m_Group.GetSyncActionService().PendingItems);
}
public void Synchronize_does_not_apply_changes_to_a_folder_that_are_excluded_by_its_filter()
{
// ARRANGE
var configurationService = m_Group.GetConfigurationService();
// set up folder 1
{
var historyBuilder = new HistoryBuilder(m_Group, "folder1");
historyBuilder.AddFile("file1");
historyBuilder.AddFile("file2");
historyBuilder.CreateSnapshot();
}
// set up folder 2
{
var historyBuilder = new HistoryBuilder(m_Group, "folder2");
historyBuilder.CreateSnapshot();
// set up filter
historyBuilder.SyncFolder.Filter = new FilterConfiguration(FilterType.MicroscopeQuery, "endsWith('file1')");
configurationService.UpdateItem(historyBuilder.SyncFolder);
}
// set up folder 3
{
var historyBuilder = new HistoryBuilder(m_Group, "folder3");
historyBuilder.CreateSnapshot();
}
//ACT
m_Instance.Synchronize(m_Group);
//ASSERT: file1 is added to both folder2 and folder3, file2 is only added to folder3 (excluded by folder2's filter)
var syncActionService = m_Group.GetSyncActionService();
SyncAssert.ActionsExist(syncActionService, "/file1",
expectedState: SyncActionState.Queued,
expectedCount:2,
expectedChangeType: ChangeType.Added);
SyncAssert.ActionsExist(syncActionService, "/file2",
expectedState: SyncActionState.Queued,
expectedCount: 1,
expectedChangeType: ChangeType.Added);
}
public void Synchronize_ignores_changes_from_a_folder_excluded_by_the_folders_filter()
{
//ARRANGE
var configurationService = m_Group.GetConfigurationService();
// set up folder 1
{
var historyBuilder = new HistoryBuilder(m_Group, "folder1");
historyBuilder.AddFile("file.excluded");
historyBuilder.AddFile("file.included");
historyBuilder.CreateSnapshot();
// set up filter
historyBuilder.SyncFolder.Filter = new FilterConfiguration(FilterType.MicroscopeQuery, "not endsWith('excluded')");
configurationService.UpdateItem(historyBuilder.SyncFolder);
}
// set up folder 2
{
new HistoryBuilder(m_Group, "folder2").CreateSnapshot();
}
// set up folder 3
{
new HistoryBuilder(m_Group, "folder3").CreateSnapshot();
}
//ACT
m_Instance.Synchronize(m_Group);
//ASSERT: file.excluded is added to no folder (filtered from source, but file.included needs to be added to both folder 2 and 3)
var syncActionService = m_Group.GetSyncActionService();
var pendingItems = syncActionService.PendingItems.ToArray();
Assert.Equal(2, syncActionService.PendingItems.Count());
SyncAssert.ActionsExist(syncActionService,
path: "/file.included",
expectedState:SyncActionState.Queued,
expectedCount:2,
expectedChangeType: ChangeType.Added);
}
public void Synchronizer_resets_the_sync_state_if_a_filter_was_modified_since_the_last_sync()
{
//ARRANGE
{
var historyBuilder = new HistoryBuilder(m_Group, "folder1");
historyBuilder.AddFile("file1");
historyBuilder.CreateSnapshot();
}
{
var historyBuilder = new HistoryBuilder(m_Group, "folder2");
historyBuilder.AddFile("file2");
historyBuilder.CreateSnapshot();
}
m_Instance.Synchronize(m_Group);
// change filter for folder2
{
var configurationService = m_Group.GetConfigurationService();
var folder = configurationService["folder2"];
//"not isEmpty()" will always be true for file paths
folder.Filter = new FilterConfiguration(FilterType.MicroscopeQuery, "not isEmpty()");
configurationService.UpdateItem(folder);
}
var firstSyncActions = m_Group.GetSyncActionService().AllItems.ToArray();
//ACT
m_Instance.Synchronize(m_Group);
//ASSERT
{
var syncPointService = m_Group.GetSyncPointService();
// there should be 3 sync points
Assert.Equal(3, syncPointService.Items.Count());
// first sync
Assert.NotNull(syncPointService[1].MultiFileSystemSnapshotId);
// reset
Assert.Null(syncPointService[2].MultiFileSystemSnapshotId);
// second sync (FromSnapshots needs to be reset to null)
Assert.NotNull(syncPointService[3].MultiFileSystemSnapshotId);
// all sync actions from previous syncs need to be cancelled
var syncActions = m_Group.GetSyncActionService().AllItems.ToDictionary(a => a.Id);
Assert.True(firstSyncActions.All(a => syncActions[a.Id].State == SyncActionState.Cancelled));
// all conflicts need to be removed
Assert.Empty(m_Group.GetSyncConflictService().Items);
}
}
public void Synchronize_stores_the_filter_configuration_in_the_sync_point()
{
//ARRANGE
var historyBuilder1 = new HistoryBuilder(m_Group, "folder1");
historyBuilder1.AddFile("file1");
historyBuilder1.CreateSnapshot();
var historyBuilder2 = new HistoryBuilder(m_Group, "folder2");
historyBuilder2.AddFile("file2");
historyBuilder2.CreateSnapshot();
var configurationService = m_Group.GetConfigurationService();
var folder1 = configurationService["folder1"];
//"not isEmpty()" will always be true for file paths
folder1.Filter = new FilterConfiguration(FilterType.MicroscopeQuery, "not isEmpty()");
configurationService.UpdateItem(folder1);
var folder2 = configurationService["folder2"];
folder2.Filter = FilterConfiguration.Empty;
configurationService.UpdateItem(folder2);
//ACT
m_Instance.Synchronize(m_Group);
//ASSERT
var syncPointService = m_Group.GetSyncPointService();
var syncPoint = syncPointService.Items.Single();
var expected = new Dictionary<string, FilterConfiguration>()
{
{"folder1", folder1.Filter},
{"folder2", folder2.Filter}
};
DictionaryAssert.Equal(expected, syncPoint.FilterConfigurations);
}
public void Sychronize_resets_the_sync_state_when_a_new_folder_was_added()
{
// ARRANGE
var left = new HistoryBuilder(m_Group, "left");
var right = new HistoryBuilder(m_Group, "right");
left.AddFile("file1");
left.CreateSnapshot();
right.CreateSnapshot();
m_Instance.Synchronize(m_Group);
var firstSyncActions = m_Group.GetSyncActionService().AllItems.ToArray();
// ACT: Add a new sync folder
var newHistory = new HistoryBuilder(m_Group, "history3");
newHistory.CreateSnapshot();
m_Group.GetSyncConflictService().AddItems(new ConflictInfo("/file2", null));
m_Instance.Synchronize(m_Group);
//ASSERT
var syncPointService = m_Group.GetSyncPointService();
// there should be 3 sync points (2 "regular" syncpoints and a "reset point")
Assert.Equal(3, syncPointService.Items.Count());
// first sync
Assert.NotNull(syncPointService[1].MultiFileSystemSnapshotId);
// reset
Assert.Null(syncPointService[2].MultiFileSystemSnapshotId);
// second sync (FromSnapshots needs to be reset to null)
Assert.NotNull(syncPointService[3].MultiFileSystemSnapshotId);
// all sync actions from previous syncs need to be cancelled
var syncActions = m_Group.GetSyncActionService().AllItems.ToDictionary(a => a.Id);
Assert.True(firstSyncActions.All(a => syncActions[a.Id].State == SyncActionState.Cancelled));
// all conflicts need to be removed
Assert.Empty(m_Group.GetSyncConflictService().Items);
}
public void Synchronize_Unrelated_sync_actions_stay_unchanged()
{
// ARRANGE
var left = new HistoryBuilder(m_Group, "left");
var right = new HistoryBuilder(m_Group, "right");
left.AddFile("file1");
left.CreateSnapshot();
right.CreateSnapshot();
//ACT
// first sync
m_Instance.Synchronize(m_Group);
SyncAssert.ActionsExist(m_Group.GetSyncActionService(), "/file1",
expectedState: SyncActionState.Queued,
expectedCount: 1,
expectedChangeType: ChangeType.Added);
Assert.Empty(m_Group.GetSyncConflictService().Items);
left.AddFile("file2");
left.CreateSnapshot();
m_Instance.Synchronize(m_Group);
//ASSERT
SyncAssert.ActionsExist(m_Group.GetSyncActionService(), "/file1",
expectedState: SyncActionState.Queued,
expectedCount: 1,
expectedChangeType: ChangeType.Added);
SyncAssert.ActionsExist(m_Group.GetSyncActionService(), "/file2",
expectedState: SyncActionState.Queued,
expectedCount: 1,
expectedChangeType: ChangeType.Added);
Assert.Empty(m_Group.GetSyncConflictService().Items);
}
public void Synchronize_with_previous_sync_point_01()
{
// ARRANGE
var left = new HistoryBuilder(m_Group, "left");
var right = new HistoryBuilder(m_Group, "right");
// left: add file 1
// right: empty
left.AddFile("file1");
left.CreateSnapshot();
right.AddFiles();
right.CreateSnapshot();
m_Instance.Synchronize(m_Group);
Assert.Equal(1, m_Group.GetSyncActionService().AllItems.Count());
// left: add file 2
left.AddFiles("file2");
left.CreateSnapshot();
//ACT
m_Instance.Synchronize(m_Group);
Assert.Equal(2, m_Group.GetSyncPointService().Items.Count());
Assert.Equal(2, m_Group.GetSyncActionService().AllItems.Count());
//TODO: Check ids in syncpoints
}
public void Synchronize_without_previous_sync_no_conflicts()
{
// ARRANGE
var left = new HistoryBuilder(m_Group, "left");
left.AddFile("file1");
left.CreateSnapshot();
left.RemoveFile("file1");
left.CreateSnapshot();
var right = new HistoryBuilder(m_Group, "right");
right.AddFile("file2");
right.CreateSnapshot();
right.RemoveFile("file2");
right.CreateSnapshot();
//ACT
m_Instance.Synchronize(m_Group);
//ASSERT
Assert.Empty(m_Group.GetSyncConflictService().Items);
var syncActions = m_Group.GetSyncActionService().AllItems.ToArray();
Assert.Empty(syncActions);
Assert.Single(m_Group.GetSyncPointService().Items);
}
public void Synchronize_without_previous_sync_single_snapshots_and_no_conflicts()
{
//ARRANGE
var left = new HistoryBuilder(m_Group, "left");
var right = new HistoryBuilder(m_Group, "right");
left.AddFile("file1");
right.AddFile("file2");
var snapshot1 = left.CreateSnapshot();
var snapshot2 = right.CreateSnapshot();
//ACT
m_Instance.Synchronize(m_Group);
//ASSERT
var syncActionService = m_Group.GetSyncActionService();
Assert.Equal(2, syncActionService.AllItems.Count());
SyncAssert.ActionsExist(syncActionService, "/file1",
expectedCount:1,
expectedState: SyncActionState.Queued,
expectedChangeType: ChangeType.Added
);
SyncAssert.ToVersionMatches(left.CurrentState.GetFile("/file1"), syncActionService["/file1"].Single());
SyncAssert.ActionsExist(syncActionService, "/file2",
expectedCount:1,
expectedState: SyncActionState.Queued,
expectedChangeType: ChangeType.Added);
SyncAssert.ToVersionMatches(right.CurrentState.GetFile("/file2"), syncActionService["/file2"].Single());
Assert.Empty(m_Group.GetSyncConflictService().Items);
Assert.Single(m_Group.GetSyncPointService().Items);
var syncPoint = m_Group.GetSyncPointService().Items.Single();
Assert.Equal(1, syncPoint.Id);
var expectedToSnapshotId = m_MultiFileSystemHistory.LatestSnapshot.Id;
Assert.Equal(expectedToSnapshotId, syncPoint.MultiFileSystemSnapshotId);
}
public void Running_Synchronize_without_at_least_one_snapshot_per_history_has_no_effect()
{
//ARRANGE
var historyBuilder1 = new HistoryBuilder(m_Group, "history1");
historyBuilder1.AddFile("file1");
historyBuilder1.CreateSnapshot();
var historyBuilder2 = new HistoryBuilder(m_Group, "history2");
//ACT
m_Instance.Synchronize(m_Group);
//ASSERT
Assert.Empty(m_Group.GetSyncConflictService().Items);
Assert.Empty(m_Group.GetSyncActionService().AllItems);
Assert.Empty(m_Group.GetSyncPointService().Items);
}
