public async Task CreateUserTwiceDeleteUserTwice()
{
// Get the access token for the Embedded Social Test Client 1 AAD application
CertificateHelper certHelper = new CertificateHelper(ValidSPClient.CertThumbprint, ValidSPClient.ClientId, StoreLocation.CurrentUser);
string accessToken = await certHelper.GetAccessToken(ValidSPClient.Authority, ValidSPClient.AppUri);
string userHandle = HandleGenerator.GenerateShortHandle();
string auth = AuthHelper.CreateAADS2SAuth(accessToken, TestConstants.AppKey, userHandle);
// Set up initial stuff
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
PostUserRequest postUserRequest =
new PostUserRequest(instanceId: TestConstants.InstanceId, firstName: "Joseph", lastName: "Johnson", bio: "Some Bio");
HttpOperationResponse <PostUserResponse> postUserOperationResponse1 =
await client.Users.PostUserWithHttpMessagesAsync(request : postUserRequest, authorization : auth);
HttpOperationResponse <PostUserResponse> postUserOperationResponse2;
postUserOperationResponse2 = await client.Users.PostUserWithHttpMessagesAsync(request : postUserRequest, authorization : auth);
HttpOperationResponse <object> deleteUserOperationResponse1 =
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
HttpOperationResponse <object> deleteUserOperationResponse2 =
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
// Assert correct HTTP error codes
Assert.IsTrue(postUserOperationResponse1.Response.IsSuccessStatusCode);
Assert.AreEqual(HttpStatusCode.Conflict, postUserOperationResponse2.Response.StatusCode);
Assert.IsTrue(deleteUserOperationResponse1.Response.IsSuccessStatusCode);
}
public async Task <ActionResult> PostUser(PostUserRequest postUserRequest)
{
var user = await context.Users.FindAsync(postUserRequest.Id);
if (user != null)
{
return(BadRequest());
}
var entityUser = new User
{
Id = postUserRequest.Id,
Email = postUserRequest.Email,
Name = postUserRequest.Username,
Password = ComputeSHA256Hash(postUserRequest.Email),
LevelStats = new LevelStats
{
Level = 1,
Experience = 0
}
};
context.Users.Add(entityUser);
await context.SaveChangesAsync();
return(Created("random", null));
}
public async Task CreateDeleteUserWithValidAADTokenValidSPClient()
{
// Get the access token for a valid AAD application
CertificateHelper certHelper = new CertificateHelper(ValidSPClient.CertThumbprint, ValidSPClient.ClientId, StoreLocation.CurrentUser);
string accessToken = await certHelper.GetAccessToken(ValidSPClient.Authority, ValidSPClient.AppUri);
string userHandle = HandleGenerator.GenerateShortHandle();
string auth = AuthHelper.CreateAADS2SAuth(accessToken, TestConstants.AppKey, userHandle);
// Set up initial stuff
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
PostUserRequest postUserRequest =
new PostUserRequest(instanceId: TestConstants.InstanceId, firstName: "Joseph", lastName: "Johnson", bio: "Some Bio");
HttpOperationResponse <PostUserResponse> postUserOperationResponse =
await client.Users.PostUserWithHttpMessagesAsync(request : postUserRequest, authorization : auth);
HttpOperationResponse <object> deleteUserOperationResponse =
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
// Assert correct HTTP error codes
Assert.IsTrue(postUserOperationResponse.Response.IsSuccessStatusCode);
Assert.IsTrue(deleteUserOperationResponse.Response.IsSuccessStatusCode);
// PostUser also returns a non-empty session token and the user handle
Assert.IsFalse(string.IsNullOrEmpty(postUserOperationResponse.Body.SessionToken));
Assert.AreEqual(userHandle, postUserOperationResponse.Body.UserHandle);
}
public UserInfo Create(PostUserRequest userRequest)
{
Member member = new Member {
name = userRequest.UserInfo.name,
lastName = userRequest.UserInfo.lastName,
address = userRequest.UserInfo.address,
email = userRequest.UserInfo.email,
phone = userRequest.UserInfo.phone,
dob = userRequest.UserInfo.dob,
age = userRequest.UserInfo.age,
};
this._nasEntities.Members.Add(member);
Device device = new Device
{
osVersion = userRequest.DeviceInfo.osVersion,
notificationKey = userRequest.DeviceInfo.notificationKey,
idMember = member.id,
};
this._nasEntities.SaveChanges();
return(Mapper.Map <UserInfo>(member));
}
public async Task CreateDeleteUserWithValidAADTokenInvalidAudience()
{
// Get the access token for SocialPlus AAD application. While this is a valid AAD token,
// the service checks that the token's audience is "https://embeddedsocial.microsoft.com/testclient1".
// In this case, it is not. Instead, the audience is "https://embeddedsocial.microsoft.com/testclient2"
CertificateHelper certHelper = new CertificateHelper(InvalidSPClient.CertThumbprint, InvalidSPClient.ClientId, StoreLocation.CurrentUser);
string accessToken = await certHelper.GetAccessToken(InvalidSPClient.Authority, InvalidSPClient.AppUri);
string userHandle = HandleGenerator.GenerateShortHandle();
string auth = AuthHelper.CreateAADS2SAuth(accessToken, TestConstants.AppKey, userHandle);
// Set up initial stuff
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
PostUserRequest postUserRequest =
new PostUserRequest(instanceId: TestConstants.InstanceId, firstName: "Joseph", lastName: "Johnson", bio: "Some Bio");
HttpOperationResponse <PostUserResponse> postUserOperationResponse =
await client.Users.PostUserWithHttpMessagesAsync(request : postUserRequest, authorization : accessToken);
// the above post user operation should fail. but in case it doesn't, we clean up the user we created
HttpOperationResponse <object> deleteUserOperationResponse =
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : accessToken);
// both the create and delete operations should fail
Assert.AreEqual(HttpStatusCode.Unauthorized, postUserOperationResponse.Response.StatusCode);
Assert.AreEqual(HttpStatusCode.Unauthorized, deleteUserOperationResponse.Response.StatusCode);
}
static async Task RunCreateUserCommandAsync()
{
Console.WriteLine("Fill in the details of the new user");
Console.WriteLine("First name:");
var name = Console.ReadLine();
Console.WriteLine("Last name:");
var lastName = Console.ReadLine();
Console.WriteLine("Age:");
var age = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Email:");
var email = Console.ReadLine();
var user = new PostUserRequest()
{
FirstName = name, LastName = lastName, Age = age, Email = email
};
Console.WriteLine("Loading...");
await _httpService.CreateUserAsync(user);
Console.WriteLine("User successfully created");
}
public async Task IssueNonBatch()
{
// instantiate the handler
DelegatingHandler[] handlers = new DelegatingHandler[1];
InstrumentedHttpMessageHandler testHandler = new InstrumentedHttpMessageHandler();
handlers[0] = testHandler;
// instantiate the client
SocialPlusClient myClient = new SocialPlusClient(TestConstants.ServerApiBaseUrl, handlers);
// request server build info
HttpOperationResponse <GetBuildInfoResponse> buildsResponse = await myClient.Config.GetBuildInfoWithHttpMessagesAsync();
VerifyBuildsResponse(buildsResponse);
// login
PostUserRequest postUserRequest = new PostUserRequest(InstanceId, "Bob", "Smith", "mybio", null);
string userHandle = HandleGenerator.GenerateShortHandle();
string auth = await TestUtilities.GetAADAuth(userHandle);
HttpOperationResponse <PostUserResponse> postUserResponse = await myClient.Users.PostUserWithHttpMessagesAsync(request : postUserRequest, authorization : auth);
VerifyPostUserResponse(postUserResponse);
// delete login
auth = AuthHelper.CreateSocialPlusAuth(postUserResponse.Body.SessionToken);
HttpOperationResponse <object> deleteUserResponse = await myClient.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.IsTrue(deleteUserResponse.Response.IsSuccessStatusCode);
}
public IHttpActionResult Create([FromBody] PostUserRequest userRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
UserInfo userInfo = MemberService.Create(userRequest);
return(CreatedAtRoute("DefaultUserApi", new { id = userInfo.id }, userInfo));
}
/// <summary>
/// Create a user
/// </summary>
/// <returns>result of create user operation</returns>
public async Task <IHttpActionResult> PostUser()
{
var postUserRequest = new PostUserRequest
{
InstanceId = "UserControllerTests",
FirstName = "Barack" + this.seqNumber.GenerateStronglyOrderedSequenceNumber(),
LastName = "Obama" + this.seqNumber.GenerateStronglyOrderedSequenceNumber(),
};
return(await this.PostUser(postUserRequest));
}
public Guid PostUserController(
[FromServices] IRequestClient <PostUserRequest> requestClient,
[FromBody] User user)
{
PostUserRequest rquest = new PostUserRequest();
rquest.User = user;
var response = requestClient.GetResponse <PostUserResponse>(rquest);
return(response.Result.Message.Id);
//return command.Exequte(user);
}
public PostUserResponse Post(PostUserRequest request)
{
var result = userService.Put(new PutUserRequest
{
Data = request.Data,
User = request.User
});
return(new PostUserResponse {
Data = result.Data
});
}
public async Task CreateUserAsync(PostUserRequest user)
{
var json = JsonConvert.SerializeObject(user);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await _client.PostAsync(baseUserAPIURL, content);
if (!response.IsSuccessStatusCode)
{
throw new HttpServiceException("Service error");
}
}
public void TestPostUserRequest()
{
var expectedEmail = "*****@*****.**";
var examination = new PostUserRequest
{
Email = expectedEmail
};
var response = _mapper.Map <MeUser>(examination);
response.Email.Should().Be(expectedEmail);
}
public async Task <ActionResult <PostUserResponse> > PostUser([FromBody] PostUserRequest request)
{
var response = await _mediator.Send(request);
if (response != null)
{
return(Ok());
}
else
{
return(StatusCode(500));
}
}
public void WhenWeCreateAUser()
{
var requestBody = new PostUserRequest()
{
Name = firstName, Job = job
};
var request = api.CreatePostRequest <PostUserRequest>(requestBody);
var resturl = api.SetUrl("api/users");
var response = api.GetResponse(resturl, request);
UserResponse content = api.GetContent <UserResponse>(response);
}
public async Task TestCreateUserOkResponse()
{
// Arrange
const string expectedUserId = "expectedUserId";
const string expectedEmail = "*****@*****.**";
const string oktaFirstName = "oktaFirstName";
const string oktaLastName = "oktaLastName";
const string oktaId = "oktaId";
const string oktaEmail = "oktaEmail";
var request = new PostUserRequest
{
Email = expectedEmail,
};
var user = new MeUser
{
UserId = expectedUserId,
Email = expectedEmail,
};
var oktaUser = new Mock <IUser>(MockBehavior.Strict);
oktaUser.Setup(u => u.Id).Returns(oktaId);
oktaUser.Setup(u => u.Profile.FirstName).Returns(oktaFirstName);
oktaUser.Setup(u => u.Profile.LastName).Returns(oktaLastName);
oktaUser.Setup(u => u.Profile.Email).Returns(oktaEmail);
_mockOktaClient
.Setup(s => s.Users.GetUserAsync(It.IsAny <string>(), default(CancellationToken)))
.Returns(Task.FromResult(oktaUser.Object));
_createUserService
.Setup(cus => cus.Handle(It.IsAny <CreateUserQuery>()))
.Returns(Task.FromResult(user));
Controller.ControllerContext = GetControllerContext();
// Act
var response = await Controller.CreateUser(request);
// Assert
response.Result.Should().BeAssignableTo <OkObjectResult>();
var result = (OkObjectResult)response.Result;
result.Value.Should().BeAssignableTo <PostUserResponse>();
var model = (PostUserResponse)result.Value;
model.Errors.Count.Should().Be(0);
model.Success.Should().BeTrue();
model.UserId.Should().Be(expectedUserId);
}
private void PersistUser(PostUserRequest request)
{
try
{
object persistenceResponse = _persistenceService.GetPersistenceValueWithKey("email");
if (persistenceResponse.Equals("error"))
{
_persistenceService.SetPersistenceValueAndKey("email", request.email);
}
}
catch (Exception e)
{
// _pageService.DisplayAlert("Erreur de persistence", e.Message ,"OK");
}
}
private async Task UpdateOnAppearing()
{
if (!isInitialized)
{
PostUserRequest request = await RegisterUser();
if (request.email != null)
{
PersistUser(request);
}
isInitialized = true;
}
//GetUserActiveRegistrations();
}
/// <summary>
/// Generic call to get create a user using the new communication library
/// </summary>
/// <param name="client"> social plus client</param>
/// <param name="firstName"> first name of user to be created</param>
/// <param name="lastName"> last name of user to be created</param>
/// <param name="bio"> bio of user to be created</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public static async Task <PostUserResponse> DoLogin(SocialPlusClient client, string firstName, string lastName, string bio)
{
PostUserRequest postUserRequest = new PostUserRequest(instanceId: "test", firstName: firstName, lastName: lastName, bio: bio);
string userHandle = HandleGenerator.GenerateShortHandle();
string auth = await TestUtilities.GetAADAuth(userHandle);
HttpOperationResponse <PostUserResponse> postUserOperationResponse = await client.Users.PostUserWithHttpMessagesAsync(request : postUserRequest, authorization : auth);
if (!postUserOperationResponse.Response.IsSuccessStatusCode)
{
throw new Exception("got " + postUserOperationResponse.Response.StatusCode);
}
return(postUserOperationResponse.Body);
}
public async Task <ActionResult <User> > Post(PostUserRequest userRequest)
{
var userId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
if (string.IsNullOrWhiteSpace(userId))
{
return(BadRequest("No userId found."));
}
if (string.IsNullOrWhiteSpace(userId))
{
return(BadRequest("No userId found."));
}
if (string.IsNullOrWhiteSpace(userRequest.Username))
{
return(BadRequest("Username cannot be empty."));
}
if (userRequest.Username.Length > 30)
{
return(BadRequest("Username cannot be longer than 30 characters."));
}
var users = await _userManager.SearchUsersAsync(userRequest.Username);
if (users.Any(u => u.Id != userId))
{
return(BadRequest("Username is taken."));
}
var user = new User
{
ContentSourceEnum = ContentSource.Community,
ContentTypeEnum = ContentType.CommunityContent,
RowKey = userId,
PartitionKey = ContentType.CommunityContent.ToString(),
Id = userId,
Username = userRequest.Username
};
await _tableStorage.AddOrUpdateAsync("users", user);
return(Ok(user));
}
public async Task IssueBatch()
{
// instantiate the handler
DelegatingHandler[] handlers = new DelegatingHandler[1];
Uri batchURL = new Uri(TestConstants.ServerApiBaseUrl.OriginalString + "batch");
BatchHttpMessageHandler batchHandler = new BatchHttpMessageHandler(HttpMethod.Post, batchURL);
handlers[0] = batchHandler;
// instantiate the client, passing in the handler
SocialPlusClient myClient = new SocialPlusClient(TestConstants.ServerApiBaseUrl, handlers);
// request server build info
Task <HttpOperationResponse <GetBuildInfoResponse> > getBuildsTask = myClient.Config.GetBuildInfoWithHttpMessagesAsync();
// request login
// Get the access token for the Embedded Social Test Client 1 AAD application
string userHandle = HandleGenerator.GenerateShortHandle();
string auth = await TestUtilities.GetAADAuth(userHandle);
PostUserRequest postUserRequest = new PostUserRequest(InstanceId, "Bob", "Smith", "mybio", null);
Task <HttpOperationResponse <PostUserResponse> > postUserTask = myClient.Users.PostUserWithHttpMessagesAsync(request: postUserRequest, authorization: auth);
// issue the batch
await batchHandler.IssueBatch();
// verify server build info
HttpOperationResponse <GetBuildInfoResponse> buildsResponse = await getBuildsTask;
VerifyBuildsResponse(buildsResponse);
// verify user login info
HttpOperationResponse <PostUserResponse> postUserResponse = await postUserTask;
VerifyPostUserResponse(postUserResponse);
// delete login
SocialPlusClient myClient2 = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
auth = AuthHelper.CreateSocialPlusAuth(postUserResponse.Body.SessionToken);
HttpOperationResponse <object> deleteUserResponse = await myClient2.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
Assert.IsTrue(deleteUserResponse.Response.IsSuccessStatusCode);
}
public async Task TestCreateUserVerificationFailure()
{
// Arrange
Controller.ModelState.AddModelError("An", "Error");
// Act
var request = new PostUserRequest();
var response = await Controller.CreateUser(request);
// Assert
response.Result.Should().BeAssignableTo <BadRequestObjectResult>();
var result = (BadRequestObjectResult)response.Result;
result.Value.Should().BeAssignableTo <PostUserResponse>();
var model = (PostUserResponse)result.Value;
model.Errors.Count.Should().Be(1);
model.Success.Should().BeFalse();
}
public async Task CreateGetDeleteUserWithMSAAccessToken()
{
// Need to Manually get the Access Token for a Microsoft Account before running tests.
// Directions:
// 1) Put this URL in browser:
// https://login.live.com/oauth20_authorize.srf?client_id=0000000040169587&scope=wl.signin%20wl.basic&response_type=token&redirect_uri=http://research.microsoft.com
// 2) Redirects to RMC - copy the redirected URL in MyURL constant below ...
// Will look like this:
string myURL = "https://www.microsoft.com/en-us/research/#access_token=EwD4Aq1DBAAUGCCXc8wU/zFu9QnLdZXy%2bYnElFkAAbU00OJc7OUURhrM11nflV99uPC4rgUL1k7bE%2bVOqRMK0i5YY%2bvF7TennG%2beoRFxYeuiDWJiwxSxe8%2bwuDALuEUN%2bf2fZ7AjJoGfAZ7tZXQGAQLJ9bbz/7bglfs6pSYpLJT8uJhEKN5jC3%2b0pMqRwOUOzaZ3TquL3DMydR6IiNpspPeIzS7NpuvLYCHW/r8iLrasHD7ntoke6IXLxQ4o3VlfmYf/v5PuJh7Gh2ip%2bGxdfX67INfR/HhVRj7Nrse2XLkQaGXSqPPZ%2bI4O0hBX/n1qeNkxowNLvTSSSowDcKbBc/j6MR8FjcTZH3AO7gOK69fCqV0SZ0mFNKGkb34iWBEDZgAACBydF1wP9oeEyAFQizCqMAQY8DNfr1ng7z/X1J%2bIj3NYIQFPliNp1ueTMSN4fnUGDORw8sNbkG/5OI3yWl2NOUtEStIAigp3ZDx3Z7ReoG4BtAycYx4ulfXbqMtcz2KqKzH0Qct8ZN5G2cpi6GApxH9t7ElJBVV9i3tsm0Rs0hEWt7Pyiyqz6HoBbSSd/Wq4BzrevpaxP6uzT54z1oRdNOCNc4Hidaj7xvjDjwd/av6gW72ZeH1xvx9k129pPgLFrEVWV0k6/82mvt%2bN6C8RoZLgInrsbQd6vyLL7sqDHh1j59ZSPeSufJ5Sku4qvriDtdj6FyZ4PY2f3qWN2FnZ6gWzHlsGkjcVLIpHSEC2txEzIJMyL3pHYdLtTIsX5Nrf1tpKK6ODn2e14QpmtG%2bD%2b3j5yzupImOkn7DRkud8RYhghIqWm7OnAqCFZFRddj9UKiE/ok7mr3A2QnseSay%2bwi9Y3Zudb47CgDk8Nr9ROuGqatBJgm%2bZvKq7ue%2bds3JSZUUh8iTHVGq7JjYa9kD0IDzAJWXxQipH1XZlEyIpmY6beP5vPz6OaN%2bWueKOt%2bAQvUEQdMcWimL8mmAZIvUI8FskpxxS8ds%2bpGuBaGjXa/h3BsfvAQ%3d%3d&token_type=bearer&expires_in=3600&scope=wl.signin%20wl.basic&authentication_token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiIsImtpZCI6IjEifQ.eyJ2ZXIiOjEsImlzcyI6InVybjp3aW5kb3dzOmxpdmVpZCIsImV4cCI6MTQ3NTExMDU1OCwidWlkIjoiOTc1ZWQ2NjRiZDA0ZTQyOTliNTgzYTlhOTcyNTY1OTQiLCJhdWQiOiJzcC1kZXYtdGVzdC5jbG91ZGFwcC5uZXQiLCJ1cm46bWljcm9zb2Z0OmFwcHVyaSI6ImFwcGlkOi8vMDAwMDAwMDA0MDE2OTU4NyIsInVybjptaWNyb3NvZnQ6YXBwaWQiOiIwMDAwMDAwMDQwMTY5NTg3In0.WKb0Nxua1jkQeUf8mIKVnZV5bQUdr00OSk6o7h5e1Zk&user_id=975ed664bd04e4299b583a9a97256594";
string auth = "Microsoft AK = " + TestConstants.AppKey + "| TK = " + AuthHelper.GetMSAAccessTokenFromURL(myURL);
// Set up initial stuff
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
PostUserRequest postUserRequest =
new PostUserRequest(instanceId: TestConstants.InstanceId, firstName: "Joseph", lastName: "Johnson", bio: "Some Bio");
HttpOperationResponse <PostUserResponse> postUserOperationResponse =
await client.Users.PostUserWithHttpMessagesAsync(request : postUserRequest, authorization : auth);
// Assert correct HTTP error codes. If incorrect, we do not need to delete the user any longer
Assert.IsTrue(postUserOperationResponse.Response.IsSuccessStatusCode);
// PostUser also returns a non-empty session token and the user handle
Assert.IsFalse(string.IsNullOrEmpty(postUserOperationResponse.Body.SessionToken));
Assert.IsFalse(string.IsNullOrEmpty(postUserOperationResponse.Body.UserHandle));
// Get the user using the OAuth credentials
HttpOperationResponse <UserProfileView> userProfile = await client.Users.GetMyProfileWithHttpMessagesAsync(authorization : auth);
// Assert correct user profile
Assert.IsTrue(userProfile.Response.IsSuccessStatusCode);
Assert.AreEqual(postUserOperationResponse.Body.UserHandle, userProfile.Body.UserHandle);
// Delete the user using the session token
auth = AuthHelper.CreateSocialPlusAuth(postUserOperationResponse.Body.SessionToken);
HttpOperationResponse <object> deleteUserOperationResponse =
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
// Assert delete was successful
Assert.IsTrue(deleteUserOperationResponse.Response.IsSuccessStatusCode);
}
public async Task CreateGetDeleteUserWithFacebookAccessToken()
{
// Need to Manually get the Access Token for a Facebook Account before running tests.
// Directions for using an app registered by Stefan but for whom Sharad and Alec have access also:
// 1) Put this URL in browser:
// https://www.facebook.com/v2.5/dialog/oauth?client_id=552285811539105&response_type=token&redirect_uri=https%3A%2F%2Fwww.facebook.com/connect/login_success.html
// 2) Login to Facebook. Once log-in is successful, copy the URL immediately (sometimes the browser will show the URL for 1 second and then hide it).
// Will look like this:
string myURL = "https://www.facebook.com/connect/login_success.html#access_token=EAAH2TQZBcfKEBAFKQKTpgMjpnLvBIcX82IH248LqZCfcxtRwlczQHATBH8eMwaYgQB7AW9eZBnPZClOeXCkC9IZByo9GWx4dOZCP2RPx0tg5JBfNxDQQfTZB5ppjbS5cJ85c4615VboF7Eo1WEOELaAI88EUUrkr4wZD&expires_in=5183996";
string auth = "Facebook AK = " + TestConstants.AppKey + "| TK = " + AuthHelper.GetFacebookAccessTokenFromURL(myURL);
// Set up initial stuff
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
PostUserRequest postUserRequest =
new PostUserRequest(instanceId: TestConstants.InstanceId, firstName: "Joseph", lastName: "Johnson", bio: "Some Bio");
HttpOperationResponse <PostUserResponse> postUserOperationResponse =
await client.Users.PostUserWithHttpMessagesAsync(request : postUserRequest, authorization : auth);
// Assert correct HTTP error codes. If incorrect, we do not need to delete the user any longer
Assert.IsTrue(postUserOperationResponse.Response.IsSuccessStatusCode);
// PostUser also returns a non-empty session token and the user handle
Assert.IsFalse(string.IsNullOrEmpty(postUserOperationResponse.Body.SessionToken));
Assert.IsFalse(string.IsNullOrEmpty(postUserOperationResponse.Body.UserHandle));
// Get the user using the OAuth credentials
HttpOperationResponse <UserProfileView> userProfile = await client.Users.GetMyProfileWithHttpMessagesAsync(authorization : auth);
// Assert correct user profile
Assert.IsTrue(userProfile.Response.IsSuccessStatusCode);
Assert.AreEqual(postUserOperationResponse.Body.UserHandle, userProfile.Body.UserHandle);
// Delete the user using the session token
auth = AuthHelper.CreateSocialPlusAuth(postUserOperationResponse.Body.SessionToken);
HttpOperationResponse <object> deleteUserOperationResponse =
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
// Assert delete was successful
Assert.IsTrue(deleteUserOperationResponse.Response.IsSuccessStatusCode);
}
public async Task TestCreateUserArgumentException()
{
// Arrange
const string oktaFirstName = "oktaFirstName";
const string oktaLastName = "oktaLastName";
const string oktaId = "oktaId";
const string oktaEmail = "oktaEmail";
_createUserService
.Setup(cus => cus.Handle(It.IsAny <CreateUserQuery>()))
.Throws <ArgumentException>();
var request = new PostUserRequest();
Controller.ControllerContext = GetControllerContext();
var oktaUser = new Mock <IUser>(MockBehavior.Strict);
oktaUser.Setup(u => u.Id).Returns(oktaId);
oktaUser.Setup(u => u.Profile.FirstName).Returns(oktaFirstName);
oktaUser.Setup(u => u.Profile.LastName).Returns(oktaLastName);
oktaUser.Setup(u => u.Profile.Email).Returns(oktaEmail);
_mockOktaClient
.Setup(s => s.Users.GetUserAsync(It.IsAny <string>(), default(CancellationToken)))
.Returns(Task.FromResult(oktaUser.Object));
// Act
var response = await Controller.CreateUser(request);
// Assert
response.Result.Should().BeAssignableTo <NotFoundObjectResult>();
var result = (NotFoundObjectResult)response.Result;
result.Value.Should().BeAssignableTo <PostUserResponse>();
var model = (PostUserResponse)result.Value;
model.Errors.Count.Should().Be(0);
model.Success.Should().BeTrue();
model.UserId.Should().Be(null);
}
public async Task <ActionResult <PostUserResponse> > CreateUser([FromBody] PostUserRequest postUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(new PostUserResponse()));
}
try
{
var oktaUser = await _oktaClient.Users.GetUserAsync(postUser.Email);
if (oktaUser == null)
{
var response = new PostUserResponse();
response.AddError(nameof(PostUserRequest.Email), "Okta User doesn't exist for email");
return(BadRequest(response));
}
var userToCreate = new MeUser
{
OktaId = oktaUser.Id,
FirstName = oktaUser.Profile.FirstName,
LastName = oktaUser.Profile.LastName,
Email = oktaUser.Profile.Email,
};
var currentUser = await CurrentUser();
var createdUser = await _userCreationService.Handle(new CreateUserQuery(userToCreate, currentUser));
return(Ok(Mapper.Map <PostUserResponse>(createdUser)));
}
catch (DocumentClientException)
{
return(NotFound(new PostUserResponse()));
}
catch (ArgumentException)
{
return(NotFound(new PostUserResponse()));
}
}
public async Task <UserResponse> PostUser([FromBody] PostUserRequest request)
{
var appUser = userManager.FindByNameAsync(request.Email);
if (appUser.Result != null)
{
return new UserResponse {
Data = null, Message = "ایمیل وارد شده توسط فرد دیگری استفاده می شود"
}
}
;
var user = new User
{
Email = request.Email,
FirstName = request.FirstName,
LastName = request.LastName,
PasswordHash = request.Password,
UserName = request.Email
};
var result = await userManager.CreateAsync(user);
if (!result.Succeeded)
{
return new UserResponse {
Data = null, Message = "اطلاعات با عدم موفقیت پایان یافت"
}
}
;
string[] roles = { "User" };
string jwtString = jwt.GenerateJwtToken(user, roles);
await userManager.SetAuthenticationTokenAsync(user, "", "jwt", jwtString);
await userManager.AddToRoleAsync(user, "User");
return(new UserResponse {
Message = "اطلاعات با موفقیت ثبت شد", Data = jwtString
});
}
public async Task CreateDeleteUserWithInvalidAADToken()
{
// Create fake access token
string fakeAccessToken = "Stefan Rules!";
string userHandle = HandleGenerator.GenerateShortHandle();
string auth = AuthHelper.CreateAADS2SAuth(fakeAccessToken, TestConstants.AppKey, userHandle);
// Set up initial stuff
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
PostUserRequest postUserRequest =
new PostUserRequest(instanceId: TestConstants.InstanceId, firstName: "Joseph", lastName: "Johnson", bio: "Some Bio");
HttpOperationResponse <PostUserResponse> postUserOperationResponse =
await client.Users.PostUserWithHttpMessagesAsync(request : postUserRequest, authorization : auth);
// the above post user operation should fail. but in case it doesn't, we clean up the user we created
HttpOperationResponse <object> deleteUserOperationResponse =
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
// both the create and delete operations should fail
Assert.AreEqual(HttpStatusCode.Unauthorized, postUserOperationResponse.Response.StatusCode);
Assert.AreEqual(HttpStatusCode.Unauthorized, deleteUserOperationResponse.Response.StatusCode);
}
public async Task TestCreateUserReturnsBadRequest_WhenOktaUserNotFound()
{
// Arrange
Controller.ControllerContext = GetControllerContext();
_mockOktaClient
.Setup(s => s.Users.GetUserAsync(It.IsAny <string>(), default(CancellationToken)))
.Returns(Task.FromResult((IUser)null));
var request = new PostUserRequest();
// Act
var response = await Controller.CreateUser(request);
// Assert
response.Result.Should().BeAssignableTo <BadRequestObjectResult>();
var result = (BadRequestObjectResult)response.Result;
result.Value.Should().BeAssignableTo <PostUserResponse>();
var model = (PostUserResponse)result.Value;
model.Errors.Count.Should().Be(1);
model.Success.Should().BeFalse();
}
public async Task GetFriendSuggestions()
{
// Facebook Access token. Have to get it manually
// Get Access Token from here: https://developers.facebook.com/tools/explorer/ -- make sure to select the scope "user_friends"
string fbAccessToken = "EAACEdEose0cBAIbxq9XeXJVQBNS02S2ytfGPACMvVWZCEyhq0TpxSrlQedGW2UyZAUIm0vh7Sr24xwnAnZChBHuPGLspLSRoZCFWGCvZAKe6VxLc8umrDQxSZAk7KQZAS1py7xudtAYgBmms7h19kIaEZBNT1DAZCp3p48dTK3moTq8yJX9nksgCkIpDRLoNnYC0ZD";
string auth = "Facebook AK = " + TestConstants.AppKey + "| TK = " + fbAccessToken;
// Set up initial stuff
SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl);
PostUserRequest postUserRequest =
new PostUserRequest(instanceId: TestConstants.InstanceId, firstName: "Joseph", lastName: "Johnson", bio: "Some Bio");
HttpOperationResponse <PostUserResponse> postUserOperationResponse =
await client.Users.PostUserWithHttpMessagesAsync(request : postUserRequest, authorization : auth);
// Assert correct HTTP error codes. If incorrect, we do not need to delete the user any longer
Assert.IsTrue(postUserOperationResponse.Response.IsSuccessStatusCode);
// PostUser also returns a non-empty session token and the user handle
Assert.IsFalse(string.IsNullOrEmpty(postUserOperationResponse.Body.SessionToken));
Assert.IsFalse(string.IsNullOrEmpty(postUserOperationResponse.Body.UserHandle));
// Get friend suggestions using the Facebook auth
HttpOperationResponse <IList <UserCompactView> > friendList = await client.MyFollowing.GetSuggestionsUsersWithHttpMessagesAsync(authorization : auth);
// Assert call went throuhg
Assert.IsTrue(friendList.Response.IsSuccessStatusCode);
// Delete the user
auth = AuthHelper.CreateSocialPlusAuth(postUserOperationResponse.Body.SessionToken);
HttpOperationResponse <object> deleteUserOperationResponse =
await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth);
// Assert delete was successful
Assert.IsTrue(deleteUserOperationResponse.Response.IsSuccessStatusCode);
}
public PostUserResponse Post(PostUserRequest request)
{
var result = userService.Put(new PutUserRequest
{
Data = request.Data,
User = request.User
});
return new PostUserResponse { Data = result.Data };
}
public PostUserResponse Post(PostUserRequest request)
{
throw new CmsException(UsersApiConstants.UsersApiHasNoImplementationMessage);
}
