public async Task Synchronize_ServerEventContainsOrganizer_IsSyncedToOutlookAndBackToServer()
{
var options = TestComponentContainer.GetOptions("IntegrationTest/Events/Sogo");
options.SynchronizationMode = SynchronizationMode.MergeInBothDirections;
var synchronizer = await CreateSynchronizer(options);
await synchronizer.ClearEventRepositoriesAndCache();
await synchronizer.CreateEventOnServer("bla", DateTime.Now.AddDays(11), DateTime.Now.AddDays(20), e => e.Organizer = new Organizer("*****@*****.**"));
await synchronizer.SynchronizeAndAssertNoErrors();
using (var outlookEvent = (await synchronizer.Outlook.GetAllEntities()).Single().Entity)
{
Assert.That(outlookEvent.Inner.Organizer, Is.EqualTo("*****@*****.**"));
outlookEvent.Inner.Subject = "TheNewSubject";
outlookEvent.Inner.Save();
}
await synchronizer.SynchronizeAndAssertNoErrors();
var serverEvent = (await synchronizer.Server.GetAllEntities()).Single().Entity;
Assert.That(serverEvent.Events[0].Summary, Is.EqualTo("TheNewSubject"));
Assert.That(serverEvent.Events[0].Organizer.Value.ToString(), Is.EqualTo("mailto:[email protected]"));
}
public async Task SynchronizeTwoWay_CacheIsClearedAfterFirstRun_FindsMatchingEntitiesInSecondRun()
{
var options = TestComponentContainer.GetOptions("IntegrationTest/Events/Sogo");
options.SynchronizationMode = SynchronizationMode.MergeInBothDirections;
var synchronizer = await CreateSynchronizer(options);
await synchronizer.ClearEventRepositoriesAndCache();
await synchronizer.CreateEventInOutlook("first", DateTime.Now.AddDays(11), DateTime.Now.AddDays(20));
await synchronizer.CreateEventInOutlook("second", DateTime.Now.AddDays(-11), DateTime.Now.AddDays(-9));
await synchronizer.CreateEventInOutlook("third", DateTime.Now.AddDays(9), DateTime.Now.AddDays(11));
await synchronizer.SynchronizeAndAssertNoErrors();
var relations = synchronizer.Components.EntityRelationDataAccess.LoadEntityRelationData().Select(r => new { r.AtypeId, r.BtypeId }).ToArray();
Assert.That(relations.Length, Is.EqualTo(3));
synchronizer.ClearCache();
await synchronizer.SynchronizeAndAssertNoErrors();
CollectionAssert.AreEquivalent(
relations,
synchronizer.Components.EntityRelationDataAccess.LoadEntityRelationData().Select(r => new { r.AtypeId, r.BtypeId })
);
}
protected async Task InitializeSynchronizer(int?chunkSize)
{
var options = TestComponentContainer.GetOptions(ProfileName);
options.ChunkSize = chunkSize ?? 0;
options.IsChunkedSynchronizationEnabled = chunkSize.HasValue;
Synchronizer = CreateSynchronizer(options);
await Synchronizer.Initialize();
}
public async Task SynchronizeToServer_AllDayEventsWithTimeRangeFilter_DoesntDuplicateOrDeleteBoundaryEvents(string profileName)
{
var options = TestComponentContainer.GetOptions(profileName);
options.SynchronizationMode = SynchronizationMode.ReplicateOutlookIntoServer;
var synchronizer = await CreateSynchronizer(options);
await synchronizer.ClearEventRepositoriesAndCache();
await synchronizer.CreateEventInOutlook("Event -5", DateTime.Today.AddDays(-5), DateTime.Now.AddDays(-5), true);
await synchronizer.CreateEventInOutlook("Event -4", DateTime.Today.AddDays(-4), DateTime.Now.AddDays(-4), true);
await synchronizer.CreateEventInOutlook("Event -3", DateTime.Today.AddDays(-3), DateTime.Now.AddDays(-3), true);
await synchronizer.CreateEventInOutlook("Event -2", DateTime.Today.AddDays(-2), DateTime.Now.AddDays(-2), true);
await synchronizer.CreateEventInOutlook("Event -1", DateTime.Today.AddDays(-1), DateTime.Now.AddDays(-1), true);
await synchronizer.CreateEventInOutlook("Event 0", DateTime.Today.AddDays(0), DateTime.Now.AddDays(0), true);
await synchronizer.CreateEventInOutlook("Event 1", DateTime.Today.AddDays(1), DateTime.Now.AddDays(1), true);
await synchronizer.CreateEventInOutlook("Event 2", DateTime.Today.AddDays(2), DateTime.Now.AddDays(2), true);
await synchronizer.CreateEventInOutlook("Event 3", DateTime.Today.AddDays(3), DateTime.Now.AddDays(3), true);
await synchronizer.CreateEventInOutlook("Event 4", DateTime.Today.AddDays(4), DateTime.Now.AddDays(4), true);
await synchronizer.CreateEventInOutlook("Event 5", DateTime.Today.AddDays(5), DateTime.Now.AddDays(5), true);
await synchronizer.SynchronizeAndCheck(
unchangedA : 0, addedA : 11, changedA : 0, deletedA : 0,
unchangedB : 0, addedB : 0, changedB : 0, deletedB : 0,
createA : 0, updateA : 0, deleteA : 0,
createB : 11, updateB : 0, deleteB : 0);
synchronizer.ClearCache();
for (int rangeInDays = 1; rangeInDays <= 5; rangeInDays++)
{
options.DaysToSynchronizeInTheFuture = rangeInDays;
options.DaysToSynchronizeInThePast = rangeInDays;
options.IgnoreSynchronizationTimeRange = false;
synchronizer = await CreateSynchronizer(options);
var expectedNumberOfEvents = rangeInDays * 2 + 2 - (rangeInDays == 5 ? 1 : 0);
await synchronizer.SynchronizeAndCheck(
unchangedA : expectedNumberOfEvents, addedA : 0, changedA : 0, deletedA : 0,
unchangedB : expectedNumberOfEvents, addedB : 0, changedB : 0, deletedB : 0,
createA : 0, updateA : 0, deleteA : 0,
createB : 0, updateB : 0, deleteB : 0);
}
}
public async Task SynchronizeToServer_SomeEventsAreOutsideTimeRangeFilter_SyncsJustEventsWhichMatchTimeRangeFilter()
{
var options = TestComponentContainer.GetOptions("IntegrationTest/Events/Sogo");
options.SynchronizationMode = SynchronizationMode.ReplicateOutlookIntoServer;
var synchronizer = await CreateSynchronizer(options);
await synchronizer.ClearEventRepositoriesAndCache();
options.DaysToSynchronizeInTheFuture = 10;
options.DaysToSynchronizeInThePast = 10;
options.IgnoreSynchronizationTimeRange = false;
synchronizer = await CreateSynchronizer(options);
await synchronizer.CreateEventInOutlook("before", DateTime.Now.AddDays(-20), DateTime.Now.AddDays(-11));
await synchronizer.CreateEventInOutlook("after", DateTime.Now.AddDays(11), DateTime.Now.AddDays(20));
await synchronizer.CreateEventInOutlook("overlapBeginning", DateTime.Now.AddDays(-11), DateTime.Now.AddDays(-9));
await synchronizer.CreateEventInOutlook("overlapEnd", DateTime.Now.AddDays(9), DateTime.Now.AddDays(11));
await synchronizer.CreateEventInOutlook("inside", DateTime.Now.AddDays(-5), DateTime.Now.AddDays(5));
await synchronizer.CreateEventInOutlook("surrounding", DateTime.Now.AddDays(-11), DateTime.Now.AddDays(11));
await synchronizer.SynchronizeAndCheck(
unchangedA : 0, addedA : 4, changedA : 0, deletedA : 0,
unchangedB : 0, addedB : 0, changedB : 0, deletedB : 0,
createA : 0, updateA : 0, deleteA : 0,
createB : 4, updateB : 0, deleteB : 0);
options.IgnoreSynchronizationTimeRange = true;
synchronizer = await CreateSynchronizer(options);
var events = await synchronizer.Server.GetAllEntities();
CollectionAssert.AreEquivalent(
new[]
{
"overlapBeginning", "overlapEnd", "inside", "surrounding"
},
events.Select(e => e.Entity.Events[0].Summary));
}
public async Task SynchronizeTwoWay_LocalContactChanges_IsSyncedToServerAndPreservesExtendedPropertiesAndUid(bool useWebDavCollectionSync)
{
var options = TestComponentContainer.GetOptions("IntegrationTests/Contacts/Sogo");
options.UseWebDavCollectionSync = useWebDavCollectionSync;
var synchronizer = await CreateSynchronizer(options);
await synchronizer.ClearEventRepositoriesAndCache();
string initialUid = null;
await synchronizer.Server.CreateEntity(
c =>
{
c.EmailAddresses.Add(new vCardEmailAddress("*****@*****.**"));
c.GivenName = "Nihil";
c.FamilyName = "Baxter";
c.OtherProperties.Add(new vCardProperty("X-CALDAVSYNCHRONIZER-INTEGRATIONTEST", "TheValueBlaBLubb"));
initialUid = c.UniqueId;
});
await synchronizer.SynchronizeAndAssertNoErrors();
using (var outlookEvent = (await synchronizer.Outlook.GetAllEntities()).Single().Entity)
{
outlookEvent.Inner.FirstName = "TheNewNihil";
outlookEvent.Inner.Save();
}
await synchronizer.SynchronizeAndAssertNoErrors();
var serverContact = (await synchronizer.Server.GetAllEntities()).Single().Entity;
Assert.That(serverContact.GivenName, Is.EqualTo("TheNewNihil"));
Assert.That(serverContact.UniqueId, Is.EqualTo(initialUid));
Assert.That(
serverContact.OtherProperties.SingleOrDefault(p => p.Name == "X-CALDAVSYNCHRONIZER-INTEGRATIONTEST")?.Value,
Is.EqualTo("TheValueBlaBLubb"));
}
public async Task SynchronizeTwoWay_LocalEventChanges_IsSyncedToServerAndPreservesExtendedPropertiesAndUid(bool useWebDavCollectionSync)
{
var options = TestComponentContainer.GetOptions("IntegrationTest/Events/Sogo");
options.UseWebDavCollectionSync = useWebDavCollectionSync;
var synchronizer = await CreateSynchronizer(options);
await synchronizer.ClearEventRepositoriesAndCache();
string initialUid = null;
await synchronizer.CreateEventOnServer(
"XXXX",
DateTime.Now.AddDays(11),
DateTime.Now.AddDays(20),
e =>
{
e.Properties.Add(new CalendarProperty("X-CALDAVSYNCHRONIZER-INTEGRATIONTEST", "TheValueBlaBLubb"));
initialUid = e.UID;
});
await synchronizer.SynchronizeAndAssertNoErrors();
using (var outlookEvent = (await synchronizer.Outlook.GetAllEntities()).Single().Entity)
{
outlookEvent.Inner.Subject = "TheNewSubject";
outlookEvent.Inner.Save();
}
await synchronizer.SynchronizeAndAssertNoErrors();
var serverEvent = (await synchronizer.Server.GetAllEntities()).Single().Entity;
Assert.That(serverEvent.Events[0].Summary, Is.EqualTo("TheNewSubject"));
Assert.That(serverEvent.Events[0].UID, Is.EqualTo(initialUid));
//Assert.That(
// serverEvent.Events[0].Properties.SingleOrDefault(p => p.Name == "X-CALDAVSYNCHRONIZER-INTEGRATIONTEST")?.Value,
// Is.EqualTo("TheValueBlaBLubb"));
}
public async Task CreateOutlookEntity_ExceptionOccurs_DoesNotLeaveEmptyEntityInRepository(bool saveAndReload, bool useWebDavCollectionSync)
{
var options = TestComponentContainer.GetOptions("IntegrationTest/Events/Sogo");
options.UseWebDavCollectionSync = useWebDavCollectionSync;
var synchronizer = await CreateSynchronizer(options);
await synchronizer.ClearEventRepositoriesAndCache();
bool exceptionCatched = false;
var exception = new Exception("bla");
try
{
await synchronizer.Components.OutlookEventRepository.Create(
w =>
{
if (saveAndReload)
{
w.SaveAndReload();
}
throw exception;
},
NullEventSynchronizationContext.Instance);
}
catch (Exception x)
{
if (ReferenceEquals(x, exception))
{
exceptionCatched = true;
}
}
Assert.That(exceptionCatched, Is.EqualTo(true));
Assert.That(
(await synchronizer.Outlook.GetAllEntities()).Count(),
Is.EqualTo(0));
}
public async Task GenericTest(int numberOfGroups, int numberOfContacts, int chunkSize)
{
var options = TestComponentContainer.GetOptions("Automated Test - Google Contacts");
options.SynchronizationMode = SynchronizationMode.ReplicateOutlookIntoServer;
options.IsChunkedSynchronizationEnabled = true;
options.ChunkSize = chunkSize;
var synchronizer = await CreateSynchronizer(options);
await synchronizer.ClearEventRepositoriesAndCache();
var groupNames = synchronizer.GetOrCreateGoogleGroups(numberOfGroups);
await synchronizer.CreateContactsInOutlook(synchronizer.CreateTestContactData(groupNames, numberOfContacts));
await synchronizer.SynchronizeAndCheck(
unchangedA : 0, addedA : numberOfContacts, changedA : 0, deletedA : 0,
unchangedB : 0, addedB : 0, changedB : 0, deletedB : 0,
createA : 0, updateA : 0, deleteA : 0,
createB : numberOfContacts, updateB : 0, deleteB : 0);
var outlook1IdsByGoogleId = synchronizer.Components.GoogleContactsEntityRelationDataAccess.LoadEntityRelationData().ToDictionary(r => r.BtypeId, r => r.AtypeId);
Assert.That(outlook1IdsByGoogleId.Count, Is.EqualTo(numberOfContacts));
await synchronizer.Outlook.DeleteAllEntities();
options.SynchronizationMode = SynchronizationMode.ReplicateServerIntoOutlook;
synchronizer = await CreateSynchronizer(options);
await synchronizer.SynchronizeAndCheck(
unchangedA : 0, addedA : 0, changedA : 0, deletedA : numberOfContacts,
unchangedB : numberOfContacts, addedB : 0, changedB : 0, deletedB : 0,
createA : numberOfContacts, updateA : 0, deleteA : 0,
createB : 0, updateB : 0, deleteB : 0);
}
public async Task Synchronize_AnyCase_SyncsSogoDistLists(bool useWebDavCollectionSync)
{
var options = TestComponentContainer.GetOptions("IntegrationTests/Contacts/Sogo");
options.UseWebDavCollectionSync = useWebDavCollectionSync;
var synchronizer = await CreateSynchronizer(options);
await synchronizer.ClearEventRepositoriesAndCache();
await synchronizer.Server.CreateEntity(
c =>
{
c.EmailAddresses.Add(new vCardEmailAddress("*****@*****.**"));
c.GivenName = "Nihil";
c.FamilyName = "Baxter";
});
var masonId = await synchronizer.Server.CreateEntity(
c =>
{
c.EmailAddresses.Add(new vCardEmailAddress("*****@*****.**"));
c.GivenName = "Agent";
c.FamilyName = "Mason";
});
var steinbergId = await synchronizer.Server.CreateEntity(
c =>
{
c.EmailAddresses.Add(new vCardEmailAddress("*****@*****.**"));
c.GivenName = "Agent";
c.FamilyName = "Steinberg";
});
await synchronizer.ServerSogoDistListsOrNull.CreateEntity(
l =>
{
l.Name = "Agents";
l.Members.Add(new KnownDistributionListMember("*****@*****.**", "Mason", masonId.GetServerFileName()));
l.Members.Add(new KnownDistributionListMember("*****@*****.**", "Steinberg", steinbergId.GetServerFileName()));
});
await synchronizer.SynchronizeAndAssertNoErrors();
var outlookNames = (await synchronizer.Outlook.GetAllEntities()).Select(c => c.Entity.Inner.LastName).ToArray();
CollectionAssert.AreEquivalent(
new[] { "Baxter", "Mason", "Steinberg" },
outlookNames);
using (var outlookDistList = (await synchronizer.OutlookDistListsOrNull.GetAllEntities()).SingleOrDefault()?.Entity)
{
Assert.That(outlookDistList, Is.Not.Null);
Assert.That(outlookDistList.Inner.DLName, Is.EqualTo("Agents"));
var outlookMembers = Enumerable
.Range(1, outlookDistList.Inner.MemberCount)
.Select(i => outlookDistList.Inner.GetMember(i))
.ToSafeEnumerable()
.Select(d => d.Address)
.ToArray();
CollectionAssert.AreEquivalent(
new[] { "*****@*****.**", "*****@*****.**" },
outlookMembers);
outlookDistList.Inner.DLName = "All";
var recipient = _testComponentContainer.Application.Session.CreateRecipient("Baxter");
Assert.That(recipient.Resolve(), Is.True);
outlookDistList.Inner.AddMember(recipient);
outlookDistList.Inner.Save();
}
await synchronizer.SynchronizeAndAssertNoErrors();
var serverDistList = (await synchronizer.ServerSogoDistListsOrNull.GetAllEntities()).SingleOrDefault()?.Entity;
Assert.That(serverDistList, Is.Not.Null);
Assert.That(serverDistList.Name, Is.EqualTo("All"));
CollectionAssert.AreEquivalent(
new[] { "*****@*****.**", "*****@*****.**", "*****@*****.**" },
serverDistList.Members.Select(m => m.EmailAddress));
}
public async Task Synchronize_AnyCase_SyncsVCardGroupWithUidDistLists(bool useWebDavCollectionSync)
{
var options = TestComponentContainer.GetOptions("IntegrationTests/Contacts/Sogo");
options.UseWebDavCollectionSync = useWebDavCollectionSync;
((Contracts.ContactMappingConfiguration)options.MappingConfiguration).DistributionListType = Contracts.DistributionListType.VCardGroupWithUid;
var synchronizer = await CreateSynchronizer(options);
await synchronizer.ClearEventRepositoriesAndCache();
string nihilUid = null;
await synchronizer.Server.CreateEntity(
c =>
{
c.EmailAddresses.Add(new vCardEmailAddress("*****@*****.**"));
c.GivenName = "Nihil";
c.FamilyName = "Baxter";
nihilUid = c.UniqueId;
});
string masonUid = null;
var masonId = await synchronizer.Server.CreateEntity(
c =>
{
c.EmailAddresses.Add(new vCardEmailAddress("*****@*****.**"));
c.GivenName = "Agent";
c.FamilyName = "Mason";
masonUid = c.UniqueId;
});
string steinbergUid = null;
var steinbergId = await synchronizer.Server.CreateEntity(
c =>
{
c.EmailAddresses.Add(new vCardEmailAddress("*****@*****.**"));
c.GivenName = "Agent";
c.FamilyName = "Steinberg";
steinbergUid = c.UniqueId;
});
await synchronizer.ServerVCardGroupsOrNull.CreateEntity(
l =>
{
l.FormattedName = "Agents";
l.FamilyName = "Agents";
var member = new vCardMember();
member.Uid = masonUid;
l.Members.Add(member);
member = new vCardMember();
member.Uid = steinbergUid;
l.Members.Add(member);
});
await synchronizer.SynchronizeAndAssertNoErrors();
var outlookNames = (await synchronizer.Outlook.GetAllEntities()).Select(c => c.Entity.Inner.LastName).ToArray();
CollectionAssert.AreEquivalent(
new[] { "Baxter", "Mason", "Steinberg" },
outlookNames);
using (var outlookDistList = (await synchronizer.OutlookDistListsOrNull.GetAllEntities()).SingleOrDefault()?.Entity)
{
Assert.That(outlookDistList, Is.Not.Null);
Assert.That(outlookDistList.Inner.DLName, Is.EqualTo("Agents"));
var outlookMembers = Enumerable
.Range(1, outlookDistList.Inner.MemberCount)
.Select(i => outlookDistList.Inner.GetMember(i))
.ToSafeEnumerable()
.Select(d => d.Address)
.ToArray();
CollectionAssert.AreEquivalent(
new[] { "*****@*****.**", "*****@*****.**" },
outlookMembers);
outlookDistList.Inner.DLName = "All";
var recipient = _testComponentContainer.Application.Session.CreateRecipient("Baxter");
Assert.That(recipient.Resolve(), Is.True);
outlookDistList.Inner.AddMember(recipient);
outlookDistList.Inner.Save();
}
await synchronizer.SynchronizeAndAssertNoErrors();
var serverDistList = (await synchronizer.ServerVCardGroupsOrNull.GetAllEntities()).SingleOrDefault()?.Entity;
Assert.That(serverDistList, Is.Not.Null);
Assert.That(serverDistList.FormattedName, Is.EqualTo("All"));
CollectionAssert.AreEquivalent(
new[] { masonUid, nihilUid, steinbergUid },
serverDistList.Members.Select(m => m.Uid));
}
public async Task Synchronize_ContainsDuplicates_DuplicatesAreDeletedIfEnabled(bool useWebDavCollectionSync)
{
var options = TestComponentContainer.GetOptions("IntegrationTest/Events/Sogo");
options.SynchronizationMode = SynchronizationMode.MergeInBothDirections;
options.UseWebDavCollectionSync = useWebDavCollectionSync;
var synchronizer = await CreateSynchronizer(options);
await synchronizer.ClearEventRepositoriesAndCache();
synchronizer = await CreateSynchronizer(options);
var now = DateTime.Now;
var date1 = new DateTime(now.Year, now.Month, now.Day, now.Hour, 0, 0).AddDays(3);
var date2 = date1.AddHours(1);
var date3 = date1.AddHours(2);
var event1 = ("e1", date1, date3);
var event2 = ("e1", date1, date3);
var event3 = ("e1", date1, date3);
var event4 = ("e2", date1, date3);
var event5 = ("e2", date1, date3);
var event6 = ("e2", date2, date3);
var event7 = ("e3", date1, date3);
var event8 = ("e3", date1, date2);
var event9 = ("e3x", date1, date3);
var allEvents = new[] { event1, event2, event3, event4, event5, event6, event7, event8, event9 };
foreach (var evt in allEvents)
{
await synchronizer.CreateEventInOutlook(evt.Item1, evt.Item2, evt.Item3);
}
await synchronizer.SynchronizeAndCheck(
unchangedA : 0, addedA : 9, changedA : 0, deletedA : 0,
unchangedB : 0, addedB : 0, changedB : 0, deletedB : 0,
createA : 0, updateA : 0, deleteA : 0,
createB : 9, updateB : 0, deleteB : 0);
var entities = (await synchronizer.Outlook.GetAllEntities()).Select(e => e.Entity).ToList();
Assert.That(
entities.Select(e => (e.Inner.Subject, e.Inner.Start, e.Inner.End)),
Is.EquivalentTo(allEvents));
entities.ForEach(e => e.Dispose());
((EventMappingConfiguration)options.MappingConfiguration).CleanupDuplicateEvents = true;
synchronizer = await CreateSynchronizer(options);
await synchronizer.SynchronizeAndCheck(
unchangedA : 9, addedA : 0, changedA : 0, deletedA : 0,
unchangedB : 9, addedB : 0, changedB : 0, deletedB : 0,
createA : 0, updateA : 0, deleteA : 0,
createB : 0, updateB : 0, deleteB : 0);
var entitiesAfterClenaup = (await synchronizer.Outlook.GetAllEntities()).Select(e => e.Entity).ToList();
Assert.That(
entitiesAfterClenaup.Select(e => (e.Inner.Subject, e.Inner.Start, e.Inner.End)),
Is.EquivalentTo(new[] { event1, event4, event6, event7, event8, event9 }));
entities.ForEach(e => e.Dispose());
}
