public void OAuth2LeggedContactsTest()
{
Tracing.TraceMsg("Entering OAuth2LeggedContactsTest");
RequestSettings rs = new RequestSettings(this.ApplicationName, this.oAuthConsumerKey,
this.oAuthConsumerSecret, this.oAuthUser, this.oAuthDomain);
ContactsRequest cr = new ContactsRequest(rs);
Feed <Contact> f = cr.GetContacts();
// modify one
foreach (Contact c in f.Entries)
{
c.Title = "new title";
cr.Update(c);
break;
}
Contact entry = new Contact();
entry.AtomEntry = ObjectModelHelper.CreateContactEntry(1);
entry.PrimaryEmail.Address = "*****@*****.**";
Contact e = cr.Insert(f, entry);
cr.Delete(e);
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
/// <summary>runs an basic auth test against the groups feed test</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void GroupsModelTest()
{
Tracing.TraceMsg("Entering GroupsModelTest");
RequestSettings rs = new RequestSettings(this.ApplicationName, this.userName, this.passWord);
rs.AutoPaging = true;
ContactsRequest cr = new ContactsRequest(rs);
Feed <Group> fg = cr.GetGroups();
Group newGroup = new Group();
newGroup.Title = "Private Data";
Group insertedGroup = cr.Insert(fg, newGroup);
Group g2 = new Group();
g2.Title = "Another private Group";
Group insertedGroup2 = cr.Insert(fg, g2);
// now insert a new contact that belongs to that group
Feed <Contact> fc = cr.GetContacts();
Contact c = new Contact();
c.AtomEntry = ObjectModelHelper.CreateContactEntry(1);
GroupMembership member = new GroupMembership();
member.HRef = insertedGroup.Id;
GroupMembership member2 = new GroupMembership();
member2.HRef = insertedGroup2.Id;
Contact insertedEntry = cr.Insert(fc, c);
// now change the group membership
insertedEntry.GroupMembership.Add(member);
insertedEntry.GroupMembership.Add(member2);
Contact currentEntry = cr.Update(insertedEntry);
Assert.IsTrue(currentEntry.GroupMembership.Count == 2, "The entry should be in 2 groups");
currentEntry.GroupMembership.Clear();
currentEntry = cr.Update(currentEntry);
Assert.IsTrue(currentEntry.GroupMembership.Count == 0, "The entry should not be in a group");
cr.Delete(currentEntry);
cr.Delete(insertedGroup);
cr.Delete(insertedGroup2);
}
public void OAuth2LeggedModelContactsBatchInsertTest()
{
const int numberOfInserts = 10;
Tracing.TraceMsg("Entering OAuth2LeggedModelContactsBatchInsertTest");
RequestSettings rs = new RequestSettings(this.ApplicationName, this.oAuthConsumerKey,
this.oAuthConsumerSecret, this.oAuthUser, this.oAuthDomain);
ContactsTestSuite.DeleteAllContacts(rs);
rs.AutoPaging = true;
ContactsRequest cr = new ContactsRequest(rs);
Feed <Contact> f = cr.GetContacts();
int originalCount = f.TotalResults;
PhoneNumber p = null;
List <Contact> inserted = new List <Contact>();
if (f != null)
{
Assert.IsTrue(f.Entries != null, "the contacts needs entries");
for (int i = 0; i < numberOfInserts; i++)
{
Contact entry = new Contact();
entry.AtomEntry = ObjectModelHelper.CreateContactEntry(i);
entry.PrimaryEmail.Address = "joe" + i.ToString() + "@doe.com";
p = entry.PrimaryPhonenumber;
inserted.Add(cr.Insert(f, entry));
}
}
List <Contact> list = new List <Contact>();
f = cr.GetContacts();
foreach (Contact e in f.Entries)
{
list.Add(e);
}
Assert.AreEqual(numberOfInserts, inserted.Count);
// now delete them again
ContactsTestSuite.DeleteList(inserted, cr, new Uri(f.AtomFeed.Batch));
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>runs an authentication test, inserts a new contact</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void ModelPhotoTest()
{
Tracing.TraceMsg("Entering ModelPhotoTest");
RequestSettings rs = new RequestSettings(this.ApplicationName, this.userName, this.passWord);
rs.AutoPaging = true;
ContactsRequest cr = new ContactsRequest(rs);
Feed <Contact> f = cr.GetContacts();
Contact e = null;
if (f != null)
{
Contact entry = new Contact();
entry.AtomEntry = ObjectModelHelper.CreateContactEntry(1);
entry.PrimaryEmail.Address = "*****@*****.**";
e = cr.Insert(f, entry);
}
Assert.IsTrue(e != null, "we should have a contact here");
Stream s = cr.GetPhoto(e);
Assert.IsTrue(s == null, "There should be no photo yet");
using (FileStream fs = new FileStream(this.resourcePath + "contactphoto.jpg", System.IO.FileMode.Open))
{
cr.SetPhoto(e, fs);
}
// now delete the guy, which requires us to reload him from the server first, as the photo change operation
// changes the etag off the entry
e = cr.Retrieve(e);
cr.Delete(e);
}
public void OAuth2LeggedModelContactsBatchInsertTest()
{
const int numberOfInserts = 37;
Tracing.TraceMsg("Entering OAuth2LeggedModelContactsBatchInsertTest");
RequestSettings rs = new RequestSettings(this.ApplicationName, this.oAuthConsumerKey, this.oAuthConsumerSecret,
this.oAuthUser, this.oAuthDomain);
ContactsTestSuite.DeleteAllContacts(rs);
rs.AutoPaging = true;
ContactsRequest cr = new ContactsRequest(rs);
Feed <Contact> f = cr.GetContacts();
int originalCount = f.TotalResults;
PhoneNumber p = null;
List <Contact> inserted = new List <Contact>();
if (f != null)
{
Assert.IsTrue(f.Entries != null, "the contacts needs entries");
for (int i = 0; i < numberOfInserts; i++)
{
Contact entry = new Contact();
entry.AtomEntry = ObjectModelHelper.CreateContactEntry(i);
entry.PrimaryEmail.Address = "joe" + i.ToString() + "@doe.com";
p = entry.PrimaryPhonenumber;
inserted.Add(cr.Insert(f, entry));
}
}
List <Contact> list = new List <Contact>();
f = cr.GetContacts();
foreach (Contact e in f.Entries)
{
list.Add(e);
}
if (inserted.Count > 0)
{
int iVer = numberOfInserts;
// let's find those guys
for (int i = 0; i < inserted.Count; i++)
{
Contact test = inserted[i];
foreach (Contact e in list)
{
if (e.Id == test.Id)
{
iVer--;
// verify we got the phonenumber back....
Assert.IsTrue(e.PrimaryPhonenumber != null, "They should have a primary phonenumber");
Assert.AreEqual(e.PrimaryPhonenumber.Value, p.Value, "They should be identical");
}
}
}
Assert.IsTrue(iVer == 0, "The new entries should all be part of the feed now, " + iVer + " left over");
}
// now delete them again
ContactsTestSuite.DeleteList(inserted, cr, new Uri(f.AtomFeed.Batch));
// now make sure they are gone
if (inserted.Count > 0)
{
f = cr.GetContacts();
Assert.IsTrue(f.TotalResults == originalCount, "The count should be correct as well");
foreach (Contact e in f.Entries)
{
// let's find those guys, we should not find ANY
for (int i = 0; i < inserted.Count; i++)
{
Contact test = inserted[i] as Contact;
Assert.IsTrue(e.Id != test.Id, "The new entries should all be deleted now");
}
}
}
}
public void ModelUpdateIfMatchAllContactsTest()
{
const int numberOfInserts = 5;
Tracing.TraceMsg("Entering ModelInsertContactsTest");
DeleteAllContacts();
RequestSettings rs = new RequestSettings(this.ApplicationName, this.userName, this.passWord);
rs.AutoPaging = true;
ContactsRequest cr = new ContactsRequest(rs);
Feed <Contact> f = cr.GetContacts();
int originalCount = f.TotalResults;
PhoneNumber p = null;
List <Contact> inserted = new List <Contact>();
if (f != null)
{
Assert.IsTrue(f.Entries != null, "the contacts needs entries");
for (int i = 0; i < numberOfInserts; i++)
{
Contact entry = new Contact();
entry.AtomEntry = ObjectModelHelper.CreateContactEntry(i);
entry.PrimaryEmail.Address = "joe" + i.ToString() + "@doe.com";
p = entry.PrimaryPhonenumber;
inserted.Add(cr.Insert(f, entry));
}
}
string newTitle = "This is an update to the title";
f = cr.GetContacts();
if (inserted.Count > 0)
{
int iVer = numberOfInserts;
// let's find those guys
foreach (Contact e in f.Entries)
{
for (int i = 0; i < inserted.Count; i++)
{
Contact test = inserted[i];
if (e.Id == test.Id)
{
iVer--;
// verify we got the phonenumber back....
Assert.IsTrue(e.PrimaryPhonenumber != null, "They should have a primary phonenumber");
Assert.AreEqual(e.PrimaryPhonenumber.Value, p.Value, "They should be identical");
e.Name.FamilyName = newTitle;
e.ETag = GDataRequestFactory.IfMatchAll;
inserted[i] = cr.Update(e);
}
}
}
Assert.IsTrue(iVer == 0, "The new entries should all be part of the feed now, we have " + iVer + " left");
}
f = cr.GetContacts();
if (inserted.Count > 0)
{
int iVer = numberOfInserts;
// let's find those guys
foreach (Contact e in f.Entries)
{
for (int i = 0; i < inserted.Count; i++)
{
Contact test = inserted[i];
if (e.Id == test.Id)
{
iVer--;
// verify we got the phonenumber back....
Assert.IsTrue(e.PrimaryPhonenumber != null, "They should have a primary phonenumber");
Assert.AreEqual(e.PrimaryPhonenumber.Value, p.Value, "They should be identical");
Assert.AreEqual(e.Name.FamilyName, newTitle, "The familyname should have been updated");
}
}
}
Assert.IsTrue(iVer == 0, "The new entries should all be part of the feed now, we have: " + iVer + " now");
}
// now delete them again
DeleteList(inserted, cr, new Uri(f.AtomFeed.Batch));
// now make sure they are gone
if (inserted.Count > 0)
{
int iVer = inserted.Count;
f = cr.GetContacts();
foreach (Contact e in f.Entries)
{
// let's find those guys, we should not find ANY
for (int i = 0; i < inserted.Count; i++)
{
Contact test = inserted[i] as Contact;
Assert.IsTrue(e.Id != test.Id, "The new entries should all be deleted now");
}
}
Assert.IsTrue(f.TotalResults == originalCount, "The count should be correct as well");
}
}
//////////////////////////////////////////////////////////////////////
/// <summary>runs an authentication test, inserts a new contact</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void InsertContactsTest()
{
const int numberOfInserts = 37;
Tracing.TraceMsg("Entering InsertContactsTest");
ContactsQuery query = new ContactsQuery(ContactsQuery.CreateContactsUri(this.userName + "@googlemail.com"));
ContactsService service = new ContactsService("unittests");
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
ContactsFeed feed = service.Query(query);
int originalCount = feed.Entries.Count;
PhoneNumber p = null;
List <ContactEntry> inserted = new List <ContactEntry>();
if (feed != null)
{
Assert.IsTrue(feed.Entries != null, "the contacts needs entries");
for (int i = 0; i < numberOfInserts; i++)
{
ContactEntry entry = ObjectModelHelper.CreateContactEntry(i);
entry.PrimaryEmail.Address = "joe" + i.ToString() + "@doe.com";
p = entry.PrimaryPhonenumber;
inserted.Add(feed.Insert(entry));
}
}
List <ContactEntry> list = new List <ContactEntry>();
feed = service.Query(query);
foreach (ContactEntry e in feed.Entries)
{
list.Add(e);
}
while (feed.NextChunk != null)
{
ContactsQuery nq = new ContactsQuery(feed.NextChunk);
feed = service.Query(nq);
foreach (ContactEntry e in feed.Entries)
{
list.Add(e);
}
}
if (inserted.Count > 0)
{
int iVer = numberOfInserts;
// let's find those guys
for (int i = 0; i < inserted.Count; i++)
{
ContactEntry test = inserted[i] as ContactEntry;
foreach (ContactEntry e in list)
{
if (e.Id == test.Id)
{
iVer--;
// verify we got the phonenumber back....
Assert.IsTrue(e.PrimaryPhonenumber != null, "They should have a primary phonenumber");
Assert.AreEqual(e.PrimaryPhonenumber.Value, p.Value, "They should be identical");
}
}
}
Assert.IsTrue(iVer == 0, "The new entries should all be part of the feed now, we have " + iVer + " now");
}
// now delete them again
foreach (ContactEntry e in inserted)
{
e.Delete();
}
// now make sure they are gone
if (inserted.Count > 0)
{
feed = service.Query(query);
// let's find those guys, we should not find ANY
for (int i = 0; i < inserted.Count; i++)
{
ContactEntry test = inserted[i] as ContactEntry;
foreach (ContactEntry e in feed.Entries)
{
Assert.IsTrue(e.Id != test.Id, "The new entries should all be deleted now");
}
}
Assert.IsTrue(feed.Entries.Count == originalCount, "The count should be correct as well");
}
}
public void ConflictContactsTest()
{
const int numberOfInserts = 50;
const int numberWithAdds = 60;
Tracing.TraceMsg("Entering InsertContactsTest");
ContactsQuery query = new ContactsQuery(ContactsQuery.CreateContactsUri(this.userName + "@googlemail.com"));
ContactsService service = new ContactsService("unittests");
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
// clean the contacts feed
DeleteAllContacts();
ContactsFeed feed = service.Query(query);
int originalCount = feed.Entries.Count;
string email = Guid.NewGuid().ToString();
List <ContactEntry> inserted = new List <ContactEntry>();
// insert a number of guys
for (int i = 0; i < numberOfInserts; i++)
{
ContactEntry entry = ObjectModelHelper.CreateContactEntry(i);
entry.PrimaryEmail.Address = email + i.ToString() + "@doe.com";
entry = feed.Insert(entry);
AddContactPhoto(entry, service);
inserted.Add(entry);
}
if (feed != null)
{
for (int x = numberOfInserts; x <= numberWithAdds; x++)
{
for (int i = 0; i < x; i++)
{
ContactEntry entry = ObjectModelHelper.CreateContactEntry(i);
entry.PrimaryEmail.Address = email + i.ToString() + "@doe.com";
try
{
entry = feed.Insert(entry);
AddContactPhoto(entry, service);
inserted.Add(entry);
}
catch (GDataRequestException)
{
}
}
}
}
List <ContactEntry> list = new List <ContactEntry>();
feed = service.Query(query);
foreach (ContactEntry e in feed.Entries)
{
list.Add(e);
}
while (feed.NextChunk != null)
{
ContactsQuery nq = new ContactsQuery(feed.NextChunk);
feed = service.Query(nq);
foreach (ContactEntry e in feed.Entries)
{
list.Add(e);
}
}
Assert.AreEqual(list.Count, numberWithAdds - originalCount, "We should have added new entries");
// clean the contacts feed
DeleteAllContacts();
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
/// <summary>runs an basic auth test against the groups feed test</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void GroupsSystemTest()
{
Tracing.TraceMsg("Entering GroupsSystemTest");
GroupsQuery query = new GroupsQuery(ContactsQuery.CreateGroupsUri(this.userName + "@googlemail.com"));
ContactsService service = new ContactsService("unittests");
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
GroupsFeed feed = service.Query(query);
int i = 0;
foreach (GroupEntry g in feed.Entries)
{
if (g.SystemGroup != null)
{
i++;
}
}
Assert.IsTrue(i == 4, "There should be 4 system groups in the groups feed");
ObjectModelHelper.DumpAtomObject(feed, CreateDumpFileName("GroupsAuthTest"));
GroupEntry newGroup = new GroupEntry();
newGroup.Title.Text = "Private Data";
GroupEntry insertedGroup = feed.Insert(newGroup);
GroupEntry g2 = new GroupEntry();
g2.Title.Text = "Another Private Group";
GroupEntry insertedGroup2 = feed.Insert(g2);
// now insert a new contact that belongs to that group
ContactsQuery q = new ContactsQuery(ContactsQuery.CreateContactsUri(this.userName + "@googlemail.com"));
ContactsFeed cf = service.Query(q);
ContactEntry entry = ObjectModelHelper.CreateContactEntry(1);
GroupMembership member = new GroupMembership();
member.HRef = insertedGroup.Id.Uri.ToString();
GroupMembership member2 = new GroupMembership();
member2.HRef = insertedGroup2.Id.Uri.ToString();
ContactEntry insertedEntry = cf.Insert(entry);
// now change the group membership
insertedEntry.GroupMembership.Add(member);
insertedEntry.GroupMembership.Add(member2);
ContactEntry currentEntry = insertedEntry.Update();
Assert.IsTrue(currentEntry.GroupMembership.Count == 2, "The entry should be in 2 groups");
currentEntry.GroupMembership.Clear();
currentEntry = currentEntry.Update();
// now we should have 2 new groups and one new entry with no groups anymore
int oldCountGroups = feed.Entries.Count;
int oldCountContacts = cf.Entries.Count;
currentEntry.Delete();
insertedGroup.Delete();
insertedGroup2.Delete();
feed = service.Query(query);
cf = service.Query(q);
Assert.AreEqual(oldCountContacts, cf.Entries.Count, "Contacts count should be the same");
Assert.AreEqual(oldCountGroups, feed.Entries.Count, "Groups count should be the same");
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>runs an authentication test, inserts a new contact</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void ModelBatchContactsTest()
{
const int numberOfInserts = 5;
Tracing.TraceMsg("Entering ModelInsertContactsTest");
DeleteAllContacts();
RequestSettings rs = new RequestSettings(this.ApplicationName, this.userName, this.passWord);
rs.AutoPaging = true;
ContactsRequest cr = new ContactsRequest(rs);
List <Contact> list = new List <Contact>();
Feed <Contact> f = cr.GetContacts();
for (int i = 0; i < numberOfInserts; i++)
{
Contact entry = new Contact();
entry.AtomEntry = ObjectModelHelper.CreateContactEntry(i);
entry.PrimaryEmail.Address = "joe" + i.ToString() + "@doe.com";
GDataBatchEntryData g = new GDataBatchEntryData();
g.Id = i.ToString();
g.Type = GDataBatchOperationType.insert;
entry.BatchData = g;
list.Add(entry);
}
Feed <Contact> r = cr.Batch(list, new Uri(f.AtomFeed.Batch), GDataBatchOperationType.Default);
list.Clear();
int iVerify = 0;
foreach (Contact c in r.Entries)
{
// let's count and update them
iVerify++;
c.Name.FamilyName = "get a nother one";
c.BatchData.Type = GDataBatchOperationType.update;
list.Add(c);
}
Assert.IsTrue(iVerify == numberOfInserts, "should have gotten 5 inserts");
Feed <Contact> u = cr.Batch(list, new Uri(f.AtomFeed.Batch), GDataBatchOperationType.Default);
list.Clear();
iVerify = 0;
foreach (Contact c in u.Entries)
{
// let's count and update them
iVerify++;
c.BatchData.Type = GDataBatchOperationType.delete;
list.Add(c);
}
Assert.IsTrue(iVerify == numberOfInserts, "should have gotten 5 updates");
Feed <Contact> d = cr.Batch(list, new Uri(f.AtomFeed.Batch), GDataBatchOperationType.Default);
iVerify = 0;
foreach (Contact c in d.Entries)
{
if (c.BatchData.Status.Code == 200)
{
// let's count and update them
iVerify++;
}
}
Assert.IsTrue(iVerify == numberOfInserts, "should have gotten 5 deletes");
}