/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>runs an authentication test</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void ContactsAuthenticationTest()
{
Tracing.TraceMsg("Entering ContactsAuthenticationTest");
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);
ObjectModelHelper.DumpAtomObject(feed, CreateDumpFileName("ContactsAuthTest"));
if (feed != null && feed.Entries.Count > 0)
{
Tracing.TraceMsg("Found a Feed " + feed.ToString());
foreach (ContactEntry entry in feed.Entries)
{
Assert.IsTrue(entry.Etag != null, "contact entries should have etags");
}
}
}
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 authentication test</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void PhotosAuthenticationTest()
{
Tracing.TraceMsg("Entering PhotosAuthenticationTest");
PicasaQuery query = new PicasaQuery();
PicasaService service = new PicasaService("unittests");
query.KindParameter = "album,tag";
if (this.defaultPhotosUri != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
query.Uri = new Uri(this.defaultPhotosUri);
AtomFeed feed = service.Query(query);
ObjectModelHelper.DumpAtomObject(feed, CreateDumpFileName("PhotoAuthTest"));
if (feed != null && feed.Entries.Count > 0)
{
Tracing.TraceMsg("Found a Feed " + feed.ToString());
DisplayExtensions(feed);
foreach (AtomEntry entry in feed.Entries)
{
Tracing.TraceMsg("Found an entry " + entry.ToString());
DisplayExtensions(entry);
}
}
}
}
public void BloggerVersion2Test()
{
Tracing.TraceMsg("Entering BloggerVersion2Test");
BloggerQuery query = new BloggerQuery();
BloggerService service = new BloggerService(this.ApplicationName);
string title = "V1" + Guid.NewGuid().ToString();
service.ProtocolMajor = 1;
service.RequestFactory = this.factory;
query.Uri = new Uri(this.bloggerURI);
// insert a new entry in version 1
AtomEntry entry = ObjectModelHelper.CreateAtomEntry(1);
entry.Categories.Clear();
entry.Title.Text = title;
entry.IsDraft = true;
entry.ProtocolMajor = 12;
AtomEntry returnedEntry = service.Insert(new Uri(this.bloggerURI), entry);
Assert.IsTrue(returnedEntry.ProtocolMajor == service.ProtocolMajor);
Assert.IsTrue(entry.IsDraft);
Assert.IsTrue(returnedEntry.IsDraft);
BloggerFeed feed = service.Query(query);
Assert.IsTrue(feed.ProtocolMajor == service.ProtocolMajor);
if (feed != null)
{
Assert.IsTrue(feed.TotalResults >= feed.Entries.Count, "totalresults should be >= number of entries");
Assert.IsTrue(feed.Entries.Count > 0, "We should have some entries");
}
service.ProtocolMajor = 2;
feed = service.Query(query);
Assert.IsTrue(feed.ProtocolMajor == service.ProtocolMajor);
if (feed != null)
{
Assert.IsTrue(feed.Entries.Count > 0, "We should have some entries");
Assert.IsTrue(feed.TotalResults >= feed.Entries.Count, "totalresults should be >= number of entries");
foreach (BloggerEntry e in feed.Entries)
{
if (e.Title.Text == title)
{
Assert.IsTrue(e.ProtocolMajor == 2);
Assert.IsTrue(e.IsDraft);
}
}
}
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
/// <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 GoogleBaseBatchInsert()
{
Tracing.TraceMsg("Entering GoogleBaseBatchUpload");
FeedQuery query = new FeedQuery();
Service service = new GBaseService(this.ApplicationName, this.gBaseKey);
if (this.gBaseURI != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
service.RequestFactory = this.factory;
query.Uri = new Uri(this.gBaseURI);
AtomFeed baseFeed = service.Query(query);
// this should have a batch URI
Assert.IsTrue(baseFeed.Batch != null, "This is a base Feed, it should have batch URI");
AtomFeed batchFeed = new AtomFeed(new Uri(this.gBaseURI), service);
// set the default operation. Unneeded, as the default is insert,
// but want to make sure the code is complete
batchFeed.BatchData = new GDataBatchFeedData();
batchFeed.BatchData.Type = GDataBatchOperationType.delete;
for (int i = 0; i < 20; i++)
{
AtomEntry entry = ObjectModelHelper.CreateGoogleBaseEntry(i);
entry.BatchData = new GDataBatchEntryData();
entry.BatchData.Type = GDataBatchOperationType.insert;
entry.BatchData.Id = i.ToString();
batchFeed.Entries.Add(entry);
}
AtomFeed resultFeed = service.Batch(batchFeed, new Uri(baseFeed.Batch));
foreach (AtomEntry resultEntry in resultFeed.Entries)
{
GDataBatchEntryData data = resultEntry.BatchData;
Assert.IsTrue(data.Status.Code == 201, "Status code should be 201, is:" + data.Status.Code);
}
}
}
public void BloggerHTMLTest()
{
Tracing.TraceMsg("Entering BloggerHTMLTest");
FeedQuery query = new FeedQuery();
BloggerService service = new BloggerService(this.ApplicationName);
if (this.bloggerURI != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
service.RequestFactory = this.factory;
query.Uri = new Uri(this.bloggerURI);
AtomFeed feed = service.Query(query);
String strTitle = "Dinner time" + Guid.NewGuid().ToString();
if (feed != null)
{
// get the first entry
String htmlContent = "<div><b>this is an html test text</b></div>";
AtomEntry entry = ObjectModelHelper.CreateAtomEntry(1);
entry.Categories.Clear();
entry.Title.Text = strTitle;
entry.Content.Type = "html";
entry.Content.Content = htmlContent;
AtomEntry newEntry = feed.Insert(entry);
Tracing.TraceMsg("Created blogger entry");
// try to get just that guy.....
FeedQuery singleQuery = new FeedQuery();
singleQuery.Uri = new Uri(newEntry.SelfUri.ToString());
AtomFeed newFeed = service.Query(singleQuery);
AtomEntry sameGuy = newFeed.Entries[0];
Assert.IsTrue(sameGuy.Title.Text.Equals(newEntry.Title.Text), "both titles should be identical");
Assert.IsTrue(sameGuy.Content.Type.Equals("html"));
String input = HttpUtility.HtmlDecode(htmlContent);
String output = HttpUtility.HtmlDecode(sameGuy.Content.Content);
Assert.IsTrue(input.Equals(output), "The input string should be equal the output string");
}
service.Credentials = null;
}
}
protected override void Seed(AdvisorDbContext context)
{
// This method will be called after migrating to the latest version.
context.RvParks.AddOrUpdate(
ObjectModelHelper.NewRvPark(
"Trailer Inns RV Park of Bellevue/Seattle",
"425-747-9181",
"Trailer Inns of Bellevue, WA 98006"),
ObjectModelHelper.NewRvPark(
"Issaquah Village RV Par",
"425-392-9233",
"If you are looking for first-class service, you have come to the right place! "
+ "We put our customers first.Come visit to see what we are all about and have a relaxing stay. "
+ "We are here to serve you and answer any questions you may have")
);
}
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</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void GoogleAuthenticationTest()
{
Tracing.TraceMsg("Entering Documents List Authentication Test");
DocumentsListQuery query = new DocumentsListQuery();
DocumentsService service = new DocumentsService(this.ApplicationName);
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
service.RequestFactory = this.factory;
DocumentsFeed feed = service.Query(query) as DocumentsFeed;
ObjectModelHelper.DumpAtomObject(feed, CreateDumpFileName("AuthenticationTest"));
service.Credentials = null;
}
public void BloggerETagTest()
{
Tracing.TraceMsg("Entering BloggerETagTest");
BloggerQuery query = new BloggerQuery();
BloggerService service = new BloggerService(this.ApplicationName);
service.ProtocolMajor = 2;
string title = "V1" + Guid.NewGuid().ToString();
service.RequestFactory = this.factory;
query.Uri = new Uri(this.bloggerURI);
// insert a new entry in version 1
AtomEntry entry = ObjectModelHelper.CreateAtomEntry(1);
entry.Categories.Clear();
entry.Title.Text = title;
entry.IsDraft = true;
BloggerEntry returnedEntry = service.Insert(new Uri(this.bloggerURI), entry) as BloggerEntry;
Assert.IsTrue(returnedEntry.ProtocolMajor == service.ProtocolMajor);
Assert.IsTrue(entry.IsDraft);
Assert.IsTrue(returnedEntry.IsDraft);
Assert.IsTrue(returnedEntry.Etag != null);
string etagOld = returnedEntry.Etag;
returnedEntry.Content.Content = "This is a test";
BloggerEntry newEntry = returnedEntry.Update() as BloggerEntry;
Assert.IsTrue(newEntry.Etag != null);
Assert.IsTrue(newEntry.Etag != etagOld);
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <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);
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>runs an authentication test</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void BloggerStressTest()
{
Tracing.TraceMsg("Entering Blogger GoogleStressTest");
FeedQuery query = new FeedQuery();
BloggerService service = new BloggerService(this.ApplicationName);
if (this.bloggerURI != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
service.RequestFactory = this.factory;
query.Uri = new Uri(this.bloggerURI);
AtomFeed blogFeed = service.Query(query);
ObjectModelHelper.DumpAtomObject(blogFeed, CreateDumpFileName("AuthenticationTest"));
if (blogFeed != null)
{
for (int i = 0; i < 30; i++)
{
AtomEntry entry = ObjectModelHelper.CreateAtomEntry(i);
entry.Categories.Clear();
entry.Title.Text = "Title " + i;
entry.Content.Content = "Some text...";
entry.Content.Type = "html";
blogFeed.Insert(entry);
}
}
}
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>runs an authentication test, iterates all entries</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void QueryPhotosTest()
{
Tracing.TraceMsg("Entering PhotosQueryPhotosTest");
PhotoQuery query = new PhotoQuery();
PicasaService service = new PicasaService("unittests");
if (this.defaultPhotosUri != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
GDataLoggingRequestFactory factory = (GDataLoggingRequestFactory)this.factory;
factory.MethodOverride = true;
service.RequestFactory = this.factory;
query.Uri = new Uri(this.defaultPhotosUri);
PicasaFeed feed = service.Query(query);
ObjectModelHelper.DumpAtomObject(feed, CreateDumpFileName("PhotoAuthTest"));
if (feed != null && feed.Entries.Count > 0)
{
Tracing.TraceMsg("Found a Feed " + feed.ToString());
DisplayExtensions(feed);
foreach (PicasaEntry entry in feed.Entries)
{
Tracing.TraceMsg("Found an entry " + entry.ToString());
DisplayExtensions(entry);
GeoRssWhere w = entry.Location;
if (w != null)
{
Tracing.TraceMsg("Found an location " + w.Latitude + w.Longitude);
}
ExifTags tags = entry.Exif;
if (tags != null)
{
Tracing.TraceMsg("Found an exif block ");
}
MediaGroup group = entry.Media;
if (group != null)
{
Tracing.TraceMsg("Found a media Group");
if (group.Title != null)
{
Tracing.TraceMsg(group.Title.Value);
}
if (group.Keywords != null)
{
Tracing.TraceMsg(group.Keywords.Value);
}
if (group.Credit != null)
{
Tracing.TraceMsg(group.Credit.Value);
}
if (group.Description != null)
{
Tracing.TraceMsg(group.Description.Value);
}
}
PhotoAccessor photo = new PhotoAccessor(entry);
Assert.IsTrue(entry.IsPhoto, "this is a photo entry, it should have the kind set");
Assert.IsTrue(photo != null, "this is a photo entry, it should convert to PhotoEntry");
Assert.IsTrue(photo.AlbumId != null);
Assert.IsTrue(photo.Height > 0);
Assert.IsTrue(photo.Width > 0);
}
}
factory.MethodOverride = false;
}
}
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");
}
}
}
}
//////////////////////////////////////////////////////////////////////
/// <summary>runs an authentication test</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void GoogleBaseAuthenticationTest()
{
Tracing.TraceMsg("Entering Base AuthenticationTest");
FeedQuery query = new FeedQuery();
Service service = new GBaseService(this.ApplicationName, this.gBaseKey);
int iCount;
if (this.gBaseURI != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
service.RequestFactory = this.factory;
query.Uri = new Uri(this.gBaseURI);
AtomFeed baseFeed = service.Query(query);
// this should have a batch URI
Assert.IsTrue(baseFeed.Batch != null, "This is a base Feed, it should have batch URI");
ObjectModelHelper.DumpAtomObject(baseFeed, CreateDumpFileName("AuthenticationTest"));
iCount = baseFeed.Entries.Count;
String strTitle = "Dinner time" + Guid.NewGuid().ToString();
if (baseFeed != null && baseFeed.Entries.Count > 0)
{
// get the first entry
AtomEntry entry = baseFeed.Entries[0];
entry = ObjectModelHelper.CreateGoogleBaseEntry(1);
entry.Title.Text = strTitle;
GBaseEntry newEntry = baseFeed.Insert(entry) as GBaseEntry;
newEntry.PublishingPriority = new PublishingPriority("high");
GBaseEntry updatedEntry = newEntry.Update() as GBaseEntry;
// publishing priority does not seem to be echoed back
// Assert.IsTrue(updatedEntry.PublishingPriority.Value == "high");
iCount++;
Tracing.TraceMsg("Created google base entry");
// try to get just that guy.....
FeedQuery singleQuery = new FeedQuery();
singleQuery.Uri = new Uri(newEntry.SelfUri.ToString());
AtomFeed newFeed = service.Query(singleQuery);
AtomEntry sameGuy = newFeed.Entries[0];
Assert.IsTrue(sameGuy.Title.Text.Equals(newEntry.Title.Text), "both titles should be identical");
}
baseFeed = service.Query(query);
if (baseFeed != null && baseFeed.Entries.Count > 0)
{
// look for the one with dinner time...
foreach (AtomEntry entry in baseFeed.Entries)
{
Tracing.TraceMsg("Entrie title: " + entry.Title.Text);
if (String.Compare(entry.Title.Text, strTitle) == 0)
{
entry.Content.Content = "Maybe stay until breakfast";
entry.Content.Type = "text";
entry.Update();
Tracing.TraceMsg("Updated entry");
}
}
}
baseFeed = service.Query(query);
if (baseFeed != null && baseFeed.Entries.Count > 0)
{
// look for the one with dinner time...
foreach (AtomEntry entry in baseFeed.Entries)
{
Tracing.TraceMsg("Entrie title: " + entry.Title.Text);
if (String.Compare(entry.Title.Text, strTitle) == 0)
{
entry.Delete();
iCount--;
Tracing.TraceMsg("deleted entry");
}
}
}
baseFeed = service.Query(query);
service.Credentials = null;
}
}
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 a batch upload test</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void GoogleBaseBatchMix()
{
Tracing.TraceMsg("Entering GoogleBaseBatchMix");
FeedQuery query = new FeedQuery();
Service service = new GBaseService(this.ApplicationName, this.gBaseKey);
if (this.gBaseURI != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
service.RequestFactory = this.factory;
query.Uri = new Uri(this.gBaseURI);
AtomFeed baseFeed = service.Query(query);
// this should have a batch URI
Assert.IsTrue(baseFeed.Batch != null, "This is a base Feed, it should have batch URI");
AtomFeed batchFeed = new AtomFeed(baseFeed);
// set the default operation.
batchFeed.BatchData = new GDataBatchFeedData();
batchFeed.BatchData.Type = GDataBatchOperationType.insert;
int id = 1;
bool fUpdate = true;
foreach (AtomEntry entry in baseFeed.Entries)
{
AtomEntry batchEntry = batchFeed.Entries.CopyOrMove(entry);
if (fUpdate == true)
{
batchEntry.BatchData = new GDataBatchEntryData();
batchEntry.BatchData.Id = id.ToString();
batchEntry.BatchData.Type = GDataBatchOperationType.update;
batchEntry.Title.Text = "Updated";
fUpdate = false;
}
else
{
batchEntry.BatchData = new GDataBatchEntryData();
batchEntry.BatchData.Id = id.ToString();
batchEntry.BatchData.Type = GDataBatchOperationType.delete;
fUpdate = true;
}
// insert one
id++;
batchEntry = ObjectModelHelper.CreateGoogleBaseEntry(1);
batchEntry.BatchData = new GDataBatchEntryData();
batchEntry.BatchData.Type = GDataBatchOperationType.insert;
batchEntry.BatchData.Id = id.ToString();
batchFeed.Entries.Add(batchEntry);
id++;
}
AtomFeed resultFeed = service.Batch(batchFeed, new Uri(baseFeed.Batch));
foreach (AtomEntry resultEntry in resultFeed.Entries)
{
GDataBatchEntryData data = resultEntry.BatchData;
int testcode = 200;
if (data.Type == GDataBatchOperationType.insert)
{
testcode = 201;
}
Assert.IsTrue(data.Status.Code == testcode, "Status code should be: " + testcode + ", is:" + data.Status.Code);
}
}
}
//////////////////////////////////////////////////////////////////////
/// <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 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");
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
/// <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");
}
public void GoogleAuthenticationTest()
{
Tracing.TraceMsg("Entering Blogger AuthenticationTest");
BloggerQuery query = new BloggerQuery();
BloggerService service = new BloggerService(this.ApplicationName);
int iCount;
if (this.bloggerURI != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
service.RequestFactory = this.factory;
query.Uri = new Uri(this.bloggerURI);
BloggerFeed blogFeed = service.Query(query);
ObjectModelHelper.DumpAtomObject(blogFeed, CreateDumpFileName("AuthenticationTest"));
iCount = blogFeed.Entries.Count;
String strTitle = "Dinner time" + Guid.NewGuid().ToString();
if (blogFeed != null && blogFeed.Entries.Count > 0)
{
BloggerEntry entry = ObjectModelHelper.CreateAtomEntry(1) as BloggerEntry;
// blogger does not like labels yet.
entry.Categories.Clear();
entry.Title.Text = strTitle;
entry.Categories.Clear();
entry.IsDraft = true;
entry.Updated = Utilities.EmptyDate;
entry.Published = Utilities.EmptyDate;
BloggerEntry newEntry = blogFeed.Insert(entry);
iCount++;
Tracing.TraceMsg("Created blogger entry");
// try to get just that guy.....
BloggerQuery singleQuery = new BloggerQuery();
singleQuery.Uri = new Uri(newEntry.SelfUri.ToString());
BloggerFeed newFeed = service.Query(singleQuery);
BloggerEntry sameGuy = newFeed.Entries[0] as BloggerEntry;
Tracing.TraceMsg("retrieved blogger entry");
Assert.IsTrue(sameGuy.Title.Text.Equals(newEntry.Title.Text), "both titles should be identical");
Assert.IsTrue(sameGuy.IsDraft);
}
blogFeed = service.Query(query);
Assert.AreEqual(iCount, blogFeed.Entries.Count, "Feed should have one more entry, it has: " + blogFeed.Entries.Count);
if (blogFeed != null && blogFeed.Entries.Count > 0)
{
// look for the one with dinner time...
foreach (AtomEntry entry in blogFeed.Entries)
{
Tracing.TraceMsg("Entrie title: " + entry.Title.Text);
if (String.Compare(entry.Title.Text, strTitle) == 0)
{
entry.Content.Content = "Maybe stay until breakfast";
entry.Content.Type = "text";
entry.Update();
Tracing.TraceMsg("Updated entry");
}
}
}
blogFeed = service.Query(query);
Assert.AreEqual(iCount, blogFeed.Entries.Count, "Feed should have one more entry, it has: " + blogFeed.Entries.Count);
if (blogFeed != null && blogFeed.Entries.Count > 0)
{
// look for the one with dinner time...
foreach (AtomEntry entry in blogFeed.Entries)
{
Tracing.TraceMsg("Entrie title: " + entry.Title.Text);
if (String.Compare(entry.Title.Text, strTitle) == 0)
{
entry.Delete();
iCount--;
Tracing.TraceMsg("deleted entry");
}
}
}
blogFeed = service.Query(query);
Assert.AreEqual(iCount, blogFeed.Entries.Count, "Feed should have the same count again, it has: " + blogFeed.Entries.Count);
service.Credentials = null;
}
}
