public void UpdateEntityShouldTranslateToUserGridErrorAndThrowWhenServiceReturnsNotFound()
{
var restResponseContent = new UsergridError
{
Description = "Service resource not found",
Error = "service_resource_not_found"
};
const string collectionName = "collection";
const string identifier = "identifier";
var entityToPost = new { FirstName = "first", LastName = "last" };
IRestResponse <UsergridError> restResponse = Helpers.SetUpRestResponseWithContent <UsergridError>(HttpStatusCode.NotFound, restResponseContent);
_request
.ExecuteJsonRequest(Arg.Any <string>(), Arg.Any <Method>(), Arg.Any <object>())
.Returns(restResponse);
try
{
_entityManager.UpdateEntity(collectionName, identifier, entityToPost);
new AssertionException("UserGridException was expected to be thrown here");
}
catch (UsergridException e)
{
Assert.AreEqual("service_resource_not_found", e.ErrorCode);
Assert.AreEqual("Service resource not found", e.Message);
}
}
public void CreateEntityShouldTranslateToUserGridErrorAndThrowWhenServiceReturnsBadRequest()
{
var restResponseContent = new UsergridError
{
Description = "Subject does not have permission",
Error = "unauthorized"
};
const string collectionName = "collection";
IRestResponse <UsergridError> restResponse = Helpers.SetUpRestResponseWithContent <UsergridError>(HttpStatusCode.BadRequest, restResponseContent);
_request
.ExecuteJsonRequest(Arg.Any <string>(), Arg.Any <Method>(), Arg.Any <object>())
.Returns(restResponse);
try
{
_entityManager.CreateEntity(collectionName, new object());
new AssertionException("UserGridException was expected to be thrown here");
}
catch (UsergridException e)
{
Assert.AreEqual("unauthorized", e.ErrorCode);
Assert.AreEqual("Subject does not have permission", e.Message);
}
}
public void ShouldTranslateToUserGridErrorAndThrowWhenServiceReturnsBadRequest()
{
string restResponseContent = new UsergridError {
Description = "Invalid username or password", Error = "invalid_grant"
}.Serialize();
var restResponse = Substitute.For <IRestResponse <LoginResponse> >();
restResponse.StatusCode.Returns(HttpStatusCode.BadRequest);
restResponse.Content.Returns(restResponseContent);
var request = Substitute.For <IUsergridRequest>();
request
.Execute <LoginResponse>(Arg.Any <string>(), Arg.Any <Method>(), Arg.Any <object>(), Arg.Any <string>())
.Returns(restResponse);
var client = new Client(null, null, request: request);
try
{
client.Login(null, null, AuthType.ClientId);
throw new AssertionException("UserGridException was expected to be thrown here");
}
catch (UsergridException e)
{
Assert.AreEqual("invalid_grant", e.ErrorCode);
Assert.AreEqual("Invalid username or password", e.Message);
}
}
public UsergridCollection <T> GetPreviousEntities <T>(string collectionName, string query = null)
{
if (!_cursorStates.ContainsKey(typeof(T)))
{
var error = new UsergridError
{
Error = "cursor_not_initialized",
Description = "Call GetEntities method to initialize the cursor"
};
throw new UsergridException(error);
}
Stack <string> stack = _cursorStates[typeof(T)];
stack.Pop();
stack.Pop();
string cursor = stack.Peek();
int limit = _pageSizes[typeof(T)];
if (cursor == null)
{
return(GetEntities <T>(collectionName, limit));
}
string url = string.Format("/{0}?cursor={1}&limit={2}", collectionName, cursor, limit);
if (query != null)
{
url += "&query=" + query;
}
IRestResponse response = Request.ExecuteJsonRequest(url, Method.GET);
if (response.StatusCode == HttpStatusCode.NotFound)
{
return(new UsergridCollection <T>());
}
ValidateResponse(response);
var getResponse = JsonConvert.DeserializeObject <UsergridGetResponse <T> >(response.Content);
var collection = new UsergridCollection <T>(getResponse.Entities)
{
HasNext = true,
HasPrevious = true
};
stack.Push(getResponse.Cursor);
return(collection);
}
public void GetAllUsersInGroupWillThrowWhenBadRequest()
{
UsergridError error = new UsergridError()
{
Description = "exception description", Error = "error code"
};
var restResponse = Helpers.SetUpRestResponseWithContent <UsergridError>(HttpStatusCode.BadRequest, error);
_request.ExecuteJsonRequest("/groups/groupName/users", Method.GET).Returns(restResponse);
try
{
_client.GetAllUsersInGroup <UsergridUser>("groupName");
Assert.Fail("Was expecting Usergrid exception to be thrown.");
}
catch (UsergridException e)
{
Assert.AreEqual(error.Description, e.Message);
Assert.AreEqual(error.Error, e.ErrorCode);
}
}
public void CreateConnectionShouldThrowUsergridExceptionWhenBadResponse()
{
var connection = new Connection();
var restResponseContent = new UsergridError {
Description = "Exception message", Error = "error code"
};
IRestResponse <LoginResponse> restResponseWithBadRequest = Helpers.SetUpRestResponseWithContent <LoginResponse>(HttpStatusCode.BadRequest, restResponseContent);
_request
.ExecuteJsonRequest(Arg.Any <string>(), Arg.Any <Method>(), Arg.Any <object>())
.Returns(restResponseWithBadRequest);
try
{
_connectionManager.CreateConnection(connection);
new AssertionException("UserGridException was expected to be thrown here");
}
catch (UsergridException e)
{
Assert.AreEqual("error code", e.ErrorCode);
Assert.AreEqual("Exception message", e.Message);
}
}
public void ShouldTranslateToUserGridErrorAndThrowWhenServiceReturnsBadRequest()
{
const string invalidUsernameOrPassword = "******";
const string invalidGrant = "invalid_grant";
var restResponseContent = new UsergridError {
Description = invalidUsernameOrPassword, Error = invalidGrant
};
var restResponse = Helpers.SetUpRestResponseWithContent <LoginResponse>(HttpStatusCode.BadRequest, restResponseContent);
var request = Helpers.SetUpUsergridRequestWithRestResponse(restResponse);
var authenticationManager = new AuthenticationManager(request);
try
{
authenticationManager.Login(null, null, AuthType.Organization);
throw new AssertionException("UserGridException was expected to be thrown here");
}
catch (UsergridException e)
{
Assert.AreEqual(invalidGrant, e.ErrorCode);
Assert.AreEqual(invalidUsernameOrPassword, e.Message);
}
}
public UsergridException(UsergridError error) : base(error.Description)
{
ErrorCode = error.Error;
}
