public async Task ChangeLoggedInUsersPassword()
{
ClientWebSocket webSocket = new ClientWebSocket();
WebSocketHandler webSocketHandler = new WebSocketHandler(webSocket);
await webSocket.ConnectAsync(new Uri("ws://localhost:80/ws"), CancellationToken.None);
await TestHelper.Login("User", "Passwort1$", webSocket, webSocketHandler);
User user = new User
{
Username = "******",
Password = "******",
MustChangePassword = false
};
Command command = new Command("ChangePassword", user);
await TestHelper.ExecuteCommandAndAwaitResponse(webSocket, webSocketHandler, command);
ModifyUserResponse response = JsonConvert.DeserializeObject <ModifyUserResponse>(webSocketHandler.ReceivedCommand.CommandData.ToString());
TestHelper.ValiateResponse(response, ModifyUserResult.SUCCESS);
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Close", CancellationToken.None);
webSocket = new ClientWebSocket();
webSocketHandler = new WebSocketHandler(webSocket);
await webSocket.ConnectAsync(new Uri("ws://localhost:80/ws"), CancellationToken.None);
await TestHelper.Login("User", "Passwort2$", webSocket, webSocketHandler);
}
public async Task CreateUserAndDelete()
{
BesteUser besteUser = new BesteUser();
User user = new User
{
Username = "******",
Lastname = "Lastname",
Firstname = "Firstname",
Email = "Email",
Password = "******"
};
ModifyUserResponse response = await besteUser.CreateUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.SUCCESS);
User loginUser = new User
{
Username = user.Username,
Password = user.Password
};
response = await besteUser.DeleteUser(JsonConvert.SerializeObject(loginUser, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.SUCCESS);
}
public async Task UnknownUser()
{
BesteUser besteUser = new BesteUser();
User user = new User
{
Username = "******",
Password = "******"
};
BesteUserAuthentificationResponse authResponse = await besteUser.Authenticate(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(authResponse, BesteUserAuthentificationResult.USER_UNKNOWN);
ModifyUserResponse response = await besteUser.EditUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.USER_UNKNOWN);
response = await besteUser.ChangePasswordByUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.USER_UNKNOWN);
response = await besteUser.DeleteUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.USER_UNKNOWN);
}
public JsonResult Update(UserDetailView vm)
{
GetUserRequest request = new GetUserRequest();
request.UserId = vm.UserId;
ModifyUserRequest updateRequest = _userService.GetUser(request).User.ConvertToModifyUserRequest();
updateRequest.UserId = vm.UserId;
updateRequest.UserName = vm.UserName;
updateRequest.Email = vm.Email;
updateRequest.Password = vm.Password;
updateRequest.FirstName = vm.FirstName;
updateRequest.LastName = vm.LastName;
updateRequest.PhoneNumber = vm.PhoneNumber;
updateRequest.BirthDay = vm.BirthDay;
updateRequest.IpAddress = vm.IpAddress;
updateRequest.Status = vm.Status;
updateRequest.CreateDate = vm.CreateDate;
GetRoomRequest roomRequest = new GetRoomRequest();
roomRequest.RoomId = vm.RoomRoomId;
updateRequest.Room = _roomService.GetRoom(roomRequest).Room;
ModifyUserResponse response = _userService.ModifyUser(updateRequest);
return(Json(response));
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
ModifyUserResponse response = new ModifyUserResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.IsStartElement)
{
if (context.TestExpression("ModifyUserResult", 2))
{
UnmarshallResult(context, response);
continue;
}
if (context.TestExpression("ResponseMetadata", 2))
{
response.ResponseMetadata = ResponseMetadataUnmarshaller.Instance.Unmarshall(context);
}
}
}
return(response);
}
public async Task CreateUserAndChangePasswortBreakRules()
{
BesteUser besteUser = new BesteUser();
User user = new User
{
Username = "******",
Lastname = "Lastname",
Firstname = "Firstname",
Email = "Email",
Password = "******"
};
ModifyUserResponse response = await besteUser.CreateUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.SUCCESS);
User loginUser = new User
{
Username = user.Username,
Password = "******"
};
response = await besteUser.ChangePasswordByUser(JsonConvert.SerializeObject(loginUser, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.PASSWORD_GUIDELINES_ERROR);
}
public static ModifyUserResponse Unmarshall(UnmarshallerContext context)
{
ModifyUserResponse modifyUserResponse = new ModifyUserResponse();
modifyUserResponse.HttpResponse = context.HttpResponse;
modifyUserResponse.RequestId = context.StringValue("ModifyUser.RequestId");
modifyUserResponse.Success = context.BooleanValue("ModifyUser.Success");
modifyUserResponse.Code = context.StringValue("ModifyUser.Code");
modifyUserResponse.Message = context.StringValue("ModifyUser.Message");
modifyUserResponse.HttpStatusCode = context.IntegerValue("ModifyUser.HttpStatusCode");
return(modifyUserResponse);
}
public void RightViolation()
{
// The checking of rights must be done in the application which uses the Module.User
// This test checks for the result code existing
BesteUserAuthentificationResponse authResponse = new BesteUserAuthentificationResponse(BesteUserAuthentificationResult.RIGHT_VIOLATION, null);
ValiateResponse(authResponse, BesteUserAuthentificationResult.RIGHT_VIOLATION);
ModifyUserResponse response = new ModifyUserResponse(ModifyUserResult.RIGHT_VIOLATION, null, null, null);
ValiateResponse(response, ModifyUserResult.RIGHT_VIOLATION);
}
public async Task CreateUserMissingParams()
{
BesteUser besteUser = new BesteUser();
User user = new User();
user.Username = "******";
user.Password = "******";
ModifyUserResponse response = await besteUser.CreateUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.MISSING_USER_PARAMS);
}
public async Task CreateUserWrongPasswordGuidelines()
{
BesteUser besteUser = new BesteUser();
User user = new User();
user.Username = "******";
user.Lastname = "Lastname";
user.Firstname = "Firstname";
user.Email = "Email";
user.Password = "******";
ModifyUserResponse response = await besteUser.CreateUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.PASSWORD_GUIDELINES_ERROR);
}
public ModifyUserResponse ModifyUser(ModifyUserRequest request)
{
ModifyUserResponse response = new ModifyUserResponse();
User user = _userRepository
.FindBy(request.UserId);
user.Id = request.UserId;
user.UserName = request.UserName;
user.Email = request.Email;
user.Password = request.Password;
user.FirstName = request.FirstName;
user.LastName = request.LastName;
user.PhoneNumber = request.PhoneNumber;
user.BirthDay = request.BirthDay;
user.IpAddress = request.IpAddress;
user.Status = request.Status;
user.CreateDate = request.CreateDate;
user.Roles = request.Roles.ConvertToRoles();
user.Permissions = request.Permissions.ConvertToPermissions();
user.PosReceiptOfDeliveries = request.PosReceiptOfDeliveries.ConvertToPosReceiptOfDeliveries();
user.Room = request.Room.ConvertToRoom();
if (user.GetBrokenRules().Count() > 0)
{
response.Errors = user.GetBrokenRules().ToList();
}
else
{
try {
_userRepository.Save(user);
_uow.Commit();
response.Errors = new List <BusinessRule>();
} catch (Exception ex)
{
response.Errors = new List <BusinessRule>();
response.Errors.Add(new BusinessRule("DAL", "DAL_ERROR: " + ex.Message));
}
}
return(response);
}
private static async Task <Command> ModifyUser(Func <Task <ModifyUserResponse> > modifyAction, string actionName, WebSocketHandler webSocketHandler)
{
User user = JsonConvert.DeserializeObject <User>(webSocketHandler.ReceivedCommand.CommandData.ToString());
ModifyUserResponse response = null;
if (RightControl.IsGranted(webSocketHandler.ConnectedUserToken, actionName, "User"))
{
response = await modifyAction();
}
else if (RightControl.IsGranted(webSocketHandler.ConnectedUserToken, actionName + "_" + user.Username, "User"))
{
response = await modifyAction();
}
else
{
response = new ModifyUserResponse(ModifyUserResult.RIGHT_VIOLATION, null, null, null);
}
return(new Command(actionName + "Response", response));
}
public async Task CreateUserAndLogin()
{
BesteUser besteUser = new BesteUser();
User user = new User
{
Username = "******",
Lastname = "Lastname",
Firstname = "Firstname",
Email = "Email",
Password = "******"
};
ModifyUserResponse response = await besteUser.CreateUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.SUCCESS);
User loginUser = new User
{
Username = user.Username,
Password = user.Password
};
BesteUserAuthentificationResponse authResponse = await besteUser.Authenticate(JsonConvert.SerializeObject(loginUser, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(authResponse, BesteUserAuthentificationResult.MUST_CHANGE_PASSWORT);
response = await besteUser.ChangePasswordByUser(JsonConvert.SerializeObject(loginUser, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.SUCCESS);
authResponse = await besteUser.Authenticate(JsonConvert.SerializeObject(loginUser, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(authResponse, BesteUserAuthentificationResult.SUCCESS);
}
public static ModifyUserResponse Unmarshall(UnmarshallerContext _ctx)
{
ModifyUserResponse modifyUserResponse = new ModifyUserResponse();
modifyUserResponse.HttpResponse = _ctx.HttpResponse;
modifyUserResponse.Code = _ctx.StringValue("ModifyUser.Code");
modifyUserResponse.Data = _ctx.StringValue("ModifyUser.Data");
modifyUserResponse.HttpStatusCode = _ctx.IntegerValue("ModifyUser.HttpStatusCode");
modifyUserResponse.Message = _ctx.StringValue("ModifyUser.Message");
modifyUserResponse.RequestId = _ctx.StringValue("ModifyUser.RequestId");
List <string> modifyUserResponse_params = new List <string>();
for (int i = 0; i < _ctx.Length("ModifyUser.Params.Length"); i++)
{
modifyUserResponse_params.Add(_ctx.StringValue("ModifyUser.Params[" + i + "]"));
}
modifyUserResponse._Params = modifyUserResponse_params;
return(modifyUserResponse);
}
public async Task CreateUserAndWrongPasswortCounter()
{
BesteUser besteUser = new BesteUser();
User user = new User
{
Username = "******",
Lastname = "Lastname",
Firstname = "Firstname",
Email = "Email",
Password = "******"
};
ModifyUserResponse response = await besteUser.CreateUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.SUCCESS);
User loginUser = new User();
loginUser.Username = user.Username;
loginUser.Password = user.Password + "1";
BesteUserAuthentificationResponse authResponse;
for (int i = 0; i < 13; i++)
{
authResponse = await besteUser.Authenticate(JsonConvert.SerializeObject(loginUser, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(authResponse, BesteUserAuthentificationResult.WRONG_PASSWORD);
}
loginUser.Password = user.Password;
authResponse = await besteUser.Authenticate(JsonConvert.SerializeObject(loginUser, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(authResponse, BesteUserAuthentificationResult.WRONG_PASSWORD_COUNTER_TOO_HIGH);
}
public async Task CreateUserAndEdit()
{
BesteUser besteUser = new BesteUser();
User user = new User
{
Username = "******",
Lastname = "Lastname",
Firstname = "Firstname",
Email = "Email",
Password = "******"
};
ModifyUserResponse response = await besteUser.CreateUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.SUCCESS);
User loginUser = new User
{
Username = "******",
Lastname = "Lastname",
Firstname = "Firstname",
Email = "Email",
Password = "******",
MustChangePassword = false
};
response = await besteUser.EditUser(JsonConvert.SerializeObject(loginUser, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.SUCCESS);
BesteUserAuthentificationResponse authResponse = await besteUser.Authenticate(JsonConvert.SerializeObject(loginUser, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(authResponse, BesteUserAuthentificationResult.SUCCESS);
}
public async Task ForcedJsonSerializationErrors()
{
BesteUser besteUser = new BesteUser();
ModifyUserResponse response = await besteUser.CreateUser("no json]");
ValiateResponse(response, ModifyUserResult.JSON_ERROR);
response = await besteUser.ChangePasswordByUser("no json]");
ValiateResponse(response, ModifyUserResult.JSON_ERROR);
response = await besteUser.DeleteUser("no json]");
ValiateResponse(response, ModifyUserResult.JSON_ERROR);
response = await besteUser.EditUser("no json]");
ValiateResponse(response, ModifyUserResult.JSON_ERROR);
BesteUserAuthentificationResponse authResponse = await besteUser.Authenticate("no json]");
ValiateResponse(authResponse, BesteUserAuthentificationResult.JSON_ERROR);
}
public async Task AdminLoginAndChangePassword()
{
ClientWebSocket webSocket = new ClientWebSocket();
WebSocketHandler webSocketHandler = new WebSocketHandler(webSocket);
await webSocket.ConnectAsync(new Uri("ws://localhost:80/ws"), CancellationToken.None);
await TestHelper.Login("Admin", "Passwort1$", webSocket, webSocketHandler);
byte[] buffer = new byte[1024 * 4];
User user = new User
{
Username = "******",
Password = "******",
MustChangePassword = false
};
Command command = new Command("ChangePassword", user);
await TestHelper.ExecuteCommandAndAwaitResponse(webSocket, webSocketHandler, command);
ModifyUserResponse response = JsonConvert.DeserializeObject <ModifyUserResponse>(webSocketHandler.ReceivedCommand.CommandData.ToString());
TestHelper.ValiateResponse(response, ModifyUserResult.SUCCESS);
}
public async Task CreateDuplicateUser()
{
BesteUser besteUser = new BesteUser();
User user = new User
{
Username = "******",
Lastname = "Lastname",
Firstname = "Firstname",
Email = "Email",
Password = "******"
};
ModifyUserResponse response = await besteUser.CreateUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.SUCCESS);
response = await besteUser.CreateUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.USER_ALREADY_EXISTS);
}
public async Task ChangeOtherUsersPasswordNotAllowed()
{
ClientWebSocket webSocket = new ClientWebSocket();
WebSocketHandler webSocketHandler = new WebSocketHandler(webSocket);
await webSocket.ConnectAsync(new Uri("ws://localhost:80/ws"), CancellationToken.None);
await TestHelper.Login("UserTryChangePassword", "Passwort1$", webSocket, webSocketHandler);
BesteUserAuthentificationResponse loginResponse = JsonConvert.DeserializeObject <BesteUserAuthentificationResponse>(webSocketHandler.ReceivedCommand.CommandData.ToString());
User user = new User
{
Username = "******",
Password = "******",
MustChangePassword = false
};
Command command = new Command("ChangePassword", user);
await TestHelper.ExecuteCommandAndAwaitResponse(webSocket, webSocketHandler, command);
ModifyUserResponse response = JsonConvert.DeserializeObject <ModifyUserResponse>(webSocketHandler.ReceivedCommand.CommandData.ToString());
TestHelper.ValiateResponse(response, ModifyUserResult.RIGHT_VIOLATION);
}
public async Task CreateUserModifyAndDelete()
{
ClientWebSocket webSocket = new ClientWebSocket();
WebSocketHandler webSocketHandler = new WebSocketHandler(webSocket);
await webSocket.ConnectAsync(new Uri("ws://localhost:80/ws"), CancellationToken.None);
await TestHelper.Login("Admin", "Passwort1$", webSocket, webSocketHandler);
User user = new User
{
Username = "******",
Lastname = "Lastname",
Firstname = "Firstname",
Email = "Email",
Password = "******"
};
Command command = new Command("CreateUser", user);
await TestHelper.ExecuteCommandAndAwaitResponse(webSocket, webSocketHandler, command);
ModifyUserResponse modifyResponse = JsonConvert.DeserializeObject <ModifyUserResponse>(webSocketHandler.ReceivedCommand.CommandData.ToString());
TestHelper.ValiateResponse(modifyResponse, ModifyUserResult.SUCCESS);
user.Lastname = "LastnameNew";
command = new Command("EditUser", user);
await TestHelper.ExecuteCommandAndAwaitResponse(webSocket, webSocketHandler, command);
modifyResponse = JsonConvert.DeserializeObject <ModifyUserResponse>(webSocketHandler.ReceivedCommand.CommandData.ToString());
TestHelper.ValiateResponse(modifyResponse, ModifyUserResult.SUCCESS);
command = new Command("DeleteUser", user);
await TestHelper.ExecuteCommandAndAwaitResponse(webSocket, webSocketHandler, command);
modifyResponse = JsonConvert.DeserializeObject <ModifyUserResponse>(webSocketHandler.ReceivedCommand.CommandData.ToString());
TestHelper.ValiateResponse(modifyResponse, ModifyUserResult.SUCCESS);
}
public static async Task CreateInitialUsersAndRights()
{
await CleanUpBesteRightsAuthorization();
await CleanUpBesteUser();
await CleanUpServerSettings();
User adminUser = new User
{
Username = "******",
Lastname = "Admin",
Firstname = "Admin",
Email = "Email",
Password = "******"
};
ModifyUserResponse response = await BesteUser.CreateUser(JsonConvert.SerializeObject(adminUser, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
TestHelper.ValiateResponse(response, ModifyUserResult.SUCCESS);
User user = new User
{
Username = "******",
Lastname = "User",
Firstname = "User",
Email = "Email",
Password = "******"
};
response = await BesteUser.CreateUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
TestHelper.ValiateResponse(response, ModifyUserResult.SUCCESS);
user = new User
{
Username = "******",
Lastname = "User",
Firstname = "User",
Email = "Email",
Password = "******"
};
response = await BesteUser.CreateUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
TestHelper.ValiateResponse(response, ModifyUserResult.SUCCESS);
adminUser = await AmazonDynamoDBFactory.ExecuteInTransactionContext(async (client, context) =>
{
adminUser.TableId = TABLE_ID;
return(await context.LoadAsync(adminUser));
});
await AmazonDynamoDBFactory.ExecuteInTransactionContext(async (client, context) =>
{
await context.SaveAsync(new BesteRightsAuthorization
{
TableId = TABLE_ID,
Namespace = "Beste.GameServer.SDaysTDie.User",
Operation = "ChangePassword",
RecourceModule = "User",
RecourceId = null,
Authorized = true,
LegitimationUuid = adminUser.Uuid,
Uuid = Guid.NewGuid().ToString()
});
await context.SaveAsync(new BesteRightsAuthorization
{
TableId = TABLE_ID,
Namespace = "Beste.GameServer.SDaysTDie.User",
Operation = "CreateUser",
RecourceModule = "User",
RecourceId = null,
Authorized = true,
LegitimationUuid = adminUser.Uuid,
Uuid = Guid.NewGuid().ToString()
});
await context.SaveAsync(new BesteRightsAuthorization
{
TableId = TABLE_ID,
Namespace = "Beste.GameServer.SDaysTDie.User",
Operation = "DeleteUser",
RecourceModule = "User",
RecourceId = null,
Authorized = true,
LegitimationUuid = adminUser.Uuid,
Uuid = Guid.NewGuid().ToString()
});
await context.SaveAsync(new BesteRightsAuthorization
{
TableId = TABLE_ID,
Namespace = "Beste.GameServer.SDaysTDie.User",
Operation = "EditUser",
RecourceModule = "User",
RecourceId = null,
Authorized = true,
LegitimationUuid = adminUser.Uuid,
Uuid = Guid.NewGuid().ToString()
});
await context.SaveAsync(new BesteRightsAuthorization
{
TableId = TABLE_ID,
Namespace = "Beste.GameServer.SDaysTDie.User",
Operation = "GetUsers",
RecourceModule = "User",
RecourceId = null,
Authorized = true,
LegitimationUuid = adminUser.Uuid,
Uuid = Guid.NewGuid().ToString()
});
await context.SaveAsync(new BesteRightsAuthorization
{
TableId = TABLE_ID,
Namespace = "Beste.GameServer.SDaysTDie.User",
Operation = "GetUser",
RecourceModule = "User",
RecourceId = null,
Authorized = true,
LegitimationUuid = adminUser.Uuid,
Uuid = Guid.NewGuid().ToString()
});
});
}
private static void UnmarshallResult(XmlUnmarshallerContext context, ModifyUserResponse response)
{
int originalDepth = context.CurrentDepth;
int targetDepth = originalDepth + 1;
if (context.IsStartOfDocument)
{
targetDepth += 2;
}
while (context.ReadAtDepth(originalDepth))
{
if (context.IsStartElement || context.IsAttribute)
{
if (context.TestExpression("AccessString", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.AccessString = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("ARN", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.ARN = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("Authentication", targetDepth))
{
var unmarshaller = AuthenticationUnmarshaller.Instance;
response.Authentication = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("Engine", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.Engine = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("Status", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.Status = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("UserGroupIds/member", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
var item = unmarshaller.Unmarshall(context);
response.UserGroupIds.Add(item);
continue;
}
if (context.TestExpression("UserId", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.UserId = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("UserName", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.UserName = unmarshaller.Unmarshall(context);
continue;
}
}
}
return;
}
public async Task GetUsers()
{
BesteUser besteUser = new BesteUser();
User user = new User
{
Username = "******",
Lastname = "Lastname",
Firstname = "Firstname",
Email = "A_C_Email",
Password = "******"
};
ModifyUserResponse response = await besteUser.CreateUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.SUCCESS);
user.Username = "******";
user.Email = "A_B_Email";
response = await besteUser.CreateUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.SUCCESS);
user.Username = "******";
user.Email = "A_A_Email";
response = await besteUser.CreateUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(response, ModifyUserResult.SUCCESS);
GetUsersParams getUsersParams = new GetUsersParams(10, 0, SortUsersBy.USERNAME);
GetUsersResponse getUserResponse = await besteUser.GetUsers(JsonConvert.SerializeObject(getUsersParams, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(getUserResponse, GetUsersResult.SUCCESS);
if (getUserResponse.Users.Count < 3)
{
Assert.Fail("getUserResponse.Users.Count < 3");
}
if (getUserResponse.Users[0].Username != "A_A_User")
{
Assert.Fail("getUserResponse.Users[0].Username != 'A_A_User'");
}
getUsersParams = new GetUsersParams(10, 1, SortUsersBy.USERNAME);
getUserResponse = await besteUser.GetUsers(JsonConvert.SerializeObject(getUsersParams, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(getUserResponse, GetUsersResult.SUCCESS);
if (getUserResponse.Users.Count < 2)
{
Assert.Fail("getUserResponse.Users.Count < 2");
}
if (getUserResponse.Users[0].Username != "A_B_User")
{
Assert.Fail("getUserResponse.Users[0].Username != 'A_B_User'");
}
getUsersParams = new GetUsersParams(1, 1, SortUsersBy.USERNAME);
getUserResponse = await besteUser.GetUsers(JsonConvert.SerializeObject(getUsersParams, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(getUserResponse, GetUsersResult.SUCCESS);
if (getUserResponse.Users.Count != 1)
{
Assert.Fail("getUserResponse.Users.Count != 1");
}
if (getUserResponse.Users[0].Username != "A_B_User")
{
Assert.Fail("getUserResponse.Users[0].Username != 'A_B_User'");
}
getUsersParams = new GetUsersParams(10, 2, SortUsersBy.EMAIL);
getUserResponse = await besteUser.GetUsers(JsonConvert.SerializeObject(getUsersParams, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(getUserResponse, GetUsersResult.SUCCESS);
if (getUserResponse.Users[0].Email != "A_C_Email")
{
Assert.Fail("getUserResponse.Users[0].Email != 'A_C_Email'");
}
getUserResponse = await besteUser.GetUser(JsonConvert.SerializeObject(user, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
ValiateResponse(getUserResponse, GetUsersResult.SUCCESS);
if (getUserResponse.Users[0].Email != "A_A_Email")
{
Assert.Fail("getUserResponse.Users[0].Email != 'A_A_Email'");
}
}
