public async Task TwoWaySynchronize_AddedBoth_NewEntitiesAreMatching(GenericConflictResolution conflictWinner)
{
await InitializeWithTwoEvents();
var addedLocal = await _localRepository.Create(v => "Item l");
var addedServer = await _serverRepository.Create(v => "Item s");
await _serverRepository.Create(v => "Item s2");
ExecuteMultipleTimes(() =>
{
SynchronizeTwoWay(
conflictWinner,
new List <IEntityRelationData <Identifier, int, Identifier, int> >
{
new EntityRelationData(addedLocal.Id, addedLocal.Version, addedServer.Id, addedServer.Version)
});
AssertLocalCount(4);
AssertLocal("l1", 0, "Item 1");
AssertLocal("l2", 0, "Item 2");
AssertLocal(0, "Item l");
AssertLocal("l4", 0, "Item s2");
AssertServerCount(4);
AssertServer("s1", 0, "Item 1");
AssertServer("s2", 0, "Item 2");
AssertServer(0, "Item s");
AssertServer("s4", 0, "Item s2");
});
}
public async Task TwoWaySynchronize_DeletedLocal_WithWrongHint2(GenericConflictResolution conflictWinner)
{
await InitializeWithTwoEvents();
_localRepository.Delete("l1");
_localRepository.Delete("l2");
ExecuteMultipleTimes(() =>
{
SynchronizePartialTwoWay(
conflictWinner,
new[]
{
IdWithHints.Create(new Identifier("l1"), (int?)666, null),
},
CreateIdentifiers());
AssertLocalCount(0);
AssertServerCount(1);
AssertServer("s2", 0, "Item 2");
});
ExecuteMultipleTimes(() =>
{
SynchronizeTwoWay(conflictWinner);
AssertLocalCount(0);
AssertServerCount(0);
});
}
protected void SynchronizeTwoWay (
GenericConflictResolution winner,
List<IEntityRelationData<Identifier, int, Identifier, int>> matchingEntities = null)
{
var strategy = CreateTwoWaySyncStrategy (winner);
SynchronizeInternal (strategy, matchingEntities);
}
protected void SynchronizeTwoWay(
GenericConflictResolution winner,
List <IEntityRelationData <Identifier, int, Identifier, int> > matchingEntities = null)
{
var strategy = CreateTwoWaySyncStrategy(winner);
SynchronizeInternal(strategy, false, matchingEntities);
}
protected Exception SynchronizeTwoWayNoThrow(
GenericConflictResolution winner,
List <IEntityRelationData <Identifier, int, Identifier, int> > matchingEntities = null)
{
var strategy = CreateTwoWaySyncStrategy(winner);
return(SynchronizeInternal(strategy, true, matchingEntities));
}
protected void SynchronizePartialTwoWay (
GenericConflictResolution winner,
Identifier[] aEntitesToSynchronize,
Identifier[] bEntitesToSynchronize)
{
var strategy = CreateTwoWaySyncStrategy (winner);
PartialSynchronizeInternal (strategy, aEntitesToSynchronize, bEntitesToSynchronize);
}
protected void SynchronizePartialTwoWay(
GenericConflictResolution winner,
IIdWithHints <Identifier, int>[] aEntitesToSynchronize,
IIdWithHints <Identifier, int>[] bEntitesToSynchronize)
{
var strategy = CreateTwoWaySyncStrategy(winner);
PartialSynchronizeInternal(strategy, aEntitesToSynchronize, bEntitesToSynchronize);
}
private TwoWayInitialSyncStateCreationStrategy<Identifier, int, string, Identifier, int, string> CreateTwoWaySyncStrategy (GenericConflictResolution winner)
{
IConflictInitialSyncStateCreationStrategy<Identifier, int, string, Identifier, int, string> conflictInitialStrategy;
if (winner == GenericConflictResolution.AWins)
conflictInitialStrategy = new ConflictInitialSyncStateCreationStrategyAWins<Identifier, int, string, Identifier, int, string> (_factory);
else
conflictInitialStrategy = new ConflictInitialSyncStateCreationStrategyBWins<Identifier, int, string, Identifier, int, string> (_factory);
var strategy = new TwoWayInitialSyncStateCreationStrategy<Identifier, int, string, Identifier, int, string> (_factory, conflictInitialStrategy);
return strategy;
}
public void Synchronize(GenericConflictResolution winner)
{
IConflictInitialSyncStateCreationStrategy<string, int, string, string, int, string> conflictInitialStrategy;
if (winner == GenericConflictResolution.AWins)
conflictInitialStrategy = new ConflictInitialSyncStateCreationStrategyAWins<string, int, string, string, int, string> (_factory);
else
conflictInitialStrategy = new ConflictInitialSyncStateCreationStrategyBWins<string, int, string, string, int, string> (_factory);
var strategy = new TwoWayInitialSyncStateCreationStrategy<string, int, string, string, int, string> (_factory, conflictInitialStrategy);
SynchronizeInternal (strategy);
}
public void TwoWaySynchronize_DeletedBoth(GenericConflictResolution conflictWinner)
{
_synchronizerSetup.InitializeWithTwoEvents();
_synchronizerSetup._serverRepository.Delete("s1");
_synchronizerSetup._localRepository.Delete("l2");
ExecuteMultipleTimes(() =>
{
Synchronize(conflictWinner);
_synchronizerSetup.AssertLocalCount(0);
_synchronizerSetup.AssertServerCount(0);
});
}
public async Task TwoWaySynchronize_DeletedBoth(GenericConflictResolution conflictWinner)
{
await InitializeWithTwoEvents();
_serverRepository.Delete("s1");
_localRepository.Delete("l2");
ExecuteMultipleTimes(() =>
{
SynchronizeTwoWay(conflictWinner);
AssertLocalCount(0);
AssertServerCount(0);
});
}
public async Task TwoWaySynchronize_DeletedLocal(GenericConflictResolution conflictWinner)
{
await InitializeWithTwoEvents();
await _localRepository.Delete("l1");
ExecuteMultipleTimes(() =>
{
Synchronize(conflictWinner);
AssertLocalCount(1);
AssertLocal("l2", 0, "Item 2");
AssertServerCount(1);
AssertServer("s2", 0, "Item 2");
});
}
public void TwoWaySynchronize_UpdatedServer(GenericConflictResolution conflictWinner)
{
_synchronizerSetup.InitializeWithTwoEvents();
_synchronizerSetup._serverRepository.UpdateWithoutIdChange("s1", v => "upd Item 1");
ExecuteMultipleTimes(() =>
{
Synchronize(conflictWinner);
_synchronizerSetup.AssertLocalCount(2);
_synchronizerSetup.AssertLocal("l1u", 1, "upd Item 1");
_synchronizerSetup.AssertLocal("l2", 0, "Item 2");
_synchronizerSetup.AssertServerCount(2);
_synchronizerSetup.AssertServer("s1", 1, "upd Item 1");
_synchronizerSetup.AssertServer("s2", 0, "Item 2");
});
}
public void TwoWaySynchronize_AddedServer(GenericConflictResolution conflictWinner)
{
_synchronizerSetup._serverRepository.Create(v => "Item 1");
_synchronizerSetup._serverRepository.Create(v => "Item 2");
ExecuteMultipleTimes(() =>
{
Synchronize(conflictWinner);
_synchronizerSetup.AssertLocalCount(2);
_synchronizerSetup.AssertLocal("l1", 0, "Item 1");
_synchronizerSetup.AssertLocal("l2", 0, "Item 2");
_synchronizerSetup.AssertServerCount(2);
_synchronizerSetup.AssertServer("s1", 0, "Item 1");
_synchronizerSetup.AssertServer("s2", 0, "Item 2");
});
}
public async Task TwoWaySynchronize_AddedServer (GenericConflictResolution conflictWinner)
{
await _serverRepository.Create (v => "Item 1");
await _serverRepository.Create (v => "Item 2");
ExecuteMultipleTimes (() =>
{
SynchronizeTwoWay (conflictWinner);
AssertLocalCount (2);
AssertLocal ("l1", 0, "Item 1");
AssertLocal ("l2", 0, "Item 2");
AssertServerCount (2);
AssertServer ("s1", 0, "Item 1");
AssertServer ("s2", 0, "Item 2");
});
}
public async Task TwoWaySynchronize_AddedServer(GenericConflictResolution conflictWinner)
{
await _serverRepository.Create(v => Task.FromResult("Item 1"), NullSynchronizationContextFactory.Instance.Create().Result);
await _serverRepository.Create(v => Task.FromResult("Item 2"), NullSynchronizationContextFactory.Instance.Create().Result);
ExecuteMultipleTimes(() =>
{
SynchronizeTwoWay(conflictWinner);
AssertLocalCount(2);
AssertLocal("l1", 0, "Item 1");
AssertLocal("l2", 0, "Item 2");
AssertServerCount(2);
AssertServer("s1", 0, "Item 1");
AssertServer("s2", 0, "Item 2");
});
}
public void Synchronize(GenericConflictResolution winner)
{
IConflictInitialSyncStateCreationStrategy <Identifier, int, string, Identifier, int, string> conflictInitialStrategy;
if (winner == GenericConflictResolution.AWins)
{
conflictInitialStrategy = new ConflictInitialSyncStateCreationStrategyAWins <Identifier, int, string, Identifier, int, string> (_factory);
}
else
{
conflictInitialStrategy = new ConflictInitialSyncStateCreationStrategyBWins <Identifier, int, string, Identifier, int, string> (_factory);
}
var strategy = new TwoWayInitialSyncStateCreationStrategy <Identifier, int, string, Identifier, int, string> (_factory, conflictInitialStrategy);
SynchronizeInternal(strategy);
}
public async Task TwoWaySynchronize_UpdatedLocal(GenericConflictResolution conflictWinner)
{
await InitializeWithTwoEvents();
_localRepository.UpdateWithoutIdChange("l1", v => "upd Item 1");
ExecuteMultipleTimes(() =>
{
SynchronizeTwoWay(conflictWinner);
AssertLocalCount(2);
AssertLocal("l1", 1, "upd Item 1");
AssertLocal("l2", 0, "Item 2");
AssertServerCount(2);
AssertServer("s1u", 1, "upd Item 1");
AssertServer("s2", 0, "Item 2");
});
}
public async Task TwoWaySynchronize_AddedServer(GenericConflictResolution conflictWinner)
{
await _serverRepository.Create(v => "Item 1");
await _serverRepository.Create(v => "Item 2");
ExecuteMultipleTimes(() =>
{
SynchronizeTwoWay(conflictWinner);
AssertLocalCount(2);
AssertLocal("l1", 0, "Item 1");
AssertLocal("l2", 0, "Item 2");
AssertServerCount(2);
AssertServer("s1", 0, "Item 1");
AssertServer("s2", 0, "Item 2");
});
}
public async Task TwoWaySynchronize_ChangedLocal_VersionSpecified (GenericConflictResolution conflictWinner)
{
await InitializeWithTwoEvents();
_localRepository.UpdateWithoutIdChange ("l1", _ => "Item 1 upd");
_localRepository.UpdateWithoutIdChange ("l2", _ => "Item 2 upd");
ExecuteMultipleTimes (() =>
{
SynchronizePartialTwoWay (
conflictWinner,
new[]
{
IdWithHints.Create (new Identifier ("l1"), (int?) 0, null), // Same version as knyown version specified => isn't synced
IdWithHints.Create (new Identifier ("l2"), (int?) 999, null) // Other version as knyown version specified => is synced
},
CreateIdentifiers());
AssertLocalCount (2);
AssertLocal ("l1", 1, "Item 1 upd");
AssertLocal ("l2", 1, "Item 2 upd");
AssertServerCount (2);
AssertServer ("s1", 0, "Item 1");
AssertServer ("s2u", 1, "Item 2 upd");
});
ExecuteMultipleTimes (() =>
{
SynchronizeTwoWay (conflictWinner);
AssertLocalCount (2);
AssertLocal ("l1", 1, "Item 1 upd");
AssertLocal ("l2", 1, "Item 2 upd");
AssertServerCount (2);
AssertServer ("s1u", 1, "Item 1 upd");
AssertServer ("s2u", 1, "Item 2 upd");
});
}
public async Task TwoWaySynchronize_ChangedLocal_VersionSpecified(GenericConflictResolution conflictWinner)
{
await InitializeWithTwoEvents();
_localRepository.UpdateWithoutIdChange("l1", _ => "Item 1 upd");
_localRepository.UpdateWithoutIdChange("l2", _ => "Item 2 upd");
ExecuteMultipleTimes(() =>
{
SynchronizePartialTwoWay(
conflictWinner,
new[]
{
IdWithHints.Create(new Identifier("l1"), (int?)0, null), // Same version as knyown version specified => isn't synced
IdWithHints.Create(new Identifier("l2"), (int?)999, null) // Other version as knyown version specified => is synced
},
CreateIdentifiers());
AssertLocalCount(2);
AssertLocal("l1", 1, "Item 1 upd");
AssertLocal("l2", 1, "Item 2 upd");
AssertServerCount(2);
AssertServer("s1", 0, "Item 1");
AssertServer("s2u", 1, "Item 2 upd");
});
ExecuteMultipleTimes(() =>
{
SynchronizeTwoWay(conflictWinner);
AssertLocalCount(2);
AssertLocal("l1", 1, "Item 1 upd");
AssertLocal("l2", 1, "Item 2 upd");
AssertServerCount(2);
AssertServer("s1u", 1, "Item 1 upd");
AssertServer("s2u", 1, "Item 2 upd");
});
}
public void TwoWaySynchronize_AddedBoth(GenericConflictResolution conflictWinner)
{
_synchronizerSetup.InitializeWithTwoEvents();
_synchronizerSetup._localRepository.Create(v => "Item l");
_synchronizerSetup._serverRepository.Create(v => "Item s");
ExecuteMultipleTimes(() =>
{
Synchronize(conflictWinner);
_synchronizerSetup.AssertLocalCount(4);
_synchronizerSetup.AssertLocal("l1", 0, "Item 1");
_synchronizerSetup.AssertLocal("l2", 0, "Item 2");
_synchronizerSetup.AssertLocal(0, "Item l");
_synchronizerSetup.AssertLocal(0, "Item s");
_synchronizerSetup.AssertServerCount(4);
_synchronizerSetup.AssertServer("s1", 0, "Item 1");
_synchronizerSetup.AssertServer("s2", 0, "Item 2");
_synchronizerSetup.AssertServer(0, "Item l");
_synchronizerSetup.AssertServer(0, "Item s");
});
}
public async Task TwoWaySynchronize_ChangedLocal_SpecifiedTwice(GenericConflictResolution conflictWinner)
{
await InitializeWithTwoEvents();
_localRepository.UpdateWithoutIdChange("l1", _ => "Item 1 upd");
_localRepository.UpdateWithoutIdChange("l2", _ => "Item 2 upd");
ExecuteMultipleTimes(() =>
{
SynchronizePartialTwoWay(
conflictWinner,
CreateIdentifiers("l1"),
CreateIdentifiers("s1"));
AssertLocalCount(2);
AssertLocal("l1", 1, "Item 1 upd");
AssertLocal("l2", 1, "Item 2 upd");
AssertServerCount(2);
AssertServer("s1u", 1, "Item 1 upd");
AssertServer("s2", 0, "Item 2");
});
}
public async Task TwoWaySynchronize_ChangedLocal_SpecifiedTwice (GenericConflictResolution conflictWinner)
{
await InitializeWithTwoEvents();
_localRepository.UpdateWithoutIdChange ("l1", _ => "Item 1 upd");
_localRepository.UpdateWithoutIdChange ("l2", _ => "Item 2 upd");
ExecuteMultipleTimes (() =>
{
SynchronizePartialTwoWay (
conflictWinner,
C ("l1"),
C ("s1"));
AssertLocalCount (2);
AssertLocal ("l1", 1, "Item 1 upd");
AssertLocal ("l2", 1, "Item 2 upd");
AssertServerCount (2);
AssertServer ("s1u", 1, "Item 1 upd");
AssertServer ("s2", 0, "Item 2");
});
}
public async Task TwoWaySynchronize_AddedBoth (GenericConflictResolution conflictWinner)
{
await InitializeWithTwoEvents();
await _localRepository.Create (v => "Item l");
await _serverRepository.Create (v => "Item s");
ExecuteMultipleTimes (() =>
{
SynchronizeTwoWay (conflictWinner);
AssertLocalCount (4);
AssertLocal ("l1", 0, "Item 1");
AssertLocal ("l2", 0, "Item 2");
AssertLocal (0, "Item l");
AssertLocal (0, "Item s");
AssertServerCount (4);
AssertServer ("s1", 0, "Item 1");
AssertServer ("s2", 0, "Item 2");
AssertServer (0, "Item l");
AssertServer (0, "Item s");
});
}
public async Task TwoWaySynchronize_AddedLocal_WithHint(GenericConflictResolution conflictWinner)
{
await _localRepository.Create(v => Task.FromResult("Item 1"), NullSynchronizationContextFactory.Instance.Create().Result);
await _localRepository.Create(v => Task.FromResult("Item 2"), NullSynchronizationContextFactory.Instance.Create().Result);
ExecuteMultipleTimes(() =>
{
SynchronizePartialTwoWay(
conflictWinner,
new[]
{
IdWithHints.Create(new Identifier("l1"), (int?)0, null),
},
CreateIdentifiers());
AssertLocalCount(2);
AssertLocal("l1", 0, "Item 1");
AssertLocal("l2", 0, "Item 2");
AssertServerCount(1);
AssertServer("s1", 0, "Item 1");
});
ExecuteMultipleTimes(() =>
{
SynchronizeTwoWay(conflictWinner);
AssertLocalCount(2);
AssertLocal("l1", 0, "Item 1");
AssertLocal("l2", 0, "Item 2");
AssertServerCount(2);
AssertServer("s1", 0, "Item 1");
AssertServer("s2", 0, "Item 2");
});
}
public async Task TwoWaySynchronize_AddedBoth(GenericConflictResolution conflictWinner)
{
await InitializeWithTwoEvents();
await _localRepository.Create(v => "Item l");
await _serverRepository.Create(v => "Item s");
ExecuteMultipleTimes(() =>
{
SynchronizeTwoWay(conflictWinner);
AssertLocalCount(4);
AssertLocal("l1", 0, "Item 1");
AssertLocal("l2", 0, "Item 2");
AssertLocal(0, "Item l");
AssertLocal(0, "Item s");
AssertServerCount(4);
AssertServer("s1", 0, "Item 1");
AssertServer("s2", 0, "Item 2");
AssertServer(0, "Item l");
AssertServer(0, "Item s");
});
}
public async Task TwoWaySynchronize_AddedLocal_WithWrongHint(GenericConflictResolution conflictWinner)
{
await _localRepository.Create(v => Task.FromResult("Item 1"), NullSynchronizationContextFactory.Instance.Create().Result);
await _localRepository.Create(v => Task.FromResult("Item 2"), NullSynchronizationContextFactory.Instance.Create().Result);
ExecuteMultipleTimes(() =>
{
SynchronizePartialTwoWay(
conflictWinner,
new[]
{
IdWithHints.Create(new Identifier("l1"), (int?)null, true), // specifying deletion hint true for a new item causes the item not to be synced
},
CreateIdentifiers());
AssertLocalCount(2);
AssertLocal("l1", 0, "Item 1");
AssertLocal("l2", 0, "Item 2");
AssertServerCount(0);
});
ExecuteMultipleTimes(() =>
{
SynchronizeTwoWay(conflictWinner);
AssertLocalCount(2);
AssertLocal("l1", 0, "Item 1");
AssertLocal("l2", 0, "Item 2");
AssertServerCount(2);
AssertServer("s1", 0, "Item 1");
AssertServer("s2", 0, "Item 2");
});
}
public async Task TwoWaySynchronize_AddedBoth_NewEntitiesAreMatching (GenericConflictResolution conflictWinner)
{
await InitializeWithTwoEvents();
var addedLocal = await _localRepository.Create (v => "Item l");
var addedServer = await _serverRepository.Create (v => "Item s");
await _serverRepository.Create (v => "Item s2");
ExecuteMultipleTimes (() =>
{
SynchronizeTwoWay (
conflictWinner,
new List<IEntityRelationData<Identifier, int, Identifier, int>>
{
new EntityRelationData (addedLocal.Id, addedLocal.Version, addedServer.Id, addedServer.Version)
});
AssertLocalCount (4);
AssertLocal ("l1", 0, "Item 1");
AssertLocal ("l2", 0, "Item 2");
AssertLocal (0, "Item l");
AssertLocal ("l4", 0, "Item s2");
AssertServerCount (4);
AssertServer ("s1", 0, "Item 1");
AssertServer ("s2", 0, "Item 2");
AssertServer (0, "Item s");
AssertServer ("s4", 0, "Item s2");
});
}
protected void SynchronizeTwoWay (GenericConflictResolution winner)
{
var strategy = CreateTwoWaySyncStrategy (winner);
SynchronizeInternal (strategy);
}
public async Task TwoWaySynchronize_DeletedBothWithConflict (GenericConflictResolution conflictWinner)
{
await InitializeWithTwoEvents();
_serverRepository.Delete ("s1");
_localRepository.Delete ("l1");
ExecuteMultipleTimes (() =>
{
SynchronizeTwoWay (conflictWinner);
AssertLocalCount (1);
AssertLocal ("l2", 0, "Item 2");
AssertServerCount (1);
AssertServer ("s2", 0, "Item 2");
});
}
public async Task TwoWaySynchronize_DeletedLocal_WithWrongHint2 (GenericConflictResolution conflictWinner)
{
await InitializeWithTwoEvents ();
_localRepository.Delete ("l1");
_localRepository.Delete ("l2");
ExecuteMultipleTimes (() =>
{
SynchronizePartialTwoWay (
conflictWinner,
new[]
{
IdWithHints.Create (new Identifier ("l1"), (int?) 666, null),
},
CreateIdentifiers ());
AssertLocalCount (0);
AssertServerCount (1);
AssertServer ("s2", 0, "Item 2");
});
ExecuteMultipleTimes (() =>
{
SynchronizeTwoWay (conflictWinner);
AssertLocalCount (0);
AssertServerCount (0);
});
}
private TwoWayInitialSyncStateCreationStrategy <Identifier, int, string, Identifier, int, string, int> CreateTwoWaySyncStrategy(GenericConflictResolution winner)
{
IConflictInitialSyncStateCreationStrategy <Identifier, int, string, Identifier, int, string, int> conflictInitialStrategy;
if (winner == GenericConflictResolution.AWins)
{
conflictInitialStrategy = new ConflictInitialSyncStateCreationStrategyAWins <Identifier, int, string, Identifier, int, string, int> (_factory);
}
else
{
conflictInitialStrategy = new ConflictInitialSyncStateCreationStrategyBWins <Identifier, int, string, Identifier, int, string, int> (_factory);
}
var strategy = new TwoWayInitialSyncStateCreationStrategy <Identifier, int, string, Identifier, int, string, int> (_factory, conflictInitialStrategy);
return(strategy);
}
public async Task TwoWaySynchronize_AddedLocal_WithHint (GenericConflictResolution conflictWinner)
{
await _localRepository.Create (v => Task.FromResult("Item 1"), NullSynchronizationContextFactory.Instance.Create ().Result);
await _localRepository.Create (v => Task.FromResult ("Item 2"), NullSynchronizationContextFactory.Instance.Create ().Result);
ExecuteMultipleTimes (() =>
{
SynchronizePartialTwoWay (
conflictWinner,
new[]
{
IdWithHints.Create (new Identifier ("l1"), (int?) 0, null),
},
CreateIdentifiers ());
AssertLocalCount (2);
AssertLocal ("l1", 0, "Item 1");
AssertLocal ("l2", 0, "Item 2");
AssertServerCount (1);
AssertServer ("s1", 0, "Item 1");
});
ExecuteMultipleTimes (() =>
{
SynchronizeTwoWay (conflictWinner);
AssertLocalCount (2);
AssertLocal ("l1", 0, "Item 1");
AssertLocal ("l2", 0, "Item 2");
AssertServerCount (2);
AssertServer ("s1", 0, "Item 1");
AssertServer ("s2", 0, "Item 2");
});
}
public async Task TwoWaySynchronize_AddedLocal_WithWrongHint (GenericConflictResolution conflictWinner)
{
await _localRepository.Create (v => Task.FromResult("Item 1"), NullSynchronizationContextFactory.Instance.Create ().Result);
await _localRepository.Create (v => Task.FromResult("Item 2"), NullSynchronizationContextFactory.Instance.Create ().Result);
ExecuteMultipleTimes (() =>
{
SynchronizePartialTwoWay (
conflictWinner,
new[]
{
IdWithHints.Create (new Identifier ("l1"), (int?) null, true), // specifying deletion hint true for a new item causes the item not to be synced
},
CreateIdentifiers ());
AssertLocalCount (2);
AssertLocal ("l1", 0, "Item 1");
AssertLocal ("l2", 0, "Item 2");
AssertServerCount (0);
});
ExecuteMultipleTimes (() =>
{
SynchronizeTwoWay (conflictWinner);
AssertLocalCount (2);
AssertLocal ("l1", 0, "Item 1");
AssertLocal ("l2", 0, "Item 2");
AssertServerCount (2);
AssertServer ("s1", 0, "Item 1");
AssertServer ("s2", 0, "Item 2");
});
}
public async Task TwoWaySynchronize_AddedBothWithoutExisting_NewEntitiesAreMatching(GenericConflictResolution conflictWinner)
{
var addedLocal = await _localRepository.Create(v => "Item l");
var addedServer = await _serverRepository.Create(v => "Item s");
ExecuteMultipleTimes(() =>
{
SynchronizeTwoWay(
conflictWinner,
new List <IEntityRelationData <Identifier, int, Identifier, int> >
{
new EntityRelationData(addedLocal.Id, addedLocal.Version, addedServer.Id, addedServer.Version)
});
AssertLocalCount(1);
AssertLocal(0, "Item l");
AssertServerCount(1);
AssertServer(0, "Item s");
});
}
public async Task TwoWaySynchronize_AddedBothWithoutExisting_NewEntitiesAreMatching (GenericConflictResolution conflictWinner)
{
var addedLocal = await _localRepository.Create (v => "Item l");
var addedServer = await _serverRepository.Create (v => "Item s");
ExecuteMultipleTimes (() =>
{
SynchronizeTwoWay (
conflictWinner,
new List<IEntityRelationData<Identifier, int, Identifier, int>>
{
new EntityRelationData (addedLocal.Id, addedLocal.Version, addedServer.Id, addedServer.Version)
});
AssertLocalCount (1);
AssertLocal (0, "Item l");
AssertServerCount (1);
AssertServer (0, "Item s");
});
}
public async Task TwoWaySynchronize_UpdatedBoth (GenericConflictResolution conflictWinner)
{
await InitializeWithTwoEvents();
_serverRepository.UpdateWithoutIdChange ("s1", v => "upd Item 1");
_localRepository.UpdateWithoutIdChange ("l2", v => "upd Item 2");
ExecuteMultipleTimes (() =>
{
SynchronizeTwoWay (conflictWinner);
AssertLocalCount (2);
AssertLocal ("l1u", 1, "upd Item 1");
AssertLocal ("l2", 1, "upd Item 2");
AssertServerCount (2);
AssertServer ("s1", 1, "upd Item 1");
AssertServer ("s2u", 1, "upd Item 2");
});
}