public async Task SearchTopicsTestUsingEmptyString()
{
// ***********************************************
// ** NOTE ** - Verification might change if design is set to not return anything vs return everything
// ***********************************************
SocialPlusClient client1 = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
PostUserResponse postUserResponse;
string firstName = "FirstUser";
string lastName = "FirstUserLastName";
string bio = string.Empty;
postUserResponse = await TestUtilities.DoLogin(client1, firstName, lastName, bio);
string auth = AuthHelper.CreateSocialPlusAuth(postUserResponse.SessionToken);
// First Topic
string topicTitle = "My Favorite Topic";
string topicText = "Sports. ";
BlobType blobType = BlobType.Image;
string blobHandle = "http://myBlobHandle/";
string language = "en-US";
string deepLink = "Sports!";
string categories = "sports, ncurrency";
string friendlyName = "Game On!";
string group = "mygroup";
PostTopicRequest postTopicRequest = new PostTopicRequest(publisherType: PublisherType.User, text: topicText, title: topicTitle, blobType: blobType, blobHandle: blobHandle, language: language, deepLink: deepLink, categories: categories, friendlyName: friendlyName, group: group);
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse = await client1.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest, authorization : auth);
// If the post topic operation failed, clean up
if (postTopicOperationResponse == null || postTopicOperationResponse.Body == null || string.IsNullOrWhiteSpace(postTopicOperationResponse.Body.TopicHandle))
{
await client1.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to post topic");
}
// Delay a bit to allow data to get into the search
await Task.Delay(TestConstants.SearchDelay);
// Only one result
HttpOperationResponse <FeedResponseTopicView> search1 = await client1.Search.GetTopicsWithHttpMessagesAsync(query : string.Empty, cursor : null, limit : 5, authorization : auth);
// Clean up topic
HttpOperationResponse <object> deleteTopic1 = await client1.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : postTopicOperationResponse.Body.TopicHandle, authorization : auth);
// Clean up first user
HttpOperationResponse <object> deleteUser1 = await client1.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
// Verify now - get info
Assert.AreEqual(search1.Response.StatusCode, HttpStatusCode.BadRequest);
// Verify deletions
Assert.IsTrue(deleteTopic1.Response.IsSuccessStatusCode);
Assert.IsTrue(deleteUser1.Response.IsSuccessStatusCode);
}
/// <summary>
/// Create a topic
/// </summary>
/// <param name="publisherType">publisher type</param>
/// <returns>result of create topic operation</returns>
public async Task <IHttpActionResult> PostTopic(PublisherType publisherType)
{
var postTopicRequest = new PostTopicRequest
{
PublisherType = publisherType,
Text = "Text" + this.seqNumber.GenerateStronglyOrderedSequenceNumber()
};
return(await this.PostTopic(postTopicRequest));
}
/// <summary>
/// Helper routine for posting a generic topic.
/// </summary>
/// <param name="client">Client object</param>
/// <param name="auth">authorization header value</param>
/// <returns>A post topic response</returns>
public static async Task <PostTopicResponse> PostGenericTopic(SocialPlusClient client, string auth)
{
string uniqueSuffix = TestUtilities.CreateUniqueDigits();
string topicTitle = "Topic Title" + uniqueSuffix;
string topicText = "Topic text is a long description" + uniqueSuffix;
BlobType blobType = BlobType.Image;
string blobHandle = "http://myBlobHandle/" + uniqueSuffix;
string language = "en-US";
PostTopicRequest postTopicRequest = new PostTopicRequest(publisherType: PublisherType.User, text: topicText, title: topicTitle, blobType: blobType, blobHandle: blobHandle, language: language);
var httpResponse = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest, authorization : auth);
if (httpResponse == null || httpResponse.Response == null || !httpResponse.Response.IsSuccessStatusCode)
{
throw new InvalidOperationException(string.Format("PostGenericTopic failed for auth {0} with status code {1}", auth, httpResponse.Response.StatusCode));
}
return(httpResponse.Body);
}
public async Task <ActionResult <int> > InsertTopic([FromBody] PostTopicRequest model)
{
var rs = await _topicService.AddTopic(model.Name, model.Description, model.NameEng, model.DescriptionEng, model.Image, model.StartDate, model.Username);
return(Ok(rs));
}
/// <summary>
/// Helper routine to perform the main actions of the test
/// Create a topic, comment and reply. Like the comment and the reply. Then delete
/// both the comment like and the reply like.
/// </summary>
/// <param name="appPublished">flag to indicate if topic is app published</param>
/// <param name="appHandle">app handle</param>
/// <returns>Fail if an exception is hit</returns>
public async Task LikeCommentReplyDeleteTestHelper(bool appPublished, string appHandle)
{
// Set up initial login etc
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
PostUserResponse postUserResponse;
string firstName = "R2D2";
string lastName = "Robot";
string bio = string.Empty;
postUserResponse = await TestUtilities.DoLogin(client, firstName, lastName, bio);
string auth = AuthHelper.CreateSocialPlusAuth(postUserResponse.SessionToken);
string userHandle = postUserResponse.UserHandle;
if (appPublished)
{
// add user as admin
bool added = ManageAppsUtils.AddAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
if (!added)
{
// delete the user and fail the test
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to set user as administrator");
}
}
string topicTitle = "Topic for Like Reply Test";
string topicText = "Verify the Like Reply!";
BlobType blobType = BlobType.Unknown;
string blobHandle = "http://myBlobHandle/";
string language = "en-US";
string deepLink = "Like It!";
string categories = "#likes; #reply";
string friendlyName = "LT";
string group = "mygroup";
string topicHandle = string.Empty;
var postTopicRequest = new PostTopicRequest()
{
Title = topicTitle, Text = topicText, BlobType = blobType, BlobHandle = blobHandle, Language = language, DeepLink = deepLink, Categories = categories, FriendlyName = friendlyName, Group = group
};
if (appPublished)
{
postTopicRequest.PublisherType = PublisherType.App;
}
else
{
postTopicRequest.PublisherType = PublisherType.User;
}
var postTopicOperationResponse = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest, authorization : auth);
if (postTopicOperationResponse.Response.IsSuccessStatusCode)
{
// extract topic handle from the response
topicHandle = postTopicOperationResponse.Body.TopicHandle;
}
else
{
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Post topic failed.");
}
// Post a comment to topic
string commentHandle = string.Empty;
var postCommentRequest = new PostCommentRequest()
{
Text = "My First Comment!", Language = "en-US"
};
var postCommentOperationResponse = await client.TopicComments.PostCommentWithHttpMessagesAsync(topicHandle : topicHandle, request : postCommentRequest, authorization : auth);
if (postCommentOperationResponse.Response.IsSuccessStatusCode)
{
commentHandle = postCommentOperationResponse.Body.CommentHandle;
}
else
{
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Post comment failed.");
}
// Post a reply to the comment to topic
string replyHandle = string.Empty;
var postReplyRequest = new PostReplyRequest()
{
Text = "My First Reply", Language = "en-US"
};
var postReplyOperationResponse = await client.CommentReplies.PostReplyWithHttpMessagesAsync(commentHandle, request : postReplyRequest, authorization : auth);
if (postReplyOperationResponse.Response.IsSuccessStatusCode)
{
replyHandle = postReplyOperationResponse.Body.ReplyHandle;
}
else
{
await client.Comments.DeleteCommentWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Post reply failed.");
}
// Post a like on the Comment
var postLikeOperationResponse = await client.CommentLikes.PostLikeWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
if (!postLikeOperationResponse.Response.IsSuccessStatusCode)
{
await client.Replies.DeleteReplyWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
await client.Comments.DeleteCommentWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Post like on comment failed.");
}
// Post a like on the Reply
var postLikeOperationResponse2 = await client.ReplyLikes.PostLikeWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
if (!postLikeOperationResponse2.Response.IsSuccessStatusCode)
{
await client.CommentLikes.DeleteLikeWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
await client.Replies.DeleteReplyWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
await client.Comments.DeleteCommentWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Post like on reply failed.");
}
// Get topic to later verify
var getTopicOperationResponse = await client.Topics.GetTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (!getTopicOperationResponse.Response.IsSuccessStatusCode)
{
await client.ReplyLikes.DeleteLikeWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
await client.CommentLikes.DeleteLikeWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
await client.Replies.DeleteReplyWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
await client.Comments.DeleteCommentWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Get topic failed.");
}
// Get comment to later verify the like is there
var getCommentOperationResponse = await client.Comments.GetCommentWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
if (!getCommentOperationResponse.Response.IsSuccessStatusCode)
{
await client.ReplyLikes.DeleteLikeWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
await client.CommentLikes.DeleteLikeWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
await client.Replies.DeleteReplyWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
await client.Comments.DeleteCommentWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Get comment failed.");
}
// Get reply to later verify the like is there
var getReplyOperationResponse = await client.Replies.GetReplyWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
if (!getReplyOperationResponse.Response.IsSuccessStatusCode)
{
await client.ReplyLikes.DeleteLikeWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
await client.CommentLikes.DeleteLikeWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
await client.Replies.DeleteReplyWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
await client.Comments.DeleteCommentWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Get reply failed.");
}
var deleteReplyLikeOperationResult = await client.ReplyLikes.DeleteLikeWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
if (!deleteReplyLikeOperationResult.Response.IsSuccessStatusCode)
{
await client.CommentLikes.DeleteLikeWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
await client.Replies.DeleteReplyWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
await client.Comments.DeleteCommentWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Delete reply like failed.");
}
var deleteCommentLikeOperationResult = await client.CommentLikes.DeleteLikeWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
if (!deleteCommentLikeOperationResult.Response.IsSuccessStatusCode)
{
await client.Replies.DeleteReplyWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
await client.Comments.DeleteCommentWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Delete comment like failed.");
}
// Get comment a second time to verify the like is gone
var getCommentOperationResponse2 = await client.Comments.GetCommentWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
if (!getCommentOperationResponse2.Response.IsSuccessStatusCode)
{
await client.Replies.DeleteReplyWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
await client.Comments.DeleteCommentWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Get comment failed.");
}
// Get reply a second time to verify the like is gone
var getReplyOperationResponse2 = await client.Replies.GetReplyWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
if (!getReplyOperationResponse2.Response.IsSuccessStatusCode)
{
await client.Replies.DeleteReplyWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
await client.Comments.DeleteCommentWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Get reply failed.");
}
// perform standard cleanup of the operations before checking assertions
await client.Replies.DeleteReplyWithHttpMessagesAsync(replyHandle : replyHandle, authorization : auth);
await client.Comments.DeleteCommentWithHttpMessagesAsync(commentHandle : commentHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
var getTopicResponse = getTopicOperationResponse.Body;
var getCommentResponse = getCommentOperationResponse.Body;
var getReplyResponse = getReplyOperationResponse.Body;
var getCommentResponse2 = getCommentOperationResponse2.Body;
var getReplyResponse2 = getReplyOperationResponse2.Body;
// Verify topic info
Assert.AreEqual(getTopicResponse.Liked, false);
Assert.AreEqual(getTopicResponse.Text, topicText);
Assert.AreEqual(getTopicResponse.BlobType, BlobType.Unknown);
Assert.AreEqual(getTopicResponse.BlobHandle, blobHandle);
Assert.AreEqual(getTopicResponse.Language, language);
Assert.AreEqual(getTopicResponse.DeepLink, deepLink);
Assert.AreEqual(getTopicResponse.Categories, categories);
Assert.AreEqual(getTopicResponse.FriendlyName, friendlyName);
Assert.AreEqual(getTopicResponse.Group, group);
Assert.AreEqual(getTopicResponse.TotalComments, 1);
Assert.AreEqual(getTopicResponse.TotalLikes, 0);
// Verify comment info
Assert.AreEqual(getCommentResponse.Liked, true);
Assert.AreEqual(getCommentResponse.Text, "My First Comment!");
Assert.AreEqual(getCommentResponse.Language, "en-US");
Assert.AreEqual(getCommentResponse.TotalReplies, 1);
Assert.AreEqual(getCommentResponse.TotalLikes, 1);
// Verify reply info
Assert.AreEqual(getReplyResponse.Liked, true);
Assert.AreEqual(getReplyResponse.Text, "My First Reply");
Assert.AreEqual(getReplyResponse.Language, "en-US");
Assert.AreEqual(getReplyResponse.TotalLikes, 1);
// Verify comment info
Assert.AreEqual(getCommentResponse2.Liked, false);
Assert.AreEqual(getCommentResponse2.Text, "My First Comment!");
Assert.AreEqual(getCommentResponse2.Language, "en-US");
Assert.AreEqual(getCommentResponse2.TotalReplies, 1);
Assert.AreEqual(getCommentResponse2.TotalLikes, 0);
// Verify reply info
Assert.AreEqual(getReplyResponse2.Liked, false);
Assert.AreEqual(getReplyResponse2.Text, "My First Reply");
Assert.AreEqual(getReplyResponse2.Language, "en-US");
Assert.AreEqual(getReplyResponse2.TotalLikes, 0);
}
public async Task BatchTestMultiGetTopics()
{
// Set up initial login etc
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
string firstName = "Stan";
string lastName = "TopicMan";
string bio = string.Empty;
PostUserResponse postUserResponse = await TestUtilities.DoLogin(client, firstName, lastName, bio);
string auth = AuthHelper.CreateSocialPlusAuth(postUserResponse.SessionToken);
string topicTitle1 = "My Favorite Topic";
string topicText1 = "It is all about sports!";
BlobType blobType = BlobType.Image;
string blobHandle = "http://myBlobHandle/";
string language = "en-US";
string deepLink = "Sports!";
string categories = "sports, ncurrency";
string friendlyName = "Game On!";
string group = "mygroup";
PostTopicRequest postTopicRequest1 = new PostTopicRequest(publisherType: PublisherType.User, text: topicText1, title: topicTitle1, blobType: blobType, blobHandle: blobHandle, categories: categories, language: language, deepLink: deepLink, friendlyName: friendlyName, group: group);
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse1 = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest1, authorization : auth);
string topicTitle2 = "My Favorite Topic #2";
string topicText2 = "Maybe it isn't all about sports?";
PostTopicRequest postTopicRequest2 = new PostTopicRequest(publisherType: PublisherType.User, text: topicText2, title: topicTitle2, blobType: blobType, blobHandle: blobHandle, categories: categories, language: language, deepLink: deepLink, friendlyName: friendlyName, group: group);
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse2 = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest2, authorization : auth);
// extract topic handles from the responses
var topicHandle1 = postTopicOperationResponse1.Body.TopicHandle;
var topicHandle2 = postTopicOperationResponse2.Body.TopicHandle;
// create a new batch operation
Uri batchURL = new Uri(TestConstants.ServerApiBaseUrl.OriginalString + "batch");
BatchHttpMessageHandler batchHandler = new BatchHttpMessageHandler(HttpMethod.Post, batchURL);
// Create a batch client
DelegatingHandler[] handlers = new DelegatingHandler[1];
handlers[0] = batchHandler;
SocialPlusClient batchClient = new SocialPlusClient(TestConstants.ServerApiBaseUrl, handlers);
// put two calls to GetTopic inside the batch
Task <HttpOperationResponse <TopicView> > getTopic1 = batchClient.Topics.GetTopicWithHttpMessagesAsync(topicHandle1, auth);
Task <HttpOperationResponse <TopicView> > getTopic2 = batchClient.Topics.GetTopicWithHttpMessagesAsync(topicHandle2, auth);
// send the batch to the server
await batchHandler.IssueBatch();
// process the individual results from the batch
var topicResult1 = await getTopic1;
var topicResult2 = await getTopic2;
// clean up
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle1, auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle2, auth);
await client.Users.DeleteUserWithHttpMessagesAsync(auth);
// after clean up, check that the get topic operations inside the batch were successful
Assert.AreEqual(categories, topicResult1.Body.Categories);
Assert.AreEqual(ContentStatus.Active, topicResult1.Body.ContentStatus);
Assert.AreEqual(deepLink, topicResult1.Body.DeepLink);
Assert.AreEqual(friendlyName, topicResult1.Body.FriendlyName);
Assert.AreEqual(group, topicResult1.Body.Group);
Assert.AreEqual(language, topicResult1.Body.Language);
Assert.AreEqual(false, topicResult1.Body.Liked);
Assert.AreEqual(false, topicResult1.Body.Pinned);
Assert.AreEqual(PublisherType.User, topicResult1.Body.PublisherType);
Assert.AreEqual(topicText1, topicResult1.Body.Text);
Assert.AreEqual(topicTitle1, topicResult1.Body.Title);
Assert.AreEqual(topicHandle1, topicResult1.Body.TopicHandle);
Assert.AreEqual(0, topicResult1.Body.TotalComments);
Assert.AreEqual(0, topicResult1.Body.TotalLikes);
Assert.AreEqual(firstName, topicResult1.Body.User.FirstName);
Assert.AreEqual(lastName, topicResult1.Body.User.LastName);
Assert.AreEqual(postUserResponse.UserHandle, topicResult1.Body.User.UserHandle);
Assert.AreEqual(categories, topicResult2.Body.Categories);
Assert.AreEqual(ContentStatus.Active, topicResult2.Body.ContentStatus);
Assert.AreEqual(deepLink, topicResult2.Body.DeepLink);
Assert.AreEqual(friendlyName, topicResult2.Body.FriendlyName);
Assert.AreEqual(group, topicResult2.Body.Group);
Assert.AreEqual(language, topicResult2.Body.Language);
Assert.AreEqual(false, topicResult2.Body.Liked);
Assert.AreEqual(false, topicResult2.Body.Pinned);
Assert.AreEqual(PublisherType.User, topicResult2.Body.PublisherType);
Assert.AreEqual(topicText2, topicResult2.Body.Text);
Assert.AreEqual(topicTitle2, topicResult2.Body.Title);
Assert.AreEqual(topicHandle2, topicResult2.Body.TopicHandle);
Assert.AreEqual(0, topicResult2.Body.TotalComments);
Assert.AreEqual(0, topicResult2.Body.TotalLikes);
Assert.AreEqual(firstName, topicResult2.Body.User.FirstName);
Assert.AreEqual(lastName, topicResult2.Body.User.LastName);
Assert.AreEqual(postUserResponse.UserHandle, topicResult2.Body.User.UserHandle);
}
public async Task PostGetLikeDeleteCommentTest()
{
// create 2 users
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
string firstName = "Stan";
string lastName = "TopicMan";
string bio = string.Empty;
PostUserResponse postUserResponse1 = await TestUtilities.DoLogin(client, firstName, lastName, bio);
string auth1 = AuthHelper.CreateSocialPlusAuth(postUserResponse1.SessionToken);
string firstName2 = "NotPopularNelly";
string lastName2 = "Von Jerk";
string bio2 = "Nelly is not very popular. :(";
PostUserResponse postUserResponse2 = await TestUtilities.DoLogin(client, firstName2, lastName2, bio2);
string auth2 = AuthHelper.CreateSocialPlusAuth(postUserResponse2.SessionToken);
// create a topic from user 1
string topicTitle = "My Favorite Topic";
string topicText = "It is all about sports!";
BlobType blobType = BlobType.Custom;
string blobHandle = "http://myBlobHandle/";
string language = string.Empty;
string deepLink = string.Empty;
string categories = string.Empty;
string friendlyName = string.Empty;
string group = string.Empty;
PostTopicRequest postTopicRequest = new PostTopicRequest(publisherType: PublisherType.User, text: topicText, title: topicTitle, blobType: blobType, blobHandle: blobHandle, categories: categories, language: language, deepLink: deepLink, friendlyName: friendlyName, group: group);
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest, authorization : auth1);
string topicHandle = null;
if (postTopicOperationResponse != null && postTopicOperationResponse.Response.IsSuccessStatusCode)
{
topicHandle = postTopicOperationResponse.Body.TopicHandle;
}
// post comment 1 with an image from user 2
HttpOperationResponse <PostImageResponse> postImageOperationResponse = await ImageTests.AddImage(new System.Uri("http://research.microsoft.com/a/i/c/ms-logo.png"), ImageType.ContentBlob, client, auth2);
string imageHandle = string.Empty;
PostCommentRequest postCommentRequest1 = null;
HttpOperationResponse <PostCommentResponse> postCommentOperationResponse1 = null;
if (!string.IsNullOrWhiteSpace(topicHandle) && postImageOperationResponse != null && postImageOperationResponse.Response.IsSuccessStatusCode)
{
// get the image handle
imageHandle = postImageOperationResponse.Body.BlobHandle;
// create a comment from user 2
postCommentRequest1 = new PostCommentRequest(text: "my comment", blobType: BlobType.Image, blobHandle: imageHandle, language: "gibberish");
postCommentOperationResponse1 = await client.TopicComments.PostCommentWithHttpMessagesAsync(topicHandle : topicHandle, request : postCommentRequest1, authorization : auth2);
}
// post comment 2 from user 1
PostCommentRequest postCommentRequest2 = null;
HttpOperationResponse <PostCommentResponse> postCommentOperationResponse2 = null;
if (!string.IsNullOrWhiteSpace(topicHandle))
{
// create a comment from user 1
postCommentRequest2 = new PostCommentRequest(text: "another comment");
postCommentOperationResponse2 = await client.TopicComments.PostCommentWithHttpMessagesAsync(topicHandle : topicHandle, request : postCommentRequest2, authorization : auth1);
}
// get comment handles
string commentHandle1 = null;
string commentHandle2 = null;
if (postCommentOperationResponse1 != null && postCommentOperationResponse1.Response.IsSuccessStatusCode)
{
commentHandle1 = postCommentOperationResponse1.Body.CommentHandle;
}
if (postCommentOperationResponse2 != null && postCommentOperationResponse2.Response.IsSuccessStatusCode)
{
commentHandle2 = postCommentOperationResponse2.Body.CommentHandle;
}
// like comment 2 by user 2
HttpOperationResponse <object> postLikeOperationResponse = null;
if (!string.IsNullOrWhiteSpace(commentHandle2))
{
postLikeOperationResponse = await client.CommentLikes.PostLikeWithHttpMessagesAsync(commentHandle : commentHandle2, authorization : auth2);
}
// get topic & comment feed from the server as user 2
HttpOperationResponse <TopicView> getTopicOperationResponse = null;
HttpOperationResponse <FeedResponseCommentView> getCommentsOperationResponse1 = null;
if (!string.IsNullOrWhiteSpace(commentHandle1) && !string.IsNullOrWhiteSpace(commentHandle2))
{
getTopicOperationResponse = await client.Topics.GetTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth1);
getCommentsOperationResponse1 = await client.TopicComments.GetTopicCommentsWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth2);
}
// try to delete comment 1 with wrong bearer token
HttpOperationResponse <object> deleteCommentOperationResponse1 = null;
if (postCommentOperationResponse1 != null && postCommentOperationResponse1.Response.IsSuccessStatusCode)
{
deleteCommentOperationResponse1 = await client.Comments.DeleteCommentWithHttpMessagesAsync(commentHandle : commentHandle1, authorization : auth1);
}
// delete comment 1 with good bearer token
HttpOperationResponse <object> deleteCommentOperationResponse2 = null;
if (postCommentOperationResponse1 != null && postCommentOperationResponse1.Response.IsSuccessStatusCode)
{
deleteCommentOperationResponse2 = await client.Comments.DeleteCommentWithHttpMessagesAsync(commentHandle : commentHandle1, authorization : auth2);
}
// get comment feed from the server as user 1
HttpOperationResponse <FeedResponseCommentView> getCommentsOperationResponse2 = null;
if (!string.IsNullOrWhiteSpace(commentHandle2))
{
getCommentsOperationResponse2 = await client.TopicComments.GetTopicCommentsWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth1);
}
// delete comment 1 again with good bearer token
HttpOperationResponse <object> deleteCommentOperationResponse3 = null;
if (postCommentOperationResponse1 != null && postCommentOperationResponse1.Response.IsSuccessStatusCode)
{
deleteCommentOperationResponse3 = await client.Comments.DeleteCommentWithHttpMessagesAsync(commentHandle : commentHandle1, authorization : auth2);
}
// delete comment 2
HttpOperationResponse <object> deleteCommentOperationResponse4 = null;
if (postCommentOperationResponse2 != null && postCommentOperationResponse2.Response.IsSuccessStatusCode)
{
deleteCommentOperationResponse4 = await client.Comments.DeleteCommentWithHttpMessagesAsync(commentHandle : commentHandle2, authorization : auth1);
}
// no need to delete the image because there is no image delete API
// delete topic
HttpOperationResponse <object> deleteTopicOperationResponse = null;
if (!string.IsNullOrWhiteSpace(topicHandle))
{
deleteTopicOperationResponse = await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth1);
}
// delete users
HttpOperationResponse <object> deleteUserOperationResponse1 = await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth1);
HttpOperationResponse <object> deleteUserOperationResponse2 = await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth2);
// check failure conditions
Assert.IsTrue(postTopicOperationResponse.Response.IsSuccessStatusCode);
Assert.IsTrue(deleteTopicOperationResponse.Response.IsSuccessStatusCode);
Assert.IsTrue(postImageOperationResponse.Response.IsSuccessStatusCode);
Assert.IsTrue(postCommentOperationResponse1.Response.IsSuccessStatusCode);
Assert.IsTrue(postCommentOperationResponse2.Response.IsSuccessStatusCode);
Assert.IsTrue(deleteUserOperationResponse1.Response.IsSuccessStatusCode);
Assert.IsTrue(deleteUserOperationResponse2.Response.IsSuccessStatusCode);
Assert.IsTrue(getTopicOperationResponse.Response.IsSuccessStatusCode);
Assert.IsTrue(getCommentsOperationResponse1.Response.IsSuccessStatusCode);
Assert.IsTrue(getCommentsOperationResponse2.Response.IsSuccessStatusCode);
Assert.IsTrue(postLikeOperationResponse.Response.IsSuccessStatusCode);
Assert.IsFalse(deleteCommentOperationResponse1.Response.IsSuccessStatusCode);
Assert.IsTrue(deleteCommentOperationResponse2.Response.IsSuccessStatusCode);
Assert.IsFalse(deleteCommentOperationResponse3.Response.IsSuccessStatusCode);
Assert.IsTrue(deleteCommentOperationResponse4.Response.IsSuccessStatusCode);
// check response values
Assert.IsFalse(string.IsNullOrWhiteSpace(postUserResponse1.SessionToken));
Assert.IsFalse(string.IsNullOrWhiteSpace(postUserResponse2.SessionToken));
Assert.IsFalse(string.IsNullOrWhiteSpace(topicHandle));
Assert.IsFalse(string.IsNullOrWhiteSpace(imageHandle));
Assert.IsFalse(string.IsNullOrWhiteSpace(commentHandle1));
Assert.IsFalse(string.IsNullOrWhiteSpace(commentHandle2));
Assert.AreEqual(getTopicOperationResponse.Body.TotalComments, 2);
Assert.AreEqual(getCommentsOperationResponse1.Body.Data.Count, 2);
Assert.AreEqual(getCommentsOperationResponse2.Body.Data.Count, 1);
// check comment 1 in comment feed 1 (oldest in the feed)
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[1].BlobHandle, postCommentRequest1.BlobHandle);
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[1].BlobType, postCommentRequest1.BlobType);
Assert.IsTrue(getCommentsOperationResponse1.Body.Data[1].BlobUrl.Contains(imageHandle));
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[1].CommentHandle, commentHandle1);
Assert.IsTrue(getCommentsOperationResponse1.Body.Data[1].ContentStatus == ContentStatus.Active || getCommentsOperationResponse1.Body.Data[1].ContentStatus == ContentStatus.Clean);
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[1].Language, postCommentRequest1.Language);
Assert.IsFalse(getCommentsOperationResponse1.Body.Data[1].Liked);
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[1].Text, postCommentRequest1.Text);
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[1].TopicHandle, topicHandle);
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[1].TotalLikes, 0);
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[1].TotalReplies, 0);
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[1].User.UserHandle, postUserResponse2.UserHandle);
// check comment 2 in comment feed 1 (earliest in the feed)
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[0].BlobHandle, postCommentRequest2.BlobHandle);
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[0].BlobType, BlobType.Unknown);
Assert.IsTrue(string.IsNullOrEmpty(getCommentsOperationResponse1.Body.Data[0].BlobUrl));
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[0].CommentHandle, commentHandle2);
Assert.IsTrue(getCommentsOperationResponse1.Body.Data[0].ContentStatus == ContentStatus.Active || getCommentsOperationResponse1.Body.Data[0].ContentStatus == ContentStatus.Clean);
Assert.IsTrue(string.IsNullOrEmpty(getCommentsOperationResponse1.Body.Data[0].Language));
Assert.IsTrue(getCommentsOperationResponse1.Body.Data[0].Liked);
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[0].Text, postCommentRequest2.Text);
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[0].TopicHandle, topicHandle);
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[0].TotalLikes, 1);
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[0].TotalReplies, 0);
Assert.AreEqual(getCommentsOperationResponse1.Body.Data[0].User.UserHandle, postUserResponse1.UserHandle);
// check comment 2 in comment feed 2 (only one in the feed)
Assert.AreEqual(getCommentsOperationResponse2.Body.Data[0].BlobHandle, postCommentRequest2.BlobHandle);
Assert.AreEqual(getCommentsOperationResponse2.Body.Data[0].BlobType, BlobType.Unknown);
Assert.IsTrue(string.IsNullOrEmpty(getCommentsOperationResponse2.Body.Data[0].BlobUrl));
Assert.AreEqual(getCommentsOperationResponse2.Body.Data[0].CommentHandle, commentHandle2);
Assert.IsTrue(getCommentsOperationResponse2.Body.Data[0].ContentStatus == ContentStatus.Active || getCommentsOperationResponse2.Body.Data[0].ContentStatus == ContentStatus.Clean);
Assert.IsTrue(string.IsNullOrEmpty(getCommentsOperationResponse2.Body.Data[0].Language));
Assert.IsFalse(getCommentsOperationResponse2.Body.Data[0].Liked);
Assert.AreEqual(getCommentsOperationResponse2.Body.Data[0].Text, postCommentRequest2.Text);
Assert.AreEqual(getCommentsOperationResponse2.Body.Data[0].TopicHandle, topicHandle);
Assert.AreEqual(getCommentsOperationResponse2.Body.Data[0].TotalLikes, 1);
Assert.AreEqual(getCommentsOperationResponse2.Body.Data[0].TotalReplies, 0);
Assert.AreEqual(getCommentsOperationResponse2.Body.Data[0].User.UserHandle, postUserResponse1.UserHandle);
}
public async Task AppPublishedCreateVerifyDeleteTopicTest()
{
// get the app handle
string appHandle = ManageAppsUtils.GetAppHandle(TestConstants.EnvironmentName);
if (appHandle == null)
{
// fail the test
Assert.Fail("Failed to lookup appHandle");
}
// Set up initial login etc
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
var user = await TestUtilities.PostGenericUser(client);
var auth = AuthHelper.CreateSocialPlusAuth(user.SessionToken);
string userHandle = user.UserHandle;
// add user as admin
bool added = ManageAppsUtils.AddAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
if (!added)
{
// delete the user and fail the test
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to set user as administrator");
}
// create a topic
string topicTitle = "My Favorite Topic";
string topicText = "It is all about sports!";
BlobType blobType = BlobType.Image;
string blobHandle = "http://myBlobHandle/";
string language = "en-US";
string deepLink = "Sports!";
string categories = "sports, ncurrency";
string group = "mygroup";
PostTopicRequest postTopicRequest = new PostTopicRequest(publisherType: PublisherType.App, text: topicText, title: topicTitle, blobType: blobType, blobHandle: blobHandle, categories: categories, language: language, deepLink: deepLink, group: group);
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest, authorization : auth);
// if create topic was a success, grab the topic handle, the topic, and delete the topic and user to cleanup
string topicHandle = string.Empty;
HttpOperationResponse <TopicView> getTopicOperationResponse = null;
HttpOperationResponse <object> deleteTopicOperationResponse = null;
HttpOperationResponse <object> deleteUserOperationResponse = null;
bool?deleteAdminResult = null;
if (postTopicOperationResponse.Response.IsSuccessStatusCode)
{
topicHandle = postTopicOperationResponse.Body.TopicHandle;
getTopicOperationResponse = await client.Topics.GetTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
deleteTopicOperationResponse = await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
}
// otherwise, delete the admin and the user
deleteAdminResult = ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
deleteUserOperationResponse = await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
// check everything went well
Assert.IsTrue(postTopicOperationResponse.Response.IsSuccessStatusCode);
Assert.IsTrue(getTopicOperationResponse.Response.IsSuccessStatusCode);
Assert.IsTrue(deleteTopicOperationResponse.Response.IsSuccessStatusCode);
Assert.IsTrue(deleteAdminResult.HasValue);
Assert.IsTrue(deleteAdminResult.Value);
Assert.IsTrue(deleteUserOperationResponse.Response.IsSuccessStatusCode);
TopicView getTopicResponse = getTopicOperationResponse.Body;
Assert.AreEqual(getTopicResponse.BlobHandle, blobHandle);
Assert.AreEqual(getTopicResponse.BlobType, blobType);
if (getTopicResponse.BlobUrl.Contains("images/" + blobHandle) == false)
{
Assert.Fail(blobHandle + "should be contained in this: " + getTopicResponse.BlobUrl);
}
Assert.AreEqual(getTopicResponse.Categories, categories);
Assert.IsTrue(getTopicResponse.ContentStatus == ContentStatus.Active || getTopicResponse.ContentStatus == ContentStatus.Clean);
Assert.AreEqual(getTopicResponse.DeepLink, deepLink);
Assert.AreEqual(getTopicResponse.Group, group);
Assert.AreEqual(getTopicResponse.Language, language);
Assert.AreEqual(getTopicResponse.Liked, false);
Assert.AreEqual(getTopicResponse.Pinned, false);
Assert.AreEqual(getTopicResponse.PublisherType, PublisherType.App);
Assert.AreEqual(getTopicResponse.Text, topicText);
Assert.AreEqual(getTopicResponse.Title, topicTitle);
Assert.AreEqual(getTopicResponse.TopicHandle, topicHandle);
Assert.AreEqual(getTopicResponse.TotalComments, 0);
Assert.AreEqual(getTopicResponse.TotalLikes, 0);
// for app-published topics, the user is null
Assert.AreEqual(getTopicResponse.User, null);
}
public async Task TrendingHashTagsTest()
{
// Create users
SocialPlusClient client1 = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
SocialPlusClient client2 = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
string firstName1 = "Stan";
string lastName1 = "TopicMan";
string bio1 = string.Empty;
PostUserResponse postUserResponse1 = await TestUtilities.DoLogin(client1, firstName1, lastName1, bio1);
string bearerToken1 = "Bearer " + postUserResponse1.SessionToken;
string firstName2 = "Emily";
string lastName2 = "Johnson";
string bio2 = string.Empty;
PostUserResponse postUserResponse2 = await TestUtilities.DoLogin(client2, firstName2, lastName2, bio2);
string bearerToken2 = "Bearer " + postUserResponse2.SessionToken;
// First Topic by first user
string topicTitle1 = "My Favorite Topic";
string topicText1 = "It is all about sports! #sports #NFL";
BlobType blobType1 = BlobType.Image;
string blobHandle1 = "http://myBlobHandle/";
string language1 = "en-US";
string deepLink1 = "Sports!";
string categories1 = "sports, ncurrency";
string friendlyName1 = "Game On!";
string group1 = "mygroup";
PostTopicRequest postTopicRequest1 = new PostTopicRequest(
publisherType: PublisherType.User,
text: topicText1,
title: topicTitle1,
blobType: blobType1,
blobHandle: blobHandle1,
language: language1,
deepLink: deepLink1,
categories: categories1,
friendlyName: friendlyName1,
group: group1);
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse1 = await client1.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest1, authorization : bearerToken1);
// If the first post topic operation failed, clean up
if (!postTopicOperationResponse1.Response.IsSuccessStatusCode)
{
await client1.Users.DeleteUserWithHttpMessagesAsync(authorization : bearerToken1);
await client2.Users.DeleteUserWithHttpMessagesAsync(authorization : bearerToken2);
Assert.Fail("Failed to post first topic");
}
// Delay to ensure that the topics are ordered correctly
await Task.Delay(TestConstants.SearchDelay);
// Second Topic by first user
// Create a GUID for the word that we will test autocomplete against.
// Reduce the size of the guid to fit into the query. Max size is 25.
string guidstring = Guid.NewGuid().ToString().Substring(0, 24);
string topicTitle2 = "My Second Favorite Topic";
string topicText2 = "It is all about food! #food" + " #" + guidstring + " #" + guidstring + guidstring;
BlobType blobType2 = BlobType.Custom;
string blobHandle2 = "http://myBlobHandle/";
string language2 = "en-US";
string deepLink2 = "Food!";
string categories2 = guidstring + " " + guidstring;
string friendlyName2 = "Eat!";
string group2 = "mygroup";
PostTopicRequest postTopicRequest2 = new PostTopicRequest(
publisherType: PublisherType.User,
text: topicText2,
title: topicTitle2,
blobType: blobType2,
blobHandle: blobHandle2,
language: language2,
deepLink: deepLink2,
categories: categories2,
friendlyName: friendlyName2,
group: group2);
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse2 = await client1.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest2, authorization : bearerToken2);
// If the second post topic operation failed, clean up
if (!postTopicOperationResponse2.Response.IsSuccessStatusCode)
{
// clean up user 1 and topic 1
await client1.Topics.DeleteTopicWithHttpMessagesAsync(postTopicOperationResponse1.Body.TopicHandle, bearerToken1);
await client1.Users.DeleteUserWithHttpMessagesAsync(authorization : bearerToken1);
// clean up user 2
await client2.Users.DeleteUserWithHttpMessagesAsync(authorization : bearerToken2);
Assert.Fail("Failed to post second topic");
}
await Task.Delay(TestConstants.SearchDelay);
// Get the trending hash tags
HttpOperationResponse <IList <string> > trendingResponse1 = await client2.Hashtags.GetTrendingHashtagsWithHttpMessagesAsync(authorization : bearerToken2);
// Clean up topics
await client1.Topics.DeleteTopicWithHttpMessagesAsync(postTopicOperationResponse1.Body.TopicHandle, bearerToken1);
await client1.Topics.DeleteTopicWithHttpMessagesAsync(postTopicOperationResponse2.Body.TopicHandle, bearerToken2);
// Clean up users
HttpOperationResponse <object> deleteUser1 = await client1.Users.DeleteUserWithHttpMessagesAsync(authorization : bearerToken1);
HttpOperationResponse <object> deleteUser2 = await client1.Users.DeleteUserWithHttpMessagesAsync(authorization : bearerToken2);
// Validate the trending part - don't assume order or counts as "dirty" data could affect verification
Assert.IsTrue(trendingResponse1.Response.IsSuccessStatusCode);
Assert.IsNotNull(trendingResponse1, "Failed to get trending hashtags");
Assert.IsNotNull(trendingResponse1.Body, "Failed to get trending hashtags");
Assert.IsTrue(trendingResponse1.Body.Contains("#" + guidstring), "#" + guidstring + " was not found in the results");
Assert.IsTrue(trendingResponse1.Body.Contains("#food"), "#food was not found in the results");
Assert.IsTrue(trendingResponse1.Body.Contains("#sports"), "#sports was not found in the results");
Assert.IsTrue(trendingResponse1.Body.Contains("#NFL"), "#NFL was not found in the results");
}
public async Task SearchTopicsTest()
{
// generate unique string
string searchWord = "#" + Guid.NewGuid().ToString().Replace("-", string.Empty);
// create user
SocialPlusClient client1 = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
PostUserResponse postUserResponse;
string firstName = "FirstUser";
string lastName = "FirstUserLastName";
string bio = string.Empty;
postUserResponse = await TestUtilities.DoLogin(client1, firstName, lastName, bio);
string auth = AuthHelper.CreateSocialPlusAuth(postUserResponse.SessionToken);
// First Topic
string topicTitle = string.Empty;
string topicText = searchWord;
BlobType blobType = BlobType.Unknown;
string blobHandle = string.Empty;
string language = string.Empty;
string deepLink = string.Empty;
string categories = string.Empty;
string friendlyName = string.Empty;
string group = string.Empty;
PostTopicRequest postTopicRequest = new PostTopicRequest(publisherType: PublisherType.User, text: topicText, title: topicTitle, blobType: blobType, blobHandle: blobHandle, language: language, deepLink: deepLink, categories: categories, friendlyName: friendlyName, group: group);
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse = await client1.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest, authorization : auth);
// If the first post topic operation failed, clean up
if (postTopicOperationResponse == null || postTopicOperationResponse.Body == null || string.IsNullOrWhiteSpace(postTopicOperationResponse.Body.TopicHandle))
{
await client1.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to post first topic");
}
// Large delay to increase the difference in freshness between the two topics.
// Search results are influenced by weight (not used right now), freshness, and relevance.
// Azure Search's relevance score seems to vary a little bit even though both topics here
// are exactly the same. By increasing the freshness difference, these small variations in
// relevance score get washed out, and this test will pass deterministically.
await Task.Delay(10 *TestConstants.SearchDelay);
// create a second Topic
string topicTitle2 = string.Empty;
string topicText2 = searchWord;
PostTopicRequest postTopicRequest2 = new PostTopicRequest(publisherType: PublisherType.User, text: topicText2, title: topicTitle2, blobType: blobType, blobHandle: blobHandle, language: language, deepLink: deepLink, categories: categories, friendlyName: friendlyName, group: group);
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse2 = await client1.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest2, authorization : auth);
// If the second post topic operation failed, clean up
if (postTopicOperationResponse2 == null || postTopicOperationResponse2.Body == null || string.IsNullOrWhiteSpace(postTopicOperationResponse2.Body.TopicHandle))
{
await client1.Topics.DeleteTopicWithHttpMessagesAsync(postTopicOperationResponse.Body.TopicHandle, auth);
await client1.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to post second topic");
}
// Delay a bit to allow data to get into the search
await Task.Delay(TestConstants.SearchDelay);
// Only one result
HttpOperationResponse <FeedResponseTopicView> search1 = await client1.Search.GetTopicsWithHttpMessagesAsync(query : searchWord, cursor : null, limit : 1, authorization : auth);
// Now get the second one after that cursor
HttpOperationResponse <FeedResponseTopicView> search2 = await client1.Search.GetTopicsWithHttpMessagesAsync(query : searchWord, cursor : int.Parse(search1.Body.Cursor), limit : 1, authorization : auth);
// Now get all in one
HttpOperationResponse <FeedResponseTopicView> search3 = await client1.Search.GetTopicsWithHttpMessagesAsync(query : searchWord, cursor : null, limit : 2, authorization : auth);
// Delete topics and see if search works
HttpOperationResponse <object> deleteTopic1 = await client1.Topics.DeleteTopicWithHttpMessagesAsync(postTopicOperationResponse.Body.TopicHandle, auth);
HttpOperationResponse <object> deleteTopic2 = await client1.Topics.DeleteTopicWithHttpMessagesAsync(postTopicOperationResponse2.Body.TopicHandle, auth);
// now search to see if works after deleted
HttpOperationResponse <FeedResponseTopicView> search4 = await client1.Search.GetTopicsWithHttpMessagesAsync(query : searchWord, cursor : null, limit : 10, authorization : auth);
// Clean up first user
HttpOperationResponse <object> deleteUser1 = await client1.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
// Verify now - verify after all is cleaned up so any failures isn't leaving behind stuff to cause failure next time test is ran
// Verify Search 1
Assert.IsTrue(search1.Response.IsSuccessStatusCode);
Assert.AreEqual(search1.Body.Data.Count, 1);
Assert.AreEqual(search1.Body.Data[0].TopicHandle, postTopicOperationResponse2.Body.TopicHandle);
Assert.AreEqual(search1.Body.Data[0].Title, topicTitle2);
Assert.AreEqual(search1.Body.Data[0].Text, topicText2);
Assert.AreEqual(search1.Body.Data[0].BlobType, blobType);
Assert.AreEqual(search1.Body.Data[0].BlobHandle, blobHandle);
Assert.AreEqual(search1.Body.Data[0].Language, language);
Assert.AreEqual(search1.Body.Data[0].DeepLink, deepLink);
Assert.AreEqual(search1.Body.Data[0].Categories, categories);
Assert.AreEqual(search1.Body.Data[0].FriendlyName, friendlyName);
Assert.AreEqual(search1.Body.Data[0].Group, group);
// Verify Search 2
Assert.IsTrue(search2.Response.IsSuccessStatusCode);
Assert.AreEqual(search2.Body.Data.Count, 1);
Assert.AreEqual(search2.Body.Data[0].TopicHandle, postTopicOperationResponse.Body.TopicHandle);
Assert.AreEqual(search2.Body.Data[0].Title, topicTitle);
Assert.AreEqual(search2.Body.Data[0].Text, topicText);
Assert.AreEqual(search2.Body.Data[0].BlobType, blobType);
Assert.AreEqual(search2.Body.Data[0].BlobHandle, blobHandle);
Assert.AreEqual(search2.Body.Data[0].Language, language);
Assert.AreEqual(search2.Body.Data[0].DeepLink, deepLink);
Assert.AreEqual(search2.Body.Data[0].Categories, categories);
Assert.AreEqual(search2.Body.Data[0].FriendlyName, friendlyName);
Assert.AreEqual(search2.Body.Data[0].Group, group);
// Verify Search 3
Assert.IsTrue(search3.Response.IsSuccessStatusCode);
Assert.AreEqual(search3.Body.Data.Count, 2);
Assert.AreEqual(search3.Body.Data[0].TopicHandle, postTopicOperationResponse2.Body.TopicHandle);
Assert.AreEqual(search3.Body.Data[0].Title, topicTitle2);
Assert.AreEqual(search3.Body.Data[0].Text, topicText2);
Assert.AreEqual(search3.Body.Data[0].BlobType, blobType);
Assert.AreEqual(search3.Body.Data[0].BlobHandle, blobHandle);
Assert.AreEqual(search3.Body.Data[0].Language, language);
Assert.AreEqual(search3.Body.Data[0].DeepLink, deepLink);
Assert.AreEqual(search3.Body.Data[0].Categories, categories);
Assert.AreEqual(search3.Body.Data[0].FriendlyName, friendlyName);
Assert.AreEqual(search3.Body.Data[0].Group, group);
Assert.AreEqual(search3.Body.Data[1].TopicHandle, postTopicOperationResponse.Body.TopicHandle);
Assert.AreEqual(search3.Body.Data[1].Title, topicTitle);
Assert.AreEqual(search3.Body.Data[1].Text, topicText);
Assert.AreEqual(search3.Body.Data[1].BlobType, blobType);
Assert.AreEqual(search3.Body.Data[1].BlobHandle, blobHandle);
Assert.AreEqual(search3.Body.Data[1].Language, language);
Assert.AreEqual(search3.Body.Data[1].DeepLink, deepLink);
Assert.AreEqual(search3.Body.Data[1].Categories, categories);
Assert.AreEqual(search3.Body.Data[1].FriendlyName, friendlyName);
Assert.AreEqual(search3.Body.Data[1].Group, group);
// Verify Search 4
Assert.IsTrue(search4.Response.IsSuccessStatusCode);
Assert.AreEqual(search4.Body.Data.Count, 0);
// Verify deletions
Assert.IsTrue(deleteTopic1.Response.IsSuccessStatusCode);
Assert.IsTrue(deleteTopic2.Response.IsSuccessStatusCode);
Assert.IsTrue(deleteUser1.Response.IsSuccessStatusCode);
}
/// <summary>
/// Create a new topic
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='request'>
/// Post topic request
/// </param>
/// <param name='authorization'>
/// Format is: "Scheme CredentialsList". Possible values are:
///
/// - Anon AK=AppKey
///
/// - SocialPlus TK=SessionToken
///
/// - Facebook AK=AppKey|TK=AccessToken
///
/// - Google AK=AppKey|TK=AccessToken
///
/// - Twitter AK=AppKey|RT=RequestToken|TK=AccessToken
///
/// - Microsoft AK=AppKey|TK=AccessToken
///
/// - AADS2S AK=AppKey|[UH=UserHandle]|TK=AADToken
/// </param>
public static PostTopicResponse PostTopic(this ITopics operations, PostTopicRequest request, string authorization)
{
return(Task.Factory.StartNew(s => ((ITopics)s).PostTopicAsync(request, authorization), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
/// <summary>
/// Create a topic, like it, verify by doing a GetTopic, then delete the like
/// </summary>
/// <param name="appPublished">flag to indicate that topic is appPublished</param>
/// <param name="appHandle">app handle</param>
/// <returns>Fail if an exception is hit</returns>
public async Task LikeTopicHelper(bool appPublished, string appHandle)
{
// Set up initial login etc
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
PostUserResponse postUserResponse;
string firstName = "R2D2";
string lastName = "Robot";
string bio = string.Empty;
postUserResponse = await TestUtilities.DoLogin(client, firstName, lastName, bio);
string auth = AuthHelper.CreateSocialPlusAuth(postUserResponse.SessionToken);
string userHandle = postUserResponse.UserHandle;
if (appPublished)
{
// add user as admin
bool added = ManageAppsUtils.AddAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
if (!added)
{
// delete the user and fail the test
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to set user as administrator");
}
}
// create a topic
string topicTitle = "Topic for Like Test";
string topicText = "Verify the likes!";
BlobType blobType = BlobType.Unknown;
string blobHandle = "http://myBlobHandle/";
string language = "en-US";
string deepLink = "Like It!";
string categories = "#likes";
string friendlyName = "LT";
string group = "mygroup";
string topicHandle = string.Empty;
var postTopicRequest = new PostTopicRequest()
{
Title = topicTitle, Text = topicText, BlobType = blobType, BlobHandle = blobHandle, Language = language, DeepLink = deepLink, Categories = categories, FriendlyName = friendlyName, Group = group
};
if (appPublished)
{
postTopicRequest.PublisherType = PublisherType.App;
}
else
{
postTopicRequest.PublisherType = PublisherType.User;
}
var postTopicOperationResponse = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest, authorization : auth);
if (postTopicOperationResponse.Response.IsSuccessStatusCode)
{
// extract topic handle from the response
topicHandle = postTopicOperationResponse.Body.TopicHandle;
}
else
{
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Post topic failed.");
}
// Post a like on the Topic
var postLikeOperationResponse = await client.TopicLikes.PostLikeWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (!postLikeOperationResponse.Response.IsSuccessStatusCode)
{
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Like of topic failed.");
}
// get the topic and verify by Get Topic
var getTopicOperationResponse = await client.Topics.GetTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (!getTopicOperationResponse.Response.IsSuccessStatusCode)
{
await client.TopicLikes.DeleteLikeWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Get topic failed.");
}
// Delete the like
var deleteLikeOperationResponse = await client.TopicLikes.DeleteLikeWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (!deleteLikeOperationResponse.Response.IsSuccessStatusCode)
{
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Delete like failed.");
}
// Clean up first before verifying
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
var getTopicResponse = getTopicOperationResponse.Body;
// Verify as the last step
Assert.AreEqual(getTopicResponse.Liked, true);
Assert.AreEqual(getTopicResponse.Text, topicText);
Assert.AreEqual(getTopicResponse.Title, topicTitle);
Assert.AreEqual(getTopicResponse.TopicHandle, topicHandle);
Assert.AreEqual(getTopicResponse.TotalComments, 0);
Assert.AreEqual(getTopicResponse.TotalLikes, 1);
}
public async Task <IHttpActionResult> PostTopic([FromBody] PostTopicRequest request)
{
string className = "TopicsController";
string methodName = "PostTopic";
string logEntry = $"PublisherType = {request?.PublisherType}";
this.LogControllerStart(this.log, className, methodName, logEntry);
var userProfileEntity = await this.usersManager.ReadUserProfile(this.UserHandle, this.AppHandle);
if (userProfileEntity == null)
{
return(this.Unauthorized(ResponseStrings.UserNotFound));
}
UserVisibilityStatus visibility = userProfileEntity.Visibility;
// app published topics can only be created by an administrator of that application
if (request.PublisherType == PublisherType.App)
{
bool isAdmin = await this.appsManager.IsAdminUser(this.AppHandle, this.UserHandle);
if (!isAdmin)
{
return(this.Unauthorized(ResponseStrings.UserUnauthorized));
}
}
// Define a locally-scoped userHandle. If App is PublisherType, we will set it to null
string userHandle = this.UserHandle;
if (request.PublisherType == PublisherType.App)
{
// for app published topics, we don't record the userHandle as the topic owner
// this is because if the user who created the topic is later deleted, we do not want the topic to disappear
userHandle = null;
// app published topics are always public
visibility = UserVisibilityStatus.Public;
}
string topicHandle = this.handleGenerator.GenerateShortHandle();
await this.topicsManager.CreateTopic(
ProcessType.Frontend,
topicHandle,
request.Title,
request.Text,
request.BlobType,
request.BlobHandle,
request.Categories,
request.Language,
request.Group,
request.DeepLink,
request.FriendlyName,
request.PublisherType,
userHandle,
visibility,
DateTime.UtcNow,
ReviewStatus.Active,
this.AppHandle,
null);
var response = new PostTopicResponse()
{
TopicHandle = topicHandle
};
logEntry += $", TopicHandle = {topicHandle}";
this.LogControllerEnd(this.log, className, methodName, logEntry);
return(this.Created <PostTopicResponse>(new Uri(this.RequestAbsoluteUri + "/" + topicHandle), response));
}
public async Task CreateVerifyDeleteNamedTopicTest()
{
HttpOperationResponse <object> deleteUserOperationResponse = null;
HttpOperationResponse <object> deleteTopicOperationResponse = null;
HttpOperationResponse <object> deleteTopicNameOperationResponse = null;
DeleteTopicNameRequest deleteTopicNameReq = new DeleteTopicNameRequest(publisherType: PublisherType.App);
int endIndex = TestConstants.ConfigFileName.IndexOf(".");
this.environment = TestConstants.ConfigFileName.Substring(0, endIndex);
// create a user
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
var t = await this.CreateUserForTest(client);
PostUserResponse postUserResponse = t.Item1;
string auth = t.Item2;
string userHandle = postUserResponse.UserHandle;
string appHandle = ManageAppsUtils.GetAppHandle(this.environment);
if (appHandle == null)
{
// delete the user and fail the test
deleteUserOperationResponse = await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to lookup appHandle");
}
// add user as admin
bool added = ManageAppsUtils.AddAdmin(this.environment, appHandle, userHandle);
if (!added)
{
// delete the user and fail the test
deleteUserOperationResponse = await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to set user as administrator");
}
// create a topic
string topicTitle = "Test topic for named topics";
string topicText = "This sure is a fine topic.";
BlobType blobType = BlobType.Image;
string blobHandle = "http://myBlobHandle/";
string language = "en-US";
string group = "mygroup";
PostTopicRequest postTopicRequest = new PostTopicRequest(publisherType: PublisherType.User, text: topicText, title: topicTitle, blobType: blobType, blobHandle: blobHandle, language: language, group: group);
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest, authorization : auth);
// if create topic was a success, grab the topic handle
string topicHandle = string.Empty;
if (postTopicOperationResponse.Response.IsSuccessStatusCode)
{
topicHandle = postTopicOperationResponse.Body.TopicHandle;
}
else
{
// otherwise, delete the admin, the user and fail the test
ManageAppsUtils.DeleteAdmin(this.environment, appHandle, userHandle);
deleteUserOperationResponse = await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Create topic failed, cannot finish the CreateVerifyUpdateDeleteNamedTopicTest");
}
string topicName = "UnitTestTopicName";
// create a topic name
PostTopicNameRequest postTopicNameReq = new PostTopicNameRequest(publisherType: PublisherType.App, topicName: topicName, topicHandle: topicHandle);
HttpOperationResponse <object> postTopicNameOperationResponse = await client.Topics.PostTopicNameWithHttpMessagesAsync(request : postTopicNameReq, authorization : auth);
// if creating the topic name fails, delete the topic, the user, and fail the test
if (!postTopicNameOperationResponse.Response.IsSuccessStatusCode)
{
deleteTopicOperationResponse = await client.Topics.DeleteTopicWithHttpMessagesAsync(authorization : auth, topicHandle : topicHandle);
ManageAppsUtils.DeleteAdmin(this.environment, appHandle, userHandle);
deleteUserOperationResponse = await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Create topic name failed, cannot finish the CreateVerifyUpdateDeleteNamedTopicTest");
}
// get the topic name
HttpOperationResponse <GetTopicByNameResponse> getTopicNameResponse = await client.Topics.GetTopicByNameWithHttpMessagesAsync(topicName : topicName, publisherType : PublisherType.App, authorization : auth);
if (!getTopicNameResponse.Response.IsSuccessStatusCode)
{
// if get topic name fails, cleanup: delete the topic name, the admin, the user, and fail the test
deleteTopicNameOperationResponse = await client.Topics.DeleteTopicNameWithHttpMessagesAsync(request : deleteTopicNameReq, authorization : auth, topicName : topicName);
deleteTopicOperationResponse = await client.Topics.DeleteTopicWithHttpMessagesAsync(authorization : auth, topicHandle : topicHandle);
ManageAppsUtils.DeleteAdmin(this.environment, appHandle, userHandle);
deleteUserOperationResponse = await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("get topic name failed, cannot finish the CreateVerifyUpdateDeleteNamedTopicTest");
}
// delete the topic name we just created
deleteTopicNameOperationResponse = await client.Topics.DeleteTopicNameWithHttpMessagesAsync(request : deleteTopicNameReq, authorization : auth, topicName : topicName);
// if deleting the topic name fails, delete the topic, the admin, the user, and fail the test
if (!deleteTopicNameOperationResponse.Response.IsSuccessStatusCode)
{
deleteTopicOperationResponse = await client.Topics.DeleteTopicWithHttpMessagesAsync(authorization : auth, topicHandle : topicHandle);
ManageAppsUtils.DeleteAdmin(this.environment, appHandle, userHandle);
deleteUserOperationResponse = await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Delete topic name failed, cannot finish the CreateVerifyUpdateDeleteNamedTopicTest");
}
// do standard cleanup : delete the topic, delete the admin, and then delete the user
deleteTopicOperationResponse = await client.Topics.DeleteTopicWithHttpMessagesAsync(authorization : auth, topicHandle : topicHandle);
ManageAppsUtils.DeleteAdmin(this.environment, appHandle, userHandle);
deleteUserOperationResponse = await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
// if we reach here, the test was successful.
return;
}
public async Task CreateUpdateDeleteNamedTopicTest()
{
var deleteRequest = new DeleteTopicNameRequest()
{
PublisherType = PublisherType.App
};
int endIndex = TestConstants.ConfigFileName.IndexOf(".");
this.environment = TestConstants.ConfigFileName.Substring(0, endIndex);
// create a user
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
var t = await this.CreateUserForTest(client);
PostUserResponse postUserResponse = t.Item1;
string auth = t.Item2;
string userHandle = postUserResponse.UserHandle;
// get the app handle
string appHandle = ManageAppsUtils.GetAppHandle(this.environment);
if (appHandle == null)
{
// delete the user and fail the test
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to lookup appHandle");
}
// add user as admin
bool added = ManageAppsUtils.AddAdmin(this.environment, appHandle, userHandle);
if (!added)
{
// delete the user and fail the test
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to set user as administrator");
}
// create a topic
string topicTitle = "Test topic for named topics";
string topicText = "This sure is a fine topic.";
BlobType blobType = BlobType.Image;
string blobHandle = "http://myBlobHandle/";
string language = "en-US";
string group = "mygroup";
string topicHandle = null;
PostTopicRequest postTopicRequest = new PostTopicRequest(publisherType: PublisherType.User, text: topicText, title: topicTitle, blobType: blobType, blobHandle: blobHandle, language: language, group: group);
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest, authorization : auth);
if (postTopicOperationResponse.Response.IsSuccessStatusCode)
{
topicHandle = postTopicOperationResponse.Body.TopicHandle;
}
// create another topic
string topicTitle2 = "Test topic #2 for named topics";
string topicText2 = "This one also sure is a fine topic.";
string language2 = "en-US";
string group2 = "mygroup2";
string topicHandle2 = null;
PostTopicRequest postTopicRequest2 = new PostTopicRequest(publisherType: PublisherType.User, text: topicText2, title: topicTitle2, language: language2, group: group2);
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse2 = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest2, authorization : auth);
if (postTopicOperationResponse2.Response.IsSuccessStatusCode)
{
topicHandle2 = postTopicOperationResponse2.Body.TopicHandle;
}
if (!(postTopicOperationResponse.Response.IsSuccessStatusCode && postTopicOperationResponse2.Response.IsSuccessStatusCode))
{
// if either topic creation fails, cleanup:
// delete both topics, the admin, the user and fail the test
await client.Topics.DeleteTopicWithHttpMessagesAsync(authorization : auth, topicHandle : topicHandle);
await client.Topics.DeleteTopicWithHttpMessagesAsync(authorization : auth, topicHandle : topicHandle2);
ManageAppsUtils.DeleteAdmin(this.environment, appHandle, userHandle);
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Create topics failed, cannot finish the CreateVerifyUpdateDeleteNamedTopicTest");
}
// create a topic name for topic #1
string topicName = "SpecialTopicName";
PostTopicNameRequest postTopicNameReq = new PostTopicNameRequest(publisherType: PublisherType.App, topicName: topicName, topicHandle: topicHandle);
HttpOperationResponse <object> postTopicNameOperationResponse = await client.Topics.PostTopicNameWithHttpMessagesAsync(request : postTopicNameReq, authorization : auth);
if (!postTopicNameOperationResponse.Response.IsSuccessStatusCode)
{
// if creating the topic name fails, cleanup:
// delete both topics, the admin, the user, and fail the test
await client.Topics.DeleteTopicWithHttpMessagesAsync(authorization : auth, topicHandle : topicHandle);
await client.Topics.DeleteTopicWithHttpMessagesAsync(authorization : auth, topicHandle : topicHandle2);
ManageAppsUtils.DeleteAdmin(this.environment, appHandle, userHandle);
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Create topic name failed, cannot finish the CreateVerifyUpdateDeleteNamedTopicTest");
}
// update the topic name so that it now refers to topic #2
PutTopicNameRequest putTopicNameReq = new PutTopicNameRequest(publisherType: PublisherType.App, topicHandle: topicHandle2);
HttpOperationResponse <object> putTopicNameOperationResponse = await client.Topics.PutTopicNameWithHttpMessagesAsync(topicName : topicName, request : putTopicNameReq, authorization : auth);
if (!putTopicNameOperationResponse.Response.IsSuccessStatusCode)
{
// if updating the topic name fails, cleanup
await client.Topics.DeleteTopicNameWithHttpMessagesAsync(topicName : topicName, request : deleteRequest, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(authorization : auth, topicHandle : topicHandle);
await client.Topics.DeleteTopicWithHttpMessagesAsync(authorization : auth, topicHandle : topicHandle2);
ManageAppsUtils.DeleteAdmin(this.environment, appHandle, userHandle);
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Put topic name failed, cannot finish the CreateVerifyUpdateDeleteNamedTopicTest");
}
// do the standard cleanup
await client.Topics.DeleteTopicNameWithHttpMessagesAsync(topicName : topicName, request : deleteRequest, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(authorization : auth, topicHandle : topicHandle);
await client.Topics.DeleteTopicWithHttpMessagesAsync(authorization : auth, topicHandle : topicHandle2);
ManageAppsUtils.DeleteAdmin(this.environment, appHandle, userHandle);
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
}
/// <summary>
/// Several types of notication test with Get Put and Count
/// </summary>
/// <param name="appPublished">flag to indicate if topics are app published</param>
/// <param name="appHandle">app handle</param>
/// <returns>Fail if an exception is hit</returns>
public async Task GetPutCountNotificationTestHelper(bool appPublished, string appHandle)
{
SocialPlusClient client1 = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
SocialPlusClient client2 = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
SocialPlusClient client3 = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
PostUserResponse postUserResponse = await TestUtilities.DoLogin(client1, "Stan", "TopicMan", string.Empty);
string auth1 = AuthHelper.CreateSocialPlusAuth(postUserResponse.SessionToken);
if (appPublished)
{
// add user1 as admin
bool added = ManageAppsUtils.AddAdmin(TestConstants.EnvironmentName, appHandle, postUserResponse.UserHandle);
if (!added)
{
// delete the user and fail the test
await client1.Users.DeleteUserAsync(auth1);
Assert.Fail("Failed to set user as administrator");
}
}
PostUserResponse postUserResponse2 = await TestUtilities.DoLogin(client2, "Emily", "Johnson", string.Empty);
string auth2 = AuthHelper.CreateSocialPlusAuth(postUserResponse2.SessionToken);
PostUserResponse postUserResponse3 = await TestUtilities.DoLogin(client3, "Johnny", "OnTheSpot", string.Empty);
string auth3 = AuthHelper.CreateSocialPlusAuth(postUserResponse3.SessionToken);
PublisherType publisherType = appPublished ? PublisherType.App : PublisherType.User;
PostTopicRequest postTopicRequest = new PostTopicRequest(publisherType: publisherType, text: "Text", title: "Title", blobHandle: "BlobHandle", language: "en-US", deepLink: "link", categories: "categories", friendlyName: "friendlyName", group: "group");
PostTopicResponse postTopicResponse = await client1.Topics.PostTopicAsync(postTopicRequest, auth1);
// all three users like the topic that was created
await client1.TopicLikes.PostLikeAsync(postTopicResponse.TopicHandle, auth1);
await client2.TopicLikes.PostLikeAsync(postTopicResponse.TopicHandle, auth2);
await client3.TopicLikes.PostLikeAsync(postTopicResponse.TopicHandle, auth3);
if (appPublished)
{
// for an app published topic, the topic creator (the content owner) does not receive notifications
// when the topic is liked.
await Task.Delay(TestConstants.ServiceBusMediumDelay);
FeedResponseActivityView notifications1 = await client1.MyNotifications.GetNotificationsAsync(auth1);
notifications1 = await client1.MyNotifications.GetNotificationsAsync(auth1, null, 10);
CountResponse count1 = await client1.MyNotifications.GetNotificationsCountAsync(auth1);
// Clean up state from the test
await client1.Topics.DeleteTopicAsync(postTopicResponse.TopicHandle, auth1);
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, postUserResponse.UserHandle);
await client1.Users.DeleteUserAsync(auth1);
await client2.Users.DeleteUserAsync(auth2);
await client3.Users.DeleteUserAsync(auth3);
// check that no notifications are delivered
Assert.AreEqual(0, notifications1.Data.Count);
Assert.AreEqual(0, count1.Count);
}
else
{
// for a user published topic, user1 (the content owner) should receive two notifications:
// one when user2 likes the topic, and one when user3 likes the topic
FeedResponseActivityView notifications1 = null;
FeedResponseActivityView notifications2 = null;
FeedResponseActivityView notifications3 = null;
CountResponse count1 = null;
await TestUtilities.AutoRetryServiceBusHelper(
async() =>
{
// get the first notification
notifications1 = await client1.MyNotifications.GetNotificationsAsync(auth1, null, 1);
// get the second notification using the first one as the cursor
notifications2 = await client1.MyNotifications.GetNotificationsAsync(auth1, notifications1.Cursor, 1);
// get up to 10 notifications
notifications3 = await client1.MyNotifications.GetNotificationsAsync(auth1, null, 10);
// get the count of unread notifications
count1 = await client1.MyNotifications.GetNotificationsCountAsync(auth1);
},
() =>
{
// verify
Assert.AreEqual(1, notifications1.Data.Count);
Assert.AreEqual(ActivityType.Like, notifications1.Data[0].ActivityType);
Assert.AreEqual(1, notifications1.Data[0].ActorUsers.Count);
Assert.AreEqual(1, notifications1.Data[0].TotalActions);
Assert.AreEqual(postTopicResponse.TopicHandle, notifications1.Data[0].ActedOnContent.ContentHandle);
Assert.AreEqual(BlobType.Unknown, notifications1.Data[0].ActedOnContent.BlobType);
Assert.AreEqual(ContentType.Topic, notifications1.Data[0].ActedOnContent.ContentType);
Assert.AreEqual(1, notifications2.Data.Count);
Assert.AreEqual(ActivityType.Like, notifications2.Data[0].ActivityType);
Assert.AreEqual(1, notifications2.Data[0].ActorUsers.Count);
Assert.AreEqual(1, notifications2.Data[0].TotalActions);
Assert.AreEqual(postTopicResponse.TopicHandle, notifications2.Data[0].ActedOnContent.ContentHandle);
Assert.AreEqual(BlobType.Unknown, notifications2.Data[0].ActedOnContent.BlobType);
Assert.AreEqual(ContentType.Topic, notifications2.Data[0].ActedOnContent.ContentType);
Assert.AreEqual(2, notifications3.Data.Count);
Assert.AreEqual(ActivityType.Like, notifications3.Data[0].ActivityType);
Assert.AreEqual(1, notifications3.Data[0].ActorUsers.Count);
Assert.AreEqual(1, notifications3.Data[0].TotalActions);
Assert.AreEqual(postTopicResponse.TopicHandle, notifications3.Data[0].ActedOnContent.ContentHandle);
Assert.AreEqual(BlobType.Unknown, notifications3.Data[0].ActedOnContent.BlobType);
Assert.AreEqual(ContentType.Topic, notifications3.Data[0].ActedOnContent.ContentType);
Assert.AreEqual(2, count1.Count);
});
// Update which is the most recent notification the user has read
PutNotificationsStatusRequest putNotificationStatusRequest = new PutNotificationsStatusRequest(notifications3.Data.First().ActivityHandle);
await client1.MyNotifications.PutNotificationsStatusAsync(putNotificationStatusRequest, auth1);
// Get Notification
FeedResponseActivityView notifications4 = await client1.MyNotifications.GetNotificationsAsync(auth1, null, 10);
var count2 = await client1.MyNotifications.GetNotificationsCountAsync(auth1);
// User3 creates another like on the topic. Even though this doesn't change
// the like status because the user has already liked this topic, it does generate
// another notification.
await client3.TopicLikes.PostLikeAsync(postTopicResponse.TopicHandle, auth3);
FeedResponseActivityView notifications5 = null;
CountResponse count3 = null;
await TestUtilities.AutoRetryServiceBusHelper(
async() =>
{
// Get new notifications and the count of unread notifications
notifications5 = await client1.MyNotifications.GetNotificationsAsync(auth1, null, 10);
count3 = await client1.MyNotifications.GetNotificationsCountAsync(auth1);
}, () =>
{
// verify
Assert.AreEqual(2, notifications5.Data.Count);
Assert.AreEqual(ActivityType.Like, notifications5.Data[0].ActivityType);
Assert.AreEqual(1, notifications5.Data[0].ActorUsers.Count);
Assert.AreEqual(1, notifications5.Data[0].TotalActions);
Assert.AreEqual(postTopicResponse.TopicHandle, notifications5.Data[0].ActedOnContent.ContentHandle);
Assert.AreEqual(BlobType.Unknown, notifications5.Data[0].ActedOnContent.BlobType);
Assert.AreEqual(ContentType.Topic, notifications5.Data[0].ActedOnContent.ContentType);
Assert.AreEqual(1, count3.Count);
});
// User2 deletes their like on the topic. This generates a notification
await client2.TopicLikes.DeleteLikeAsync(postTopicResponse.TopicHandle, auth2);
FeedResponseActivityView notifications6 = null;
CountResponse count4 = null;
await TestUtilities.AutoRetryServiceBusHelper(
async() =>
{
// Get new notifications and the count of unread notifications
notifications6 = await client1.MyNotifications.GetNotificationsAsync(auth1, null, 10);
count4 = await client1.MyNotifications.GetNotificationsCountAsync(auth1);
}, () =>
{
// verify
Assert.AreEqual(1, notifications6.Data.Count);
Assert.AreEqual(ActivityType.Like, notifications6.Data[0].ActivityType);
Assert.AreEqual(1, notifications6.Data[0].ActorUsers.Count);
Assert.AreEqual(1, notifications6.Data[0].TotalActions);
Assert.AreEqual(postTopicResponse.TopicHandle, notifications6.Data[0].ActedOnContent.ContentHandle);
Assert.AreEqual(BlobType.Unknown, notifications6.Data[0].ActedOnContent.BlobType);
Assert.AreEqual(ContentType.Topic, notifications6.Data[0].ActedOnContent.ContentType);
Assert.AreEqual(1, count4.Count);
});
// User2 once again likes the topic and generates a notification
await client2.TopicLikes.PostLikeAsync(postTopicResponse.TopicHandle, auth2);
FeedResponseActivityView notifications7 = null;
CountResponse count5 = null;
await TestUtilities.AutoRetryServiceBusHelper(
async() =>
{
// Get new notifications and the count of unread notifications
notifications7 = await client1.MyNotifications.GetNotificationsAsync(auth1, null, 10);
count5 = await client1.MyNotifications.GetNotificationsCountAsync(auth1);
}, () =>
{
// verify
Assert.AreEqual(2, notifications7.Data.Count);
Assert.AreEqual(ActivityType.Like, notifications7.Data[0].ActivityType);
Assert.AreEqual(1, notifications7.Data[0].ActorUsers.Count);
Assert.AreEqual(1, notifications7.Data[0].TotalActions);
Assert.AreEqual(postTopicResponse.TopicHandle, notifications7.Data[0].ActedOnContent.ContentHandle);
Assert.AreEqual(BlobType.Unknown, notifications7.Data[0].ActedOnContent.BlobType);
Assert.AreEqual(ContentType.Topic, notifications7.Data[0].ActedOnContent.ContentType);
Assert.AreEqual(2, count5.Count);
});
// Update the most recent notification read
putNotificationStatusRequest = new PutNotificationsStatusRequest(notifications7.Data.First().ActivityHandle);
await client1.MyNotifications.PutNotificationsStatusAsync(putNotificationStatusRequest, auth1);
// Get new notifications and the count of unread notifications
var notifications8 = await client1.MyNotifications.GetNotificationsAsync(auth1, null, 10);
var count6 = await client1.MyNotifications.GetNotificationsCountAsync(auth1);
// Clean up state from the test
await client1.Topics.DeleteTopicAsync(postTopicResponse.TopicHandle, auth1);
await client1.Users.DeleteUserAsync(auth1);
await client2.Users.DeleteUserAsync(auth2);
await client3.Users.DeleteUserAsync(auth3);
// Validate everything
Assert.AreEqual(1, notifications1.Data.Count);
Assert.AreEqual(ActivityType.Like, notifications1.Data[0].ActivityType);
Assert.AreEqual(1, notifications1.Data[0].ActorUsers.Count);
Assert.AreEqual(1, notifications1.Data[0].TotalActions);
Assert.AreEqual(postTopicResponse.TopicHandle, notifications1.Data[0].ActedOnContent.ContentHandle);
Assert.AreEqual(BlobType.Unknown, notifications1.Data[0].ActedOnContent.BlobType);
Assert.AreEqual(ContentType.Topic, notifications1.Data[0].ActedOnContent.ContentType);
Assert.AreEqual(1, notifications2.Data.Count);
Assert.AreEqual(ActivityType.Like, notifications2.Data[0].ActivityType);
Assert.AreEqual(1, notifications2.Data[0].ActorUsers.Count);
Assert.AreEqual(1, notifications2.Data[0].TotalActions);
Assert.AreEqual(postTopicResponse.TopicHandle, notifications2.Data[0].ActedOnContent.ContentHandle);
Assert.AreEqual(BlobType.Unknown, notifications2.Data[0].ActedOnContent.BlobType);
Assert.AreEqual(ContentType.Topic, notifications2.Data[0].ActedOnContent.ContentType);
Assert.AreEqual(2, notifications3.Data.Count);
Assert.AreEqual(ActivityType.Like, notifications3.Data[0].ActivityType);
Assert.AreEqual(1, notifications3.Data[0].ActorUsers.Count);
Assert.AreEqual(1, notifications3.Data[0].TotalActions);
Assert.AreEqual(postTopicResponse.TopicHandle, notifications3.Data[0].ActedOnContent.ContentHandle);
Assert.AreEqual(BlobType.Unknown, notifications3.Data[0].ActedOnContent.BlobType);
Assert.AreEqual(ContentType.Topic, notifications3.Data[0].ActedOnContent.ContentType);
Assert.AreEqual(2, notifications4.Data.Count);
Assert.AreEqual(ActivityType.Like, notifications4.Data[0].ActivityType);
Assert.AreEqual(1, notifications4.Data[0].ActorUsers.Count);
Assert.AreEqual(1, notifications4.Data[0].TotalActions);
Assert.AreEqual(postTopicResponse.TopicHandle, notifications4.Data[0].ActedOnContent.ContentHandle);
Assert.AreEqual(BlobType.Unknown, notifications4.Data[0].ActedOnContent.BlobType);
Assert.AreEqual(ContentType.Topic, notifications4.Data[0].ActedOnContent.ContentType);
Assert.AreEqual(2, notifications5.Data.Count);
Assert.AreEqual(ActivityType.Like, notifications5.Data[0].ActivityType);
Assert.AreEqual(1, notifications5.Data[0].ActorUsers.Count);
Assert.AreEqual(1, notifications5.Data[0].TotalActions);
Assert.AreEqual(postTopicResponse.TopicHandle, notifications5.Data[0].ActedOnContent.ContentHandle);
Assert.AreEqual(BlobType.Unknown, notifications5.Data[0].ActedOnContent.BlobType);
Assert.AreEqual(ContentType.Topic, notifications5.Data[0].ActedOnContent.ContentType);
Assert.AreEqual(1, notifications6.Data.Count);
Assert.AreEqual(ActivityType.Like, notifications6.Data[0].ActivityType);
Assert.AreEqual(1, notifications6.Data[0].ActorUsers.Count);
Assert.AreEqual(1, notifications6.Data[0].TotalActions);
Assert.AreEqual(postTopicResponse.TopicHandle, notifications6.Data[0].ActedOnContent.ContentHandle);
Assert.AreEqual(BlobType.Unknown, notifications6.Data[0].ActedOnContent.BlobType);
Assert.AreEqual(ContentType.Topic, notifications6.Data[0].ActedOnContent.ContentType);
Assert.AreEqual(2, notifications7.Data.Count);
Assert.AreEqual(ActivityType.Like, notifications7.Data[0].ActivityType);
Assert.AreEqual(1, notifications7.Data[0].ActorUsers.Count);
Assert.AreEqual(1, notifications7.Data[0].TotalActions);
Assert.AreEqual(postTopicResponse.TopicHandle, notifications7.Data[0].ActedOnContent.ContentHandle);
Assert.AreEqual(BlobType.Unknown, notifications7.Data[0].ActedOnContent.BlobType);
Assert.AreEqual(ContentType.Topic, notifications7.Data[0].ActedOnContent.ContentType);
Assert.AreEqual(2, notifications8.Data.Count);
Assert.AreEqual(ActivityType.Like, notifications8.Data[0].ActivityType);
Assert.AreEqual(1, notifications8.Data[0].ActorUsers.Count);
Assert.AreEqual(1, notifications8.Data[0].TotalActions);
Assert.AreEqual(postTopicResponse.TopicHandle, notifications8.Data[0].ActedOnContent.ContentHandle);
Assert.AreEqual(BlobType.Unknown, notifications8.Data[0].ActedOnContent.BlobType);
Assert.AreEqual(ContentType.Topic, notifications8.Data[0].ActedOnContent.ContentType);
Assert.AreEqual(2, count1.Count);
Assert.AreEqual(0, count2.Count);
Assert.AreEqual(1, count3.Count);
Assert.AreEqual(1, count4.Count);
Assert.AreEqual(2, count5.Count);
Assert.AreEqual(0, count6.Count);
}
}
/// <summary>
/// Publish a new app-published topic with a topic name to Embedded Social
/// </summary>
/// <param name="topicName">name of the new topic</param>
/// <param name="topicTitle">title of the new topic</param>
/// <param name="topicText">text of the new topic</param>
/// <param name="topicCategory">category of the new topic</param>
/// <returns>task that publishes a new topic</returns>
private async Task CreateTopic(string topicName, string topicTitle, string topicText, string topicCategory)
{
// format the input into an Embedded Social topic request
PostTopicRequest topicRequest = new PostTopicRequest()
{
PublisherType = PublisherType.App,
Text = topicText,
Title = topicTitle,
BlobType = BlobType.Unknown,
BlobHandle = string.Empty,
Categories = topicCategory,
Language = TopicLanguage,
DeepLink = string.Empty,
FriendlyName = topicName,
Group = string.Empty
};
// publish to Embedded Social
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse = await this.client.Topics.PostTopicWithHttpMessagesAsync(request : topicRequest, authorization : this.authorization);
// check response
if (postTopicOperationResponse == null || postTopicOperationResponse.Response == null)
{
throw new Exception("got null response");
}
else if (!postTopicOperationResponse.Response.IsSuccessStatusCode)
{
throw new Exception("request failed with HTTP code: " + postTopicOperationResponse.Response.StatusCode + ", and reason: " + postTopicOperationResponse.Response.ReasonPhrase);
}
else if (postTopicOperationResponse.Body == null)
{
throw new Exception("got null response body");
}
else if (string.IsNullOrWhiteSpace(postTopicOperationResponse.Body.TopicHandle))
{
throw new Exception("topicHandle is null or whitespace");
}
// publish the name for the topic
string topicHandle = postTopicOperationResponse.Body.TopicHandle;
PostTopicNameRequest topicNameRequest = new PostTopicNameRequest()
{
PublisherType = PublisherType.App,
TopicName = topicName,
TopicHandle = topicHandle
};
HttpOperationResponse postTopicNameOperationResponse = await this.client.Topics.PostTopicNameWithHttpMessagesAsync(request : topicNameRequest, authorization : this.authorization);
// check response
if (postTopicNameOperationResponse == null || postTopicNameOperationResponse.Response == null)
{
// attempt to clean up the topic first
HttpOperationResponse deleteTopicOperationResponse = await this.client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : this.authorization);
throw new Exception("got null response");
}
else if (!postTopicNameOperationResponse.Response.IsSuccessStatusCode)
{
// attempt to clean up the topic first
HttpOperationResponse deleteTopicOperationResponse = await this.client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : this.authorization);
throw new Exception("request failed with HTTP code: " + postTopicNameOperationResponse.Response.StatusCode + ", and reason: " + postTopicNameOperationResponse.Response.ReasonPhrase);
}
}
/// <summary>
/// Create a new topic
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='request'>
/// Post topic request
/// </param>
/// <param name='authorization'>
/// Format is: "Scheme CredentialsList". Possible values are:
///
/// - Anon AK=AppKey
///
/// - SocialPlus TK=SessionToken
///
/// - Facebook AK=AppKey|TK=AccessToken
///
/// - Google AK=AppKey|TK=AccessToken
///
/// - Twitter AK=AppKey|RT=RequestToken|TK=AccessToken
///
/// - Microsoft AK=AppKey|TK=AccessToken
///
/// - AADS2S AK=AppKey|[UH=UserHandle]|TK=AADToken
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <PostTopicResponse> PostTopicAsync(this ITopics operations, PostTopicRequest request, string authorization, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.PostTopicWithHttpMessagesAsync(request, authorization, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Create a topic, and issue 100 likes and unlikes on it from the same user in rapid succession
/// </summary>
/// <param name="unlike">if true, will also issue unlikes</param>
/// <returns>Fail if any of the likes or unlikes result in an HTTP error</returns>
private async Task RapidLikeTopicHelper(bool unlike)
{
int numLikesToIssue = 100;
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
// create a user
PostUserResponse postUserResponse = await TestUtilities.DoLogin(client, "Rapid", "Like", "Rapid Like Topic Test");
string auth = AuthHelper.CreateSocialPlusAuth(postUserResponse.SessionToken);
string userHandle = postUserResponse.UserHandle;
// create a topic
PostTopicRequest postTopicRequest = new PostTopicRequest()
{
Title = "Rapid like topic test",
Text = "Rapid like topic test",
BlobType = BlobType.Unknown,
BlobHandle = string.Empty,
Language = string.Empty,
DeepLink = string.Empty,
Categories = string.Empty,
FriendlyName = string.Empty,
Group = string.Empty,
PublisherType = PublisherType.User
};
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest, authorization : auth);
if (!postTopicOperationResponse.Response.IsSuccessStatusCode)
{
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
}
Assert.IsTrue(postTopicOperationResponse.Response.IsSuccessStatusCode);
string topicHandle = postTopicOperationResponse.Body.TopicHandle;
// issue repeated likes and unlikes
HttpOperationResponse[] postLikeOperationResponses = new HttpOperationResponse[numLikesToIssue];
HttpOperationResponse[] postUnLikeOperationResponses = new HttpOperationResponse[numLikesToIssue];
for (int i = 0; i < numLikesToIssue; i++)
{
postLikeOperationResponses[i] = await client.TopicLikes.PostLikeWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (unlike)
{
postUnLikeOperationResponses[i] = await client.TopicLikes.DeleteLikeWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
}
}
// clean up
HttpOperationResponse deleteTopicOperationResponse = await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
HttpOperationResponse deleteUserOperationResponse = await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
// check for errors
for (int i = 0; i < numLikesToIssue; i++)
{
Assert.IsTrue(postLikeOperationResponses[i].Response.IsSuccessStatusCode);
if (unlike)
{
Assert.IsTrue(postUnLikeOperationResponses[i].Response.IsSuccessStatusCode);
}
}
Assert.IsTrue(deleteTopicOperationResponse.Response.IsSuccessStatusCode);
Assert.IsTrue(deleteUserOperationResponse.Response.IsSuccessStatusCode);
}
/// <summary>
/// Helper routine that performs the main actions of the test.
/// Create multiple topics. Pin them. Then get the pin feed, and check that all the pinned topics show up.
/// </summary>
/// <param name="appPublished">flag to indicate if topic is app published</param>
/// <param name="appHandle">app handle</param>
/// <returns>Fail if an exception is hit</returns>
public async Task GetPinFeedTestHelper(bool appPublished, string appHandle)
{
// Set up initial login etc
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
string firstName = "J.J.";
string lastName = "Z";
string bio = string.Empty;
PostUserResponse postUserResponse = await TestUtilities.DoLogin(client, firstName, lastName, bio);
string auth = AuthHelper.CreateSocialPlusAuth(postUserResponse.SessionToken);
string userHandle = postUserResponse.UserHandle;
if (appPublished)
{
// add user as admin
bool added = ManageAppsUtils.AddAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
if (!added)
{
// delete the user and fail the test
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to set user as administrator");
}
}
// create topic #1
string topicTitle = "topic number 1";
string topicText = "the jukebox needs to take a leak";
string language = "en-US";
string deepLink = "http://dummy/";
string categories = "cat1, cat6";
string group = "mygroup";
// step 1, create a topic and pin it
string topicHandle = string.Empty;
var postTopicRequest = new PostTopicRequest()
{
Text = topicText, Title = topicTitle, Categories = categories, Language = language, DeepLink = deepLink, Group = group
};
if (appPublished)
{
postTopicRequest.PublisherType = PublisherType.App;
}
else
{
postTopicRequest.PublisherType = PublisherType.User;
}
var postTopicOperationResponse = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest, authorization : auth);
if (postTopicOperationResponse.Response.IsSuccessStatusCode)
{
topicHandle = postTopicOperationResponse.Body.TopicHandle;
}
else
{
// cleanup: delete the user
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to post topic.");
}
var pinRequest = new PostPinRequest()
{
TopicHandle = topicHandle
};
var postPinOperationResponse = await client.MyPins.PostPinWithHttpMessagesAsync(authorization : auth, request : pinRequest);
if (!postPinOperationResponse.Response.IsSuccessStatusCode)
{
// cleanup: delete topic #1 and delete the user
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to pin topic #1.");
}
// create topic #2 and pin it
topicTitle = "topic number 2";
topicText = "the piano has been drinking";
language = "en-US";
deepLink = "http://dummy/";
categories = "cat1, cat6";
group = "mygroup";
string topicHandle2 = string.Empty;
PostTopicRequest postTopicRequest2 = new PostTopicRequest()
{
Text = topicText, Title = topicTitle, Categories = categories, Language = language, DeepLink = deepLink, Group = group
};
if (appPublished)
{
postTopicRequest2.PublisherType = PublisherType.App;
}
else
{
postTopicRequest2.PublisherType = PublisherType.User;
}
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse2 = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest2, authorization : auth);
if (postTopicOperationResponse2.Response.IsSuccessStatusCode)
{
topicHandle2 = postTopicOperationResponse2.Body.TopicHandle;
}
else
{
// cleanup: delete topic #1 and delete the user
await client.MyPins.DeletePinWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to post topic #2.");
}
pinRequest = new PostPinRequest()
{
TopicHandle = topicHandle2
};
postPinOperationResponse = await client.MyPins.PostPinWithHttpMessagesAsync(authorization : auth, request : pinRequest);
if (!postPinOperationResponse.Response.IsSuccessStatusCode)
{
// cleanup: delete topic #1, topic #2, and delete the user
await client.MyPins.DeletePinWithHttpMessagesAsync(topicHandle : topicHandle2, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle2, authorization : auth);
await client.MyPins.DeletePinWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to pin topic #2.");
}
// create topic #3
topicTitle = "topic number 3";
topicText = "the carpet needs a haircut";
language = "en-US";
deepLink = "http://dummy/";
categories = "cat1, cat6";
group = "mygroup";
string topicHandle3 = string.Empty;
PostTopicRequest postTopicRequest3 = new PostTopicRequest()
{
Text = topicText, Title = topicTitle, Categories = categories, Language = language, DeepLink = deepLink, Group = group
};
if (appPublished)
{
postTopicRequest3.PublisherType = PublisherType.App;
}
else
{
postTopicRequest3.PublisherType = PublisherType.User;
}
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse3 = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest3, authorization : auth);
if (postTopicOperationResponse3.Response.IsSuccessStatusCode)
{
topicHandle3 = postTopicOperationResponse3.Body.TopicHandle;
}
else
{
// cleanup: delete topic #1, topic #2, and delete the user
await client.MyPins.DeletePinWithHttpMessagesAsync(topicHandle : topicHandle2, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle2, authorization : auth);
await client.MyPins.DeletePinWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to post topic #3.");
}
pinRequest = new PostPinRequest()
{
TopicHandle = topicHandle3
};
postPinOperationResponse = await client.MyPins.PostPinWithHttpMessagesAsync(authorization : auth, request : pinRequest);
if (!postPinOperationResponse.Response.IsSuccessStatusCode)
{
// cleanup: delete topic #1, topic #2, topic #3 and delete the user
await client.MyPins.DeletePinWithHttpMessagesAsync(topicHandle : topicHandle3, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle3, authorization : auth);
await client.MyPins.DeletePinWithHttpMessagesAsync(topicHandle : topicHandle2, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle2, authorization : auth);
await client.MyPins.DeletePinWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to pin topic #3.");
}
var pinFeedOperationResponse = await client.MyPins.GetPinsWithHttpMessagesAsync(authorization : auth);
IList <TopicView> pinFeedResponse = null;
if (pinFeedOperationResponse.Response.IsSuccessStatusCode)
{
pinFeedResponse = pinFeedOperationResponse.Body.Data;
}
else
{
// cleanup: delete topic #1, topic #2, topic #3 and delete the user
await client.MyPins.DeletePinWithHttpMessagesAsync(topicHandle : topicHandle3, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle3, authorization : auth);
await client.MyPins.DeletePinWithHttpMessagesAsync(topicHandle : topicHandle2, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle2, authorization : auth);
await client.MyPins.DeletePinWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to get the pin feed.");
}
// after getting the pin feed, clean up
await client.MyPins.DeletePinWithHttpMessagesAsync(topicHandle : topicHandle3, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle3, authorization : auth);
await client.MyPins.DeletePinWithHttpMessagesAsync(topicHandle : topicHandle2, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle2, authorization : auth);
await client.MyPins.DeletePinWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
bool?adminDeleted = null;
if (appPublished)
{
adminDeleted = ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
if (appPublished)
{
Assert.IsTrue(adminDeleted.HasValue);
Assert.IsTrue(adminDeleted.Value);
}
// after clean up, check the content of the pin feed
Assert.AreEqual(pinFeedResponse.Count, 3);
Assert.AreEqual(pinFeedResponse[0].Title, "topic number 3");
Assert.AreEqual(pinFeedResponse[1].Title, "topic number 2");
Assert.AreEqual(pinFeedResponse[2].Title, "topic number 1");
}
public async Task SearchUpdatedTopicTest()
{
string dateString = DateTime.UtcNow.ToFileTime().ToString();
string searchWord1 = "OriginalText" + dateString.Substring(dateString.Length - 7);
string searchWord2 = "UpdatedText" + dateString.Substring(dateString.Length - 7);
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
PostUserResponse postUserResponse;
string firstName = "FirstUser";
string lastName = "FirstUserLastName";
string bio = string.Empty;
postUserResponse = await TestUtilities.DoLogin(client, firstName, lastName, bio);
string auth = AuthHelper.CreateSocialPlusAuth(postUserResponse.SessionToken);
string topicTitle = "My Favorite Topic";
string originalText = "Sports. #" + searchWord1;
BlobType blobType = BlobType.Image;
string blobHandle = "http://myBlobHandle/";
string language = "en-US";
string deepLink = "Sports!";
string categories = "sports, ncurrency";
string friendlyName = "Game On!";
string group = "mygroup";
PostTopicRequest postTopicRequest = new PostTopicRequest(publisherType: PublisherType.User, text: originalText, title: topicTitle, blobType: blobType, blobHandle: blobHandle, language: language, deepLink: deepLink, categories: categories, friendlyName: friendlyName, group: group);
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest, authorization : auth);
// If the post topic operation failed, clean up
if (postTopicOperationResponse == null || !postTopicOperationResponse.Response.IsSuccessStatusCode || postTopicOperationResponse.Body == null || string.IsNullOrWhiteSpace(postTopicOperationResponse.Body.TopicHandle))
{
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to post topic");
}
string topicHandle = postTopicOperationResponse.Body.TopicHandle;
string updatedText = "Movies. #" + searchWord2;
PutTopicRequest putTopicRequest = new PutTopicRequest(text: updatedText, title: topicTitle, categories: categories);
HttpOperationResponse putTopicOperationResponse = await client.Topics.PutTopicWithHttpMessagesAsync(topicHandle, request : putTopicRequest, authorization : auth);
// If the put topic operation failed, clean up
if (putTopicOperationResponse == null || !putTopicOperationResponse.Response.IsSuccessStatusCode)
{
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to update topic");
}
// Delay a bit to allow data to get into the search
await Task.Delay(TestConstants.SearchDelay);
// Search on original text
HttpOperationResponse <FeedResponseTopicView> search1 = await client.Search.GetTopicsWithHttpMessagesAsync(query : searchWord1, cursor : null, authorization : auth);
// Search on updated text
HttpOperationResponse <FeedResponseTopicView> search2 = await client.Search.GetTopicsWithHttpMessagesAsync(query : searchWord2, cursor : null, authorization : auth);
// Clean up topic
HttpOperationResponse <object> deleteTopic = await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
// Clean up user
HttpOperationResponse <object> deleteUser = await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
// Verify now - verify after cleanup so that failed asserts don't cause data to be left behind and interfere with future tests
// Verify Search 1
Assert.IsTrue(search1.Response.IsSuccessStatusCode);
Assert.AreEqual(search1.Body.Data.Count, 0);
// Verify Search 2
Assert.IsTrue(search2.Response.IsSuccessStatusCode);
Assert.AreEqual(search2.Body.Data.Count, 1);
Assert.AreEqual(search2.Body.Data[0].TopicHandle, topicHandle);
Assert.AreEqual(search2.Body.Data[0].Title, topicTitle);
Assert.AreEqual(search2.Body.Data[0].Text, updatedText);
Assert.AreEqual(search2.Body.Data[0].BlobType, blobType);
Assert.AreEqual(search2.Body.Data[0].BlobHandle, blobHandle);
Assert.AreEqual(search2.Body.Data[0].Language, language);
Assert.AreEqual(search2.Body.Data[0].DeepLink, deepLink);
Assert.AreEqual(search2.Body.Data[0].Categories, categories);
Assert.AreEqual(search2.Body.Data[0].FriendlyName, friendlyName);
Assert.AreEqual(search2.Body.Data[0].Group, group);
// Verify deletions
Assert.IsTrue(deleteTopic.Response.IsSuccessStatusCode);
Assert.IsTrue(deleteUser.Response.IsSuccessStatusCode);
}
/// <summary>
/// Helper routine that performs the main actions of the test.
/// Create a topic. Get the initial topic pin status, check that it is unpinned. Pin it. Check the pin status is true.
/// Unpin it. Then check pin status is back to false.
/// </summary>
/// <param name="appPublished">flag to indicate if topic is app published</param>
/// <param name="appHandle">app handle</param>
/// <returns>Fail if an exception is hit</returns>
public async Task PinUnPinDeletePinTestHelper(bool appPublished, string appHandle)
{
// Set up initial login etc
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
string firstName = "J.J.";
string lastName = "Z";
string bio = string.Empty;
PostUserResponse postUserResponse = await TestUtilities.DoLogin(client, firstName, lastName, bio);
string auth = AuthHelper.CreateSocialPlusAuth(postUserResponse.SessionToken);
string userHandle = postUserResponse.UserHandle;
if (appPublished)
{
// add user as admin
bool added = ManageAppsUtils.AddAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
if (!added)
{
// delete the user and fail the test
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to set user as administrator");
}
}
string topicTitle = "Rarest coin";
string topicText = "Egyptian coin";
BlobType blobType = BlobType.Image;
string blobHandle = "http://myBlobHandle/";
string language = "en-US";
string deepLink = "coins:abcdef";
string categories = "photo, ncurrency";
string friendlyName = "abcde";
string group = "mygroup";
string topicHandle = string.Empty;
// step 1, create a topic
var postTopicRequest = new PostTopicRequest()
{
Text = topicText, Title = topicTitle, BlobType = blobType, BlobHandle = blobHandle, Categories = categories, Language = language, DeepLink = deepLink, FriendlyName = friendlyName, Group = group
};
if (appPublished)
{
postTopicRequest.PublisherType = PublisherType.App;
}
else
{
postTopicRequest.PublisherType = PublisherType.User;
}
var postTopicOperationResponse = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest, authorization : auth);
if (postTopicOperationResponse.Response.IsSuccessStatusCode)
{
topicHandle = postTopicOperationResponse.Body.TopicHandle;
}
else
{
// cleanup: delete the user
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to post topic.");
}
bool?initialPinValue = null;
bool?secondPinValue = null;
bool?finalPinValue = null;
// step 2, get the topic (and its pin status)
var getTopicOperationResponse = await client.Topics.GetTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (getTopicOperationResponse.Response.IsSuccessStatusCode)
{
initialPinValue = getTopicOperationResponse.Body.Pinned;
}
else
{
// cleanup: delete the topic and the user
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to get topic.");
}
// step 3, pin topic
PostPinRequest postPinRequest = new PostPinRequest()
{
TopicHandle = topicHandle
};
var postPinOperationResponse = await client.MyPins.PostPinWithHttpMessagesAsync(request : postPinRequest, authorization : auth);
if (!postPinOperationResponse.Response.IsSuccessStatusCode)
{
// cleanup: delete the topic and the user
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to pin topic.");
}
// step 4, get topic and its pin status again
getTopicOperationResponse = await client.Topics.GetTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (getTopicOperationResponse.Response.IsSuccessStatusCode)
{
secondPinValue = getTopicOperationResponse.Body.Pinned;
}
else
{
// cleanup: delete the topic and the user
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to get topic.");
}
// step 5, Delete Pin
var deletePinOperationResponse = await client.MyPins.DeletePinWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (!deletePinOperationResponse.Response.IsSuccessStatusCode)
{
// cleanup: delete the topic and the user
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to delete pin.");
}
// step 6, get topic yet again, and check pin status to see that it is now back to false
getTopicOperationResponse = await client.Topics.GetTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (getTopicOperationResponse.Response.IsSuccessStatusCode)
{
finalPinValue = getTopicOperationResponse.Body.Pinned;
}
else
{
// cleanup: delete the topic and the user
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
if (appPublished)
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to get pin.");
}
// cleanup: delete the topic and the user
await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : topicHandle, authorization : auth);
bool?adminDeleted = null;
if (appPublished)
{
adminDeleted = ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
}
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
if (appPublished)
{
Assert.IsTrue(adminDeleted.HasValue);
Assert.IsTrue(adminDeleted.Value);
}
Assert.IsTrue(initialPinValue.HasValue);
Assert.IsFalse(initialPinValue.Value);
Assert.IsTrue(secondPinValue.HasValue);
Assert.IsTrue(secondPinValue.Value);
Assert.IsTrue(finalPinValue.HasValue);
Assert.IsFalse(finalPinValue.Value);
}
public async Task ManualReportTesting()
{
// WARNING: do not run this test unless you are doing a test where you can tolerate 1-3 days of latency
// and can manually verify the result by inspecting Azure Tables
Assert.IsTrue(false);
// create two users with benign profiles
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
PostUserResponse postUserResponse1 = await TestUtilities.PostGenericUser(client);
string auth1 = AuthHelper.CreateSocialPlusAuth(postUserResponse1.SessionToken);
PostUserResponse postUserResponse2 = await TestUtilities.PostGenericUser(client);
string auth2 = AuthHelper.CreateSocialPlusAuth(postUserResponse2.SessionToken);
// issue a Threats / Cyberbullying / Harassment report from user 2 on user 1
PostReportRequest postReportRequest1 = new PostReportRequest(Reason.ThreatsCyberbullyingHarassment);
HttpOperationResponse <object> postUserReportOperationResponse1 = await client.UserReports.PostReportWithHttpMessagesAsync(userHandle : postUserResponse1.UserHandle, postReportRequest : postReportRequest1, authorization : auth2);
// issue a Content Infringment report from user 2
PostReportRequest postReportRequest2 = new PostReportRequest(Reason.ContentInfringement);
HttpOperationResponse <object> postUserReportOperationResponse2 = await client.UserReports.PostReportWithHttpMessagesAsync(userHandle : postUserResponse1.UserHandle, postReportRequest : postReportRequest2, authorization : auth2);
// check failure conditions
Assert.IsTrue(postUserReportOperationResponse1.Response.IsSuccessStatusCode);
Assert.IsTrue(postUserReportOperationResponse2.Response.IsSuccessStatusCode);
// create a threatening topic from user 1
PostTopicRequest postTopicRequest = new PostTopicRequest(publisherType: PublisherType.User, text: "I am going to beat you up.", title: "You're in big trouble.", blobType: BlobType.Custom, blobHandle: null, categories: null, language: null, deepLink: null, friendlyName: null, group: null);
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest, authorization : auth1);
string topicHandle = null;
if (postTopicOperationResponse != null && postTopicOperationResponse.Response.IsSuccessStatusCode)
{
topicHandle = postTopicOperationResponse.Body.TopicHandle;
}
// issue a Threats / Cyberbullying / Harassment report from user 2
PostReportRequest postTopicReportRequest1 = new PostReportRequest(Reason.ThreatsCyberbullyingHarassment);
HttpOperationResponse <object> postTopicReportOperationResponse1 = await client.TopicReports.PostReportWithHttpMessagesAsync(topicHandle : topicHandle, postReportRequest : postTopicReportRequest1, authorization : auth2);
// check failure conditions
Assert.IsTrue(postTopicOperationResponse.Response.IsSuccessStatusCode);
Assert.IsTrue(postTopicReportOperationResponse1.Response.IsSuccessStatusCode);
// create a benign comment from user 1
var postCommentOperationResponse = await TestUtilities.PostGenericComment(client, auth1, topicHandle);
var commentHandle = postCommentOperationResponse.CommentHandle;
// issue a Child Endangerment / Exploitation report from user 2
PostReportRequest postCommentReportRequest1 = new PostReportRequest(Reason.ChildEndangermentExploitation);
HttpOperationResponse <object> postCommentReportOperationResponse1 = await client.CommentReports.PostReportWithHttpMessagesAsync(commentHandle : commentHandle, postReportRequest : postCommentReportRequest1, authorization : auth2);
// check failure conditions
Assert.IsTrue(postCommentReportOperationResponse1.Response.IsSuccessStatusCode);
// create a profanity laden reply from user 1
PostReplyRequest postReplyRequest = new PostReplyRequest(text: "f**k. shit.");
HttpOperationResponse <PostReplyResponse> postReplyOperationResponse = await client.CommentReplies.PostReplyWithHttpMessagesAsync(commentHandle : commentHandle, request : postReplyRequest, authorization : auth1);
string replyHandle = null;
if (postReplyOperationResponse != null && postReplyOperationResponse.Response.IsSuccessStatusCode)
{
replyHandle = postReplyOperationResponse.Body.ReplyHandle;
}
// issue an Offensive Content report from user 2
PostReportRequest postReplyReportRequest1 = new PostReportRequest(Reason.OffensiveContent);
HttpOperationResponse <object> postReplyReportOperationResponse1 = await client.ReplyReports.PostReportWithHttpMessagesAsync(replyHandle : replyHandle, postReportRequest : postReplyReportRequest1, authorization : auth2);
// check failure conditions
Assert.IsTrue(postReplyOperationResponse.Response.IsSuccessStatusCode);
Assert.IsTrue(postReplyReportOperationResponse1.Response.IsSuccessStatusCode);
// do NOT clean up the users after the test ends
}
public async Task AppPublishedTopicSearchTest()
{
// create the client
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
// get the app handle
string appHandle = ManageAppsUtils.GetAppHandle(TestConstants.EnvironmentName);
if (string.IsNullOrWhiteSpace(appHandle))
{
// fail the test
Assert.Fail("Failed to lookup appHandle");
}
// create a user
var user = await TestUtilities.PostGenericUser(client);
var auth = AuthHelper.CreateSocialPlusAuth(user.SessionToken);
// get the user handle
string userHandle = user.UserHandle;
if (string.IsNullOrWhiteSpace(userHandle))
{
// fail the test
Assert.Fail("Failed to get userHandle");
}
// elevate the user to admin
bool added = ManageAppsUtils.AddAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
if (!added)
{
// delete the user and fail the test
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to set user as administrator");
}
// create a unique string to search on
string unique = Guid.NewGuid().ToString().Replace("-", string.Empty);
// post a topic published by the app
string topicTitle = unique;
string topicText = "Something";
BlobType blobType = BlobType.Unknown;
string blobHandle = string.Empty;
string language = "en-US";
string deepLink = string.Empty;
string categories = string.Empty;
string friendlyName = string.Empty;
string group = string.Empty;
PostTopicRequest postTopicRequest = new PostTopicRequest(publisherType: PublisherType.App, text: topicText, title: topicTitle, blobType: blobType, blobHandle: blobHandle, language: language, deepLink: deepLink, categories: categories, friendlyName: friendlyName, group: group);
HttpOperationResponse <PostTopicResponse> postTopicOperationResponse = await client.Topics.PostTopicWithHttpMessagesAsync(request : postTopicRequest, authorization : auth);
// If the post topic operation failed, clean up
if (postTopicOperationResponse == null || !postTopicOperationResponse.Response.IsSuccessStatusCode ||
postTopicOperationResponse.Body == null || string.IsNullOrWhiteSpace(postTopicOperationResponse.Body.TopicHandle))
{
ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.Fail("Failed to post topic");
}
// Delay a bit to allow data to get into the search
await Task.Delay(TestConstants.SearchDelay);
// search for the single result
HttpOperationResponse <FeedResponseTopicView> search = await client.Search.GetTopicsWithHttpMessagesAsync(query : unique, cursor : null, limit : 5, authorization : auth);
// Clean up topic
HttpOperationResponse <object> deleteTopic = await client.Topics.DeleteTopicWithHttpMessagesAsync(topicHandle : postTopicOperationResponse.Body.TopicHandle, authorization : auth);
// Clean up first user
bool deleteAdminResult = ManageAppsUtils.DeleteAdmin(TestConstants.EnvironmentName, appHandle, userHandle);
HttpOperationResponse <object> deleteUser = await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
// Verify search result
Assert.IsNotNull(search);
Assert.IsNotNull(search.Body);
Assert.IsNotNull(search.Body.Data);
Assert.AreEqual(1, search.Body.Data.Count);
Assert.AreEqual(postTopicOperationResponse.Body.TopicHandle, search.Body.Data[0].TopicHandle);
Assert.AreEqual(unique, search.Body.Data[0].Title);
// Verify deletions
Assert.IsNotNull(deleteTopic);
Assert.IsTrue(deleteTopic.Response.IsSuccessStatusCode);
Assert.IsTrue(deleteAdminResult);
Assert.IsNotNull(deleteUser);
Assert.IsTrue(deleteUser.Response.IsSuccessStatusCode);
}