public async Task should_return_existing_draft_copy()
{
var id = ObjectId.GenerateNewId();
var model = new LocalizationCopy
{
ObjectId = ObjectId.GenerateNewId().ToString(),
ObjectName = ObjectName
};
var cursor = StubCursor();
var form = new LocalizationModel {
Id = id
};
cursor.Setup(x => x.Current).Returns(new List <LocalizationModel> {
form
});
cursor.SetupSequence(x => x.MoveNext(It.IsAny <CancellationToken>()))
.Returns(true)
.Returns(true)
.Returns(false);
var response = await ExecuteEndpoint(_controller.Upsert(model));
_repository.Verify(x => x.SaveAsync(
LocalizationController.CollectionName,
It.IsAny <LocalizationModel>()), Times.Never);
response.Should().Be(form);
}
public async Task should_save_new_copy_of_original_form()
{
var id = ObjectId.GenerateNewId();
var model = new LocalizationCopy
{
ObjectId = ObjectId.GenerateNewId().ToString()
};
var cursor = StubCursor();
var localizationModel = new LocalizationModel {
Id = id
};
cursor.Setup(x => x.Current).Returns(new List <LocalizationModel> {
localizationModel
});
cursor.SetupSequence(x => x.MoveNext(It.IsAny <CancellationToken>()))
.Returns(false)
.Returns(true)
.Returns(false);
_repository.Setup(x => x.SaveAsync
(
LocalizationController.CollectionName, It.IsAny <LocalizationModel>()
)
)
.ReturnsAsync(localizationModel);
var _ = await _controller.Upsert(model);
_repository.Verify(x => x.SaveAsync(
LocalizationController.CollectionName,
It.IsAny <LocalizationModel>()));
}
public async Task <ApiResult <LocalizationModel> > AddNewItem([FromBody] LocalizationModel document)
{
var results = await _repository.FindAsync <LocalizationModel>(CollectionName, x => x.ObjectId == document.ObjectId && x.ObjectName == document.ObjectName);
var result = results.SingleOrDefault();
if (result != null)
{
throw new HttpForbidException
(
new ApiError
(
nameof(Forbid),
$"Item with {nameof(document.ObjectId)}{document.ObjectId} and {nameof(document.ObjectName)}{document.ObjectName} already exists in database"
)
);
}
var createdResult = await _repository.SaveAsync(CollectionName, document);
if (createdResult == null)
{
throw new HttpConflictException
(
new ApiError(
nameof(Conflict),
$"Unable to create the localization: {{{nameof(document)}}}",
additionalData: new Dictionary <string, LocalizationModel> {
{ nameof(document), document }
})
);
}
return(Created($"{HttpContext.GetRequestUrl()}?objectId={createdResult.ObjectId}&objectName={createdResult.ObjectName}", createdResult));
}
private static LocalizationModel CopyExistingLocalization(LocalizationModel localizationModel, string newObjectId)
{
var copy = BsonSerializer.Deserialize <LocalizationModel>(localizationModel.ToBsonDocument());
copy.Id = ObjectId.GenerateNewId();
copy.ObjectId = newObjectId;
return(copy);
}
public async Task should_delegate_to_find_results_with_expected_params()
{
var objectId = ObjectId.Parse(Id);
var cursor = StubCursor();
var model = new LocalizationModel();
StubSingleFoundResult(cursor, model);
var response = await ExecuteEndpoint(_controller.GetById(Id));
AssetRespositoryWasQueriedById(objectId);
response.Should().Be(model);
}
public void should_return_403_when_duplicate_item_already_exists()
{
var model = new LocalizationModel();
var cursor = new Mock <IAsyncCursor <LocalizationModel> >();
cursor.Setup(x => x.Current).Returns(new List <LocalizationModel> {
model
});
cursor.SetupSequence(x => x.MoveNext(It.IsAny <CancellationToken>())).Returns(true).Returns(false);
StubFindAsync(cursor.Object);
_controller.Awaiting(x => x.AddNewItem(model))
.Should().ThrowExactly <HttpForbidException>().And
.StatusCode.Should().Be(HttpStatusCode.Forbidden);
}
public async Task should_delegate_to_repo_to_lookup_by_id()
{
var objectId = ObjectId.Parse(Id);
var cursor = StubCursor();
var model = new LocalizationModel();
StubSingleFoundResult(cursor, model);
var patch = new JsonPatchDocument <LocalizationModel>();
_repository.Setup(x => x.UpdateAsync(LocalizationController.CollectionName, It.IsAny <Expression <Func <LocalizationModel, bool> > >(), model))
.ReturnsAsync(new ReplaceOneResult.Acknowledged(1, 1, objectId));
var response = await _controller.Patch(Id, patch);
AssetRespositoryWasQueriedById(objectId);
}
public async Task should_delegate_to_repo_to_look_for_duplicate_object()
{
var cursor = new Mock <IAsyncCursor <LocalizationModel> >();
StubFindAsync(cursor.Object);
var model = new LocalizationModel();
_repository.Setup(x => x.SaveAsync(
LocalizationController.CollectionName,
model)).ReturnsAsync(model);
await _controller.AddNewItem(model);
_repository.Verify(x => x.FindAsync(LocalizationController.CollectionName,
It.Is <Expression <Func <LocalizationModel, bool> > >(e => Lambda.Eq(e, f => f.ObjectId == model.ObjectId && f.ObjectName == model.ObjectName))));
}
public async Task should_apply_patch_then_delegate_to_repo_to_update_model_data()
{
var objectId = ObjectId.Parse(Id);
var cursor = StubCursor();
var model = new LocalizationModel();
StubSingleFoundResult(cursor, model);
var patch = new JsonPatchDocument <LocalizationModel>();
_repository.Setup(x => x.UpdateAsync(LocalizationController.CollectionName, It.IsAny <Expression <Func <LocalizationModel, bool> > >(), model))
.ReturnsAsync(new ReplaceOneResult.Acknowledged(1, 1, objectId));
var response = await _controller.Patch(Id, patch);
_repository.Verify(x => x.UpdateAsync(LocalizationController.CollectionName,
It.Is <Expression <Func <LocalizationModel, bool> > >(e => Lambda.Eq(e, f => f.Id == objectId)), model));
}
public async Task should_return_single_result_when_found()
{
const string objectId = "123";
const string objectName = "form";
var model = new LocalizationModel();
var cursor = new Mock <IAsyncCursor <LocalizationModel> >();
cursor.Setup(x => x.Current).Returns(new List <LocalizationModel> {
model
});
cursor.SetupSequence(x => x.MoveNext(It.IsAny <CancellationToken>())).Returns(true).Returns(false);
StubFindAsync(cursor.Object);
var response = await ExecuteEndpoint(_controller.Get(objectId, objectName));
response.Should().Be(model);
}
public async Task should_delegate_to_repo_to_save_model_when_it_doesnt_already_exist()
{
var cursor = new Mock <IAsyncCursor <LocalizationModel> >();
StubFindAsync(cursor.Object);
var model = new LocalizationModel();
_repository.Setup(x => x.SaveAsync(
LocalizationController.CollectionName,
model)).ReturnsAsync(model);
var response = await ExecuteEndpoint(_controller.AddNewItem(model));
_repository.Verify(x => x.SaveAsync(
LocalizationController.CollectionName,
model));
response.Should().Be(model);
}
private static void StubSingleFoundResult(Mock <IAsyncCursor <LocalizationModel> > cursor, LocalizationModel model)
{
cursor.Setup(x => x.Current).Returns(new List <LocalizationModel> {
model
});
cursor.SetupSequence(x => x.MoveNext(It.IsAny <CancellationToken>()))
.Returns(true)
.Returns(false);
}
