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); } }