public async Task Post_PersonWithFullName_ReturnsCreatedAtResult()
{
//Arrange
Person expected = PersonGenerator.Generate();
Mock <IPersonRepository> repository = new Mock <IPersonRepository>();
PersonController controller = new PersonController(repository.Object);
//Act
IActionResult result = await controller.Post(expected);
//Assert
CreatedAtActionResult createdAtActionResult = Assert.IsType <CreatedAtActionResult>(result);
Assert.Null(createdAtActionResult.ControllerName);
Assert.Equal(nameof(PersonController.Get), createdAtActionResult.ActionName);
}
public void TestPostOne()
{
//Arrange
Session s = new Session()
{
ID = 1,
Key = "0PYP4EZLC2Y6YGRSP01S7TOKVQUVMW4D",
UserID = 27
};
SessionsController controller = new SessionsController();
//Act
IActionResult response = controller.Post(s);
CreatedAtActionResult result = response as CreatedAtActionResult;
//Assert
Assert.AreEqual(result.StatusCode, 201);
}
// The service should replace Json objects with specified IDs when using the more complex ObjectId format
public async Task Replace_with_ObjectId_Full_Response(string json, string expectedName)
{
// Arrange
var controller = new ObjectController(_fixture.MongoRepository);
// Act - insert first
var insertResult = await controller.InsertObjectWithId(new ItemRouteParameters()
{
DatabaseName = DATABASE_NAME,
CollectionName = "customers9",
}, json, ResponseFormat.EntireObject);
var expectedInsert = typeof(CreatedAtActionResult);
CreatedAtActionResult createdResult = ((CreatedAtActionResult)insertResult);
// Assert
Assert.Equal(201, createdResult.StatusCode);
JObject jsonObject1 = JObject.Parse(createdResult.Value.ToString());
var id = jsonObject1.SelectTokens(@"_id.$oid").FirstOrDefault().Value <string>();
// Act - do the replacement
var replaceResult = await controller.ReplaceObject(new ItemRouteParameters()
{
DatabaseName = DATABASE_NAME,
CollectionName = "customers9",
Id = id
}, json, ResponseFormat.EntireObject);
var expectedReplace = typeof(OkObjectResult);
OkObjectResult okResult = ((OkObjectResult)replaceResult);
JObject jsonObject2 = JObject.Parse(okResult.Value.ToString());
var insertedId = jsonObject2.SelectTokens(@"_id.$oid").FirstOrDefault().Value <string>();
var insertedName = jsonObject2["name"].ToString();
// Assert
Assert.IsType(expectedReplace, okResult);
Assert.Equal(id, insertedId);
Assert.Equal(expectedName, insertedName);
Assert.Equal(200, okResult.StatusCode);
}
[ProducesResponseType(typeof(string), 502)] // upstream resource isn't available...ref https://tools.ietf.org/html/rfc2616?spm=5176.doc32013.2.3.Aimyd7#section-10.5.3
public IActionResult Post([FromBody] UserModel value)
{
if (value == null)
{
return(BadRequest());
}
var(ok, error, newModel) = Logic.Insert(value);
if (!ok)
{
return(new UnprocessableEntityObjectResult(error));
}
var result = new CreatedAtActionResult(nameof(this.GetById), "example", new { id = newModel.ID }, newModel);
return(result);
}
public async Task ShouldReturnCreatedAtResult()
{
CreateUserCommand command = CreateCommand();
UsersController controller = CreateController();
Guid userId = Guid.NewGuid();
mediatorMock
.Setup(mediator => mediator.Send(command, CancellationToken.None))
.ReturnsAsync(userId);
IActionResult result = await controller.Post(command);
CreatedAtActionResult actionResult = result as CreatedAtActionResult;
Assert.IsNotNull(actionResult);
Assert.AreEqual(201, actionResult.StatusCode);
Assert.AreEqual(userId, actionResult.Value);
}
public void SetUp()
{
_customer = new Customer
{
FirstName = "New",
LastName = "Customer",
Email = "*****@*****.**",
Password = "******"
};
_customerRepository = new Mock <ICustomersRepository>();
_customerRepository.Setup(mock => mock.Create(It.IsAny <Customer>())).Callback(() => _customer.Id = 1);
var subject = new CustomersController(_customerRepository.Object);
_result = subject.Create(_customer) as CreatedAtActionResult;
_resultCustomer = _result.Value as Customer;
}
public void AddCarSale()
{
// Arrange:
var okCarSale = _data.okAddCarSale;
CarSaleViewModel invalidCarSale = _data.invalidAddCarSale;
// Act:
var okResponse = _carSaleController.AddCarSale(okCarSale);
CreatedAtActionResult okResult = okResponse as CreatedAtActionResult;
//CarSaleViewModel okValue = okResult.Value as CarSaleViewModel;
var badResponse = _carSaleController.AddCarSale(invalidCarSale);
BadRequestObjectResult badResult = badResponse as BadRequestObjectResult;
// Assert:
Assert.IsInstanceOfType(okResponse, typeof(CreatedAtActionResult));
Assert.IsInstanceOfType(badResponse, typeof(BadRequestObjectResult));
}
public async Task CreateGroup_ShouldReturnCreatedResult_WhenGroupIsCreated()
{
// Arrange
CreateGroupBody model = new CreateGroupBody
{
Name = "Some group name",
Description = "Some group description"
};
GroupResource expectedGroup = new GroupResource
{
GroupId = 1,
Name = model.Name,
Description = model.Description
};
Mock <IMediator> mediatorMock = new Mock <IMediator>();
mediatorMock
.Setup(m => m.Send(It.IsAny <CreateGroupCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(expectedGroup);
MapperConfiguration mapperConfiguration = new MapperConfiguration(config =>
{
config.CreateMap <CreateGroupBody, CreateGroupCommand>();
});
IMapper mapperMock = mapperConfiguration.CreateMapper();
GroupController controller = new GroupController(mediatorMock.Object, mapperMock);
// Act
ActionResult <GroupResource> response = await controller.CreateGroup(model);
// Assert
CreatedAtActionResult result = Assert.IsType <CreatedAtActionResult>(response.Result);
GroupResource actualGroup = Assert.IsType <GroupResource>(result.Value);
Assert.NotNull(actualGroup);
Assert.Equal(1, actualGroup.GroupId);
mediatorMock.Verify(m => m.Send(It.IsAny <CreateGroupCommand>(), It.IsAny <CancellationToken>()));
}
public async Task TestNewOrder()
{
var o = context.Orders.Find(99);
OrderVM order = new OrderVM
{
cityId = o.CityId,
customerId = o.CustomerId,
operationId = o.OperationId,
notes = "New Order",
street = o.Street
};
var result = await ordersController.NewOrder(order);
CreatedAtActionResult ok = (CreatedAtActionResult)result.Result;
order = ok.Value as OrderVM;
Assert.IsInstanceOf <OrderVM>(order);
Assert.IsTrue(order.status == Status.Received);
}
public async Task Delete_Object_by_ObjectId(string json)
{
// Arrange
var controller = new ObjectController(_fixture.MongoRepository);
var collectionName = "audit2";
// Act
var insertResult = await controller.InsertObjectWithNoId(new ItemRouteParameters()
{
DatabaseName = DATABASE_NAME, CollectionName = collectionName
}, json, ResponseFormat.OnlyId);
CreatedAtActionResult createdResult = ((CreatedAtActionResult)insertResult);
JObject jsonObject2 = JObject.Parse(createdResult.Value.ToString());
var insertedId = JArray.Parse(jsonObject2["ids"].ToString())[0].ToString();
var firstGetResult = await controller.GetObject(new ItemRouteParameters()
{
DatabaseName = DATABASE_NAME, CollectionName = collectionName, Id = insertedId
});
OkObjectResult okGetResult = ((OkObjectResult)firstGetResult);
Assert.Equal(200, okGetResult.StatusCode);
var deleteResult = await controller.DeleteObject(new ItemRouteParameters()
{
DatabaseName = DATABASE_NAME, CollectionName = collectionName, Id = insertedId
});
OkResult okDeleteResult = ((OkResult)deleteResult);
Assert.Equal(200, okDeleteResult.StatusCode);
var secondGetResult = await controller.GetObject(new ItemRouteParameters()
{
DatabaseName = DATABASE_NAME, CollectionName = collectionName, Id = insertedId
});
ObjectResult notFoundGetResult = ((ObjectResult)secondGetResult);
Assert.Equal(404, notFoundGetResult.StatusCode);
}
public void PostMethodSetsLocationHeader()
{
var mock = new Mock <IBookRepository>();
var controller = new BookController(mock.Object);
var item = new Book()
{
Id = 3,
Title = "Hands-On TypeScript for C# and .NET Developers",
Author = "Francesco Abbruzzese"
};
CreatedAtActionResult response = (CreatedAtActionResult)controller.Post(item);
Book book = (Book)response.Value;
Assert.IsNotNull(response);
Assert.AreEqual("GetById", response.ActionName);
Assert.AreEqual(201, response.StatusCode);
Assert.AreEqual(item.Title, book.Title);
}
public async Task Add_Returns_CompanyDtoInCreatedAtRoute()
{
CompanyForAddDto companyForAddDto = new CompanyForAddDto();
CompanyDto companyDto = new CompanyDto {
CompanyId = 5
};
Company company = new Company {
CompanyId = 5
};
_companiesController = new CompaniesController(_companyServiceMock.Object, _mapperMock.Object);
_mapperMock.Setup(x => x.Map <Company>(companyForAddDto)).Returns(company);
_mapperMock.Setup(x => x.Map <CompanyDto>(company)).Returns(companyDto);
ActionResult <CompanyDto> result = await _companiesController.Add(companyForAddDto);
CreatedAtActionResult actionResult = result.Result as CreatedAtActionResult;
Assert.Equal(companyDto, actionResult.Value);
}
public async Task CreatedAtActionResult_ThrowsOnNullUrl()
{
// Arrange
var httpContext = GetHttpContext();
var actionContext = GetActionContext(httpContext);
var urlHelper = GetMockUrlHelper(returnValue: null);
var result = new CreatedAtActionResult(
actionName: null,
controllerName: null,
routeValues: null,
value: null);
result.UrlHelper = urlHelper;
// Act & Assert
await ExceptionAssert.ThrowsAsync <InvalidOperationException>(
async() => await result.ExecuteResultAsync(actionContext),
"No route matches the supplied values.");
}
public void TestPostOne()
{
//Arrange
DateTime date = DateTime.Now;
Test t = new Test()
{
Temperature = 35.029838,
TimeOfDataRecording = date,
ID = 1,
HasFever = false,
RaspberryPiID = 1,
};
TestsController controller = new TestsController();
//Act
CreatedAtActionResult response = (CreatedAtActionResult)controller.Post(t);
//Assert
Assert.AreEqual(response.StatusCode, 201);
}
public void PostUserSuccess()
{
UsersController _usersController = new UsersController(_context);
Users _user = new Users
{
UserId = 1,
UserName = "******",
Email = "test_email",
Alias = "test_alias",
FirstName = "test_firstname",
LastName = "test_lastname"
};
var res = _usersController.PostUsers(_user);
Assert.IsType <CreatedAtActionResult>(res.Result);
CreatedAtActionResult caRes = (CreatedAtActionResult)res.Result;
Assert.Equal(_user, caRes.Value);
}
public void TestPostOne()
{
//Arrange
Profile p = new Profile()
{
Address = "testAd",
City = "testCi",
CompanyName = "testCN",
Country = "testCo",
ID = 0,
JoinDate = DateTime.Now,
Phone = "1234"
};
ProfilesController controller = new ProfilesController();
//Act
CreatedAtActionResult response = (CreatedAtActionResult)controller.Post(p);
//Assert
Assert.AreEqual(response.StatusCode, 201);
}
public async Task CreateOrganisationAsync_ServiceReturnsSuccess_Returns_CreatedAtAction()
{
var organisationId = Guid.NewGuid();
var controller = OrganisationControllerBuilder.Create().WithCreateOrganisationServiceReturningSuccess(organisationId).Build();
var response = await controller.CreateOrganisationAsync(new CreateOrganisationRequestModel());
response.Should().BeOfType <ActionResult <CreateOrganisationResponseModel> >();
var expected = new CreatedAtActionResult(
nameof(controller.GetByIdAsync).TrimAsync(),
null,
new { id = organisationId },
new CreateOrganisationResponseModel {
OrganisationId = organisationId
});
var actual = response.Result;
actual.Should().BeEquivalentTo(expected);
}
public async Task PostTeacherTest()
{
//Arrange
TeachersController teachersController = new TeachersController(_inMemoryDBContext);
ActionResult <IEnumerable <Teacher> > _teacherList = await teachersController.GetTeachers();
int startingCount = _teacherList.Value.Count <Teacher>();
Teacher teacher = new Teacher();
teacher.TeacherName = "Señora Maestra";
//Act
ActionResult <Teacher> newTeacher = await teachersController.PostTeacher(teacher);
//Assert
CreatedAtActionResult postResult = (CreatedAtActionResult)newTeacher.Result;
Teacher createdTeacher = (Teacher)postResult.Value;
Assert.IsTrue(createdTeacher.TeacherKey > startingCount);
}
public void RevokeCarSale()
{
// Arrange:
int validId = 2;
int invalidId = 0;
int noCarSaleId = 5;
// Act:
var badReqId = _carSaleController.RevokeCarSaleFunction(invalidId);
BadRequestObjectResult badResult = badReqId as BadRequestObjectResult;
var noCarSale = _carSaleController.RevokeCarSaleFunction(noCarSaleId);
NotFoundObjectResult notFoundResult = noCarSale as NotFoundObjectResult;
var validCarSale = _carSaleController.RevokeCarSaleFunction(validId);
CreatedAtActionResult createdResult = validCarSale as CreatedAtActionResult;
// Assert:
Assert.IsInstanceOfType(badReqId, typeof(BadRequestObjectResult));
Assert.IsInstanceOfType(noCarSale, typeof(NotFoundObjectResult));
Assert.IsInstanceOfType(validCarSale, typeof(CreatedAtActionResult));
}
public async void TestPostRequest()
{
// Arrange
Note testNote = await mockDbHelper.GetTestResultData();
Mock <INotesService> mockRepo = new Mock <INotesService>();
mockRepo.Setup(repo => repo.PostNotes(testNote)).Returns(mockDbHelper.GetTestResultData());
NotesController controller = new NotesController(mockRepo.Object);
// Act
var result = await controller.PostNotes(testNote);
CreatedAtActionResult objectResult = result as CreatedAtActionResult;
//Note objectResultValue = objectResult.Value as Note;
// Assert
//Assert.True(Assert.Equal(title,result.Result))
Assert.Equal(201, objectResult.StatusCode);
//Assert.True(objectResultValue.TrueForAll(x => x.Title == title));
//Assert.Equal("Note 1", result.Result.Should().BeEquivalentTo())
}
public async Task CreatedAtActionResult_ReturnsStatusCode_SetsLocationHeader()
{
// Arrange
var expectedUrl = "testAction";
var httpContext = GetHttpContext();
var actionContext = GetActionContext(httpContext);
var urlHelper = GetMockUrlHelper(expectedUrl);
// Act
var result = new CreatedAtActionResult(
actionName: expectedUrl,
controllerName: null,
routeValues: null,
value: null);
result.UrlHelper = urlHelper;
await result.ExecuteResultAsync(actionContext);
// Assert
Assert.Equal(StatusCodes.Status201Created, httpContext.Response.StatusCode);
Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]);
}
public void AddCarFunction()
{
// Arrange:
var okCar = _data.okCar;
CarViewModel invalidCar = null;
// Act:
var okResponse = _carController.AddCarFunction(okCar);
CreatedAtActionResult okResult = okResponse as CreatedAtActionResult;
var badResponse = _carController.AddCarFunction(invalidCar);
BadRequestResult badResult = badResponse as BadRequestResult;
var invalidModelStateResponse = _carController.AddCarFunction(invalidCar);
StatusCodeResult badStatus = invalidModelStateResponse as StatusCodeResult;
// Assert:
Assert.IsInstanceOfType(okResponse, typeof(CreatedAtActionResult));
Assert.IsInstanceOfType(badResponse, typeof(BadRequestResult));
Assert.IsInstanceOfType(badResponse, typeof(StatusCodeResult));
}
#pragma warning disable 1998
public async Task <ActionResult <ExternalAssociate> > Create([FromBody] CreateExternalAssociateDto item)
#pragma warning restore 1998
{
Result <DUNSNumber> dunsNumberOrError = DUNSNumber.Create(item.DUNSNumber);
Result <LongName> longNameOrError = LongName.Create(item.LongName);
Result <ShortName> shortNameOrError = ShortName.Create(item.ShortName);
Result result = Result.Combine(dunsNumberOrError, longNameOrError, shortNameOrError);
if (result.IsFailure)
{
return(Error(result.Error));
}
ExternalAssociate externalAssociate = new ExternalAssociate(dunsNumberOrError.Value, longNameOrError.Value, shortNameOrError.Value, ExternalAssociateType.SELF_PROVIDER);
_repository.AddExternalAssociate(externalAssociate);
CreatedAtActionResult createdAtActionResult = CreatedAtAction("Create", new { id = externalAssociate.Id }, externalAssociate);
return(createdAtActionResult);
}
private async System.Threading.Tasks.Task SendTaskCreatedEventToAMQP(CreatedAtActionResult createdAtAction, string jsonMessage)
{
if (createdAtAction.StatusCode == 200 ||
createdAtAction.StatusCode == 201 ||
createdAtAction.StatusCode == 204 ||
createdAtAction.StatusCode == 205)
{
var amqpSettings = _configuration.GetSection("AMQPSettings");
var addressConfiguration = amqpSettings.GetSection("Address").Value;
var messageForTaskCreatedEventConfiguration = amqpSettings.GetSection("MessageForTaskCreatedEvent").Value;
var senderLinkNameConfiguration = amqpSettings.GetSection("SenderLinkName").Value;
var senderLinkAddressConfiguration = amqpSettings.GetSection("SenderLinkAddress").Value;
Address address = new Address(addressConfiguration);
Connection connection = await Connection.Factory.CreateAsync(address);
Session session = new Session(connection);
Message message = new Message(jsonMessage);
var sender = new SenderLink(session, senderLinkNameConfiguration, senderLinkAddressConfiguration);
await sender.SendAsync(message);
}
}
public async void CanGetListWithItems()
{
DbContextOptions <ToDoNgDbContext> options = new DbContextOptionsBuilder <ToDoNgDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
using (ToDoNgDbContext context = new ToDoNgDbContext(options))
{
// Arrange
ToDoController itemController = new ToDoController(context);
ToDoListController listController = new ToDoListController(context);
CreatedAtActionResult listResult = await listController.Post(new ToDoList()
{
Name = "Foo"
}) as CreatedAtActionResult;
int listId = (listResult.Value as ToDoList).Id;
CreatedAtActionResult itemResult = await itemController.Post(new ToDo()
{
Message = "Hello, world!",
IsDone = false,
ListId = listId
}) as CreatedAtActionResult;
int itemId = (itemResult.Value as ToDo).Id;
// Act
OkObjectResult getResult = await listController.GetToDoList(listId) as OkObjectResult;
PropertyInfo itemsPropertyInfo = getResult.Value.GetType().GetProperty("items");
IEnumerable <ToDo> associatedItems = itemsPropertyInfo.GetValue(getResult.Value) as IEnumerable <ToDo>;
// Assert
Assert.Contains(associatedItems, i => i.Id == itemId);
}
}
public async Task bPostTruck1()
{
ActionResult <Vehicle> actionresult = await _controller.PostVehicle(testTrucks[1]);
if (actionresult.Result is BadRequestObjectResult)
{
BadRequestObjectResult result = actionresult.Result as BadRequestObjectResult;
Assert.Fail(result.Value.ToString());
}
else
{
CreatedAtActionResult result = actionresult.Result as CreatedAtActionResult;
Vehicle truck = result.Value as Vehicle;
if (truck.Name == testTrucks[1].Name && truck.Make == testTrucks[1].Make)
{
Assert.Pass();
}
else
{
Assert.Fail();
}
}
}
public async Task Check_PostBusinessGame_GetID()
{
// Arrange
var controller = new GameController(_dbContext);
UserTempStorage.id = 1;
BusinessGames businessGamingInfo = new BusinessGames();
businessGamingInfo.GameId = 2;
// Act
IActionResult addBusinessGame = await controller.PostBusinessGame(businessGamingInfo);
CreatedAtActionResult results = addBusinessGame as CreatedAtActionResult;
string var = results.RouteValues["id"].ToString();
//string var = results.RouteValues["id"].ToString();
// Assert
Assert.AreEqual(var, "2");
}
public void PostProductOptionTest()
{
Guid productId = Guid.NewGuid();
ProductOptionDto productOption = new ProductOptionDto {
Name = "OptionA", Description = "desc", ProductId = productId
};
ProductOption model = new ProductOption {
Id = Guid.NewGuid(), Name = "OptionA", Description = "desc", ProductId = productId
};
var productsService = new Mock <IProductsService>();
productsService
.Setup(repo => repo.CreateProductOption(productId, new ProductOptionDoDtoConverter().ToDO(productOption)))
.Returns(model);
ProductsController productsController = new ProductsController(productsService.Object, Mock.Of <ILogger <ProductsController> >());
ActionResult result = productsController.PostProductOption(productId, productOption);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(CreatedAtActionResult));
CreatedAtActionResult createdAtActionResult = (CreatedAtActionResult)result;
Assert.IsInstanceOfType(createdAtActionResult.Value, typeof(ProductOptionDto));
ProductOptionDto expectedProduct = new ProductOptionDoDtoConverter().FromDO(model);
Assert.AreEqual(expectedProduct, (ProductOptionDto)createdAtActionResult.Value);
object productIdActual;
bool contains = createdAtActionResult.RouteValues.TryGetValue("productId", out productIdActual);
Assert.AreEqual(true, contains);
Assert.AreEqual(productId, productIdActual);
object productOptionId;
contains = createdAtActionResult.RouteValues.TryGetValue("productOptionId", out productOptionId);
Assert.AreEqual(true, contains);
Assert.AreEqual(model.Id, productOptionId);
}
public async Task SaveFundingSchema_WhenSavingIsSuccessful_ReturnsCreatedAtResult()
{
//arrange
string json = CreateSchemaFile("CalculateFunding.Services.Policy.Resources.LogicalModel.json");
IFundingSchemaRepository fundingSchemaRepository = CreateFundingSchemaRepository();
ILogger logger = CreateLogger();
FundingSchemaService fundingSchemaService = CreateFundingSchemaService(logger, fundingSchemaRepository: fundingSchemaRepository);
//Act
IActionResult result = await fundingSchemaService.SaveFundingSchema(
createdAtActionName, createdAtControllerName, json);
//Assert
result
.Should()
.BeAssignableTo <CreatedAtActionResult>();
CreatedAtActionResult actionResult = result as CreatedAtActionResult;
actionResult
.ActionName
.Should()
.Be("GetFundingSchemaByVersion");
actionResult
.ControllerName
.Should()
.Be("SchemaController");
actionResult
.RouteValues["schemaVersion"].ToString()
.Should()
.Be("1.0");
}
public async void CanGetItemWithList()
{
DbContextOptions <ToDoNgDbContext> options = new DbContextOptionsBuilder <ToDoNgDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
using (ToDoNgDbContext context = new ToDoNgDbContext(options))
{
// Arrange
ToDoController itemController = new ToDoController(context);
ToDoListController listController = new ToDoListController(context);
CreatedAtActionResult listResult = await listController.Post(new ToDoList()
{
Name = "Foo"
}) as CreatedAtActionResult;
int listId = (listResult.Value as ToDoList).Id;
CreatedAtActionResult itemResult = await itemController.Post(new ToDo()
{
Message = "Hello, world!",
IsDone = false,
ListId = listId
}) as CreatedAtActionResult;
int itemId = (itemResult.Value as ToDo).Id;
// Act
OkObjectResult getResult = await itemController.GetToDo(itemId) as OkObjectResult;
ToDoList associatedList = (getResult.Value as ToDo).List;
// Assert
Assert.Equal(listId, associatedList.Id);
}
}
