///////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// /// <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; } }