public void AddSubject_ValidObject_ReturnsCreatedSubject()
{
// arrange
FakeSubjectOrderRepository fake = new FakeSubjectOrderRepository();
SubjectsController sc = new SubjectsController(fake);
SubjectForCreationDto subject = new SubjectForCreationDto
{
FirstName = "Zita",
LastName = "Garsden Kabok",
DateOfBirth = new DateTime(1980, 05, 03),
TitleId = 2
};
// act
CreatedAtRouteResult result = sc.CreateSubject(subject) as CreatedAtRouteResult;
// assert
Assert.IsInstanceOf <SubjectDto>(result.Value);
Assert.AreEqual("GetSubject", result.RouteName);
SubjectDto subjectReturned = result.Value as SubjectDto;
Assert.AreEqual(6, subjectReturned.subjectId);
Assert.AreEqual("Zita", subjectReturned.firstName);
Assert.AreEqual("Garsden Kabok", subjectReturned.lastName);
Assert.AreEqual("03/05/1980", subject.DateOfBirth.ToString("d"));
Assert.AreEqual(2, subjectReturned.titleId);
}
public async Task Post_ValidModel_ReturnsCreatedAtRouteResult()
{
string roleName = "admin";
string roleDescription = "admin role desc";
RolePostRequest model = new RolePostRequest {
Name = roleName, Description = roleDescription
};
this.roleManagerMock.Setup(r => r.CreateAsync(It.IsAny <ApplicationRole>())).ReturnsAsync(IdentityResult.Success);
var controller = new RoleController(this.roleManagerMock.Object, this.userManagerMock.Object, this.localizationMock.Object, this.mapperMock.Object);
controller.BindViewModel(model);
var response = await controller.Post(model).ConfigureAwait(false);
Assert.IsAssignableFrom <CreatedAtRouteResult>(response);
CreatedAtRouteResult result = response as CreatedAtRouteResult;
Assert.Equal("RoleGet", result.RouteName);
Assert.True(result.RouteValues.Keys.Contains("roleName"));
Assert.True(result.RouteValues.Values.Contains("admin"));
Assert.Equal(result.Value, model);
}
public IActionResult Create(ContentUploadVM ContentUploadVM, IFormFile file)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (file != null)
{
using (Stream stream = file.OpenReadStream())
{
using (BinaryReader br = new BinaryReader(stream))
{
var fileContent = br.ReadBytes((int)file.Length);
ContentUploadVM.Image = SaveFileHelper.SaveFileToDisk(_env, fileContent, file.FileName, file.ContentType);
}
}
}
Content _newContent = Mapper.Map <Content>(ContentUploadVM);
_contentRepository.Add(_newContent);
_contentRepository.SaveChanges();
CreatedAtRouteResult result = CreatedAtRoute("GetContent", new { controller = "Content", id = ContentUploadVM.Id }, ContentUploadVM);
return(result);
}
public void WithRouteName_GivenExpectedRouteName_ShouldPass()
{
var expectedRouteName = "expectedRoute";
var result = new CreatedAtRouteResult(expectedRouteName, null, null);
result.Should().BeCreatedAtRouteResult().WithRouteName(expectedRouteName);
}
public void Post_Successful_IgnoresInputId(string id)
{
PersonEntry entry = new PersonEntry
{
Id = id,
FirstName = "first",
LastName = "last"
};
var result = _controller.Post(entry);
Assert.IsType <CreatedAtRouteResult>(result);
CreatedAtRouteResult car = (CreatedAtRouteResult)result;
Assert.Equal(201, car.StatusCode);
Assert.Equal("GetPersonById", car.RouteName);
Assert.IsAssignableFrom <PersonEntry>(car.Value);
PersonEntry created = (PersonEntry)car.Value;
Assert.Equal("first", created.FirstName);
Assert.Equal("last", created.LastName);
// The Id is coming back null, but in a real post it shows up
// I expect it has to do with the DB context mock not being setup correctly
// Assert.False(string.IsNullOrWhiteSpace(created.Id));
// Assert.NotEqual(id, created.Id);
VerifyAddPerson();
VerifySaveDbOnce();
}
public IActionResult CreateJob(int id, [FromBody] JobViewModel job)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Customer _customerDb = _customerRepository.GetSingle(id);
Job _newJob;
if (_customerDb == null)
{
return(NotFound());
}
else
{
_newJob = new Job
{
JobType = (JobType)Enum.Parse(typeof(JobType), job.JobType),
Date = DateTime.Now.Date,
Status = JobStatusType.Active,
CustomerId = id
};
}
_jobRepository.Add(_newJob);
_jobRepository.Commit();
job = Mapper.Map <Job, JobViewModel>(_newJob);
//check logic - return jobs created from customer To-Do
CreatedAtRouteResult result = CreatedAtRoute("GetCustomerJobs", new { controller = "Customers", id }, job);
return(result);
}
public IActionResult CreateAddress(int id, [FromBody] AddressViewModel address, [FromBody] CustomerViewModel customer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Customer _customerDb = _customerRepository.GetSingle(id);
Address _newAddress;
if (_customerDb == null)
{
return(NotFound());
}
else
{
_newAddress = new Address
{
Address1 = address.Address1,
Address2 = address.Address2,
City = address.City,
ZipCode = address.ZipCode,
State = address.State,
CustomerId = id
};
}
_addressRepository.Add(_newAddress);
_addressRepository.Commit();
address = Mapper.Map <Address, AddressViewModel>(_newAddress);
CreatedAtRouteResult result = CreatedAtRoute("GetAddress", new { controller = "Address", id = address.Id }, address);
return(result);
}
public IActionResult CreatePhoneNumber(int id, [FromBody] PhoneNumberViewModel phoneNumber)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Customer _customerDb = _customerRepository.GetSingle(id);
PhoneNumber _newPhoneNumber;
if (_customerDb == null)
{
return(NotFound());
}
else
{
_newPhoneNumber = new PhoneNumber
{
Number = phoneNumber.Number,
CustomerId = id
};
}
_phoneNumberRepository.Add(_newPhoneNumber);
_phoneNumberRepository.Commit();
phoneNumber = Mapper.Map <PhoneNumber, PhoneNumberViewModel>(_newPhoneNumber);
CreatedAtRouteResult result = CreatedAtRoute("GetCustomerPhoneNumbers", new { controller = "Customers", id }, phoneNumber);
return(result);
}
public IActionResult Create(SliderUploadVM SliderUploadVM, IFormFile file)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (file == null || file.Length == 0)
{
return(BadRequest("Your file was not valid!"));
}
using (Stream stream = file.OpenReadStream())
{
using (BinaryReader br = new BinaryReader(stream))
{
var fileContent = br.ReadBytes((int)file.Length);
SliderUploadVM.Image = SaveFileHelper.SaveFileToDisk(_env, fileContent, file.FileName, file.ContentType);
}
}
Slider _newSlider = Mapper.Map <Slider>(SliderUploadVM);
_sliderRepository.Add(_newSlider);
_sliderRepository.SaveChanges();
CreatedAtRouteResult result = CreatedAtRoute("GetCategory", new { controller = "Categories", id = SliderUploadVM.Id }, SliderUploadVM);
return(result);
}
public async Task Post_ResturnsOrder_WhenOrderCreated()
{
//Arrage
/*Mock<Order> order = new Mock<Order>();
* order.SetupAllProperties();*/
var user = new Faker <User>()
.RuleFor(x => x.Id, x => x.IndexFaker)
.Generate();
var products = new Faker <Product>()
.RuleFor(x => x.Id, x => x.IndexFaker)
.Generate(10);
var order = new Faker <Order>("pl")
.RuleFor(x => x.Id, x => x.IndexFaker)
.RuleFor(x => x.User, x => user)
.RuleFor(x => x.Products, x => x.PickRandom(products, 5))
.Generate();
Mock <ICrudService <Order> > service = new Mock <ICrudService <Order> >();
service.Setup(x => x.CreateAsync(It.IsAny <Order>())).ReturnsAsync(order);
OrdersController controller = new OrdersController(service.Object, null);
//Act
IActionResult result = await controller.Post(null);
//Assert
CreatedAtRouteResult createdAtRouteResult = Assert.IsType <CreatedAtRouteResult>(result);
Assert.Equal(order, createdAtRouteResult.Value);
Assert.Equal("GetOrderRoute", createdAtRouteResult.RouteName);
}
public IActionResult Post([FromBody] ValueViewModel model)
{
ValueGenerator.Insert(model);
CreatedAtRouteResult result = CreatedAtRoute("GetValue", new { controller = "Value", id = model.Id }, model);
return(result);
}
public IActionResult Create([FromBody] ScheduleViewModel schedule)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Schedule _newSchedule = Mapper.Map <ScheduleViewModel, Schedule>(schedule);
_newSchedule.DateCreated = DateTime.Now;
_scheduleRepository.Add(_newSchedule);
_scheduleRepository.Commit();
foreach (var userId in schedule.Attendees)
{
_newSchedule.Attendees.Add(new Attendee {
UserId = userId
});
}
_scheduleRepository.Commit();
schedule = Mapper.Map <Schedule, ScheduleViewModel>(_newSchedule);
CreatedAtRouteResult result = CreatedAtRoute("GetSchedule", new { controller = "Schedules", id = schedule.Id }, schedule);
return(result);
}
public void PutAdd()
{
//Arrange.
Exception internalEx = new EncounterNotFoundException();
Exception toThrow = new ServiceException(internalEx.Message, ErrorType.ENTITY_NOT_FOUND);
matchService.Setup(ms => ms.ModifyEncounter(It.IsAny <int>(), It.IsAny <ICollection <int> >(),
It.IsAny <DateTime>(), It.IsAny <string>())).Throws(toThrow);
matchService.Setup(ms => ms.AddEncounter(It.IsAny <int>(), It.IsAny <ICollection <int> >(),
It.IsAny <string>(), It.IsAny <DateTime>())).Returns(testEncounter);
MatchModelIn input = BuildMatchModelIn(testEncounter);
//Act.
IActionResult result = controller.Put(1, input);
CreatedAtRouteResult createdResult = result as CreatedAtRouteResult;
EncounterModelOut modified = createdResult.Value as EncounterModelOut;
//Assert.
matchService.Verify(ms => ms.ModifyEncounter(It.IsAny <int>(), It.IsAny <ICollection <int> >(),
It.IsAny <DateTime>(), It.IsAny <string>()), Times.Once);
matchService.Verify(ms => ms.AddEncounter(It.IsAny <int>(), It.IsAny <ICollection <int> >(),
It.IsAny <string>(), It.IsAny <DateTime>()), Times.Once);
Assert.IsNotNull(result);
Assert.IsNotNull(createdResult);
Assert.AreEqual(201, createdResult.StatusCode);
Assert.AreEqual("GetMatchById", createdResult.RouteName);
Assert.IsNotNull(modified);
Assert.AreEqual(modified.Id, testEncounter.id);
}
public void CommentOnMatchTest()
{
//Arrange.
User commentarist = GetFakeUser();
CommentaryDto made = new CommentaryDto()
{
makerUsername = commentarist.UserName, text = "this is a comment"
};
CommentModelIn input = new CommentModelIn()
{
Text = "this is a comment"
};
matchService.Setup(ms => ms.CommentOnEncounter(3, "username", input.Text)).Returns(made);
//Act.
IActionResult result = controller.CommentOnMatch(3, input);
CreatedAtRouteResult createdResult = result as CreatedAtRouteResult;
CommentModelOut comment = createdResult.Value as CommentModelOut;
//Assert.
matchService.Verify(ms => ms.CommentOnEncounter(3, "username", input.Text), Times.Once);
Assert.IsNotNull(result);
Assert.IsNotNull(createdResult);
Assert.AreEqual(201, createdResult.StatusCode);
Assert.AreEqual("GetCommentById", createdResult.RouteName);
Assert.IsNotNull(comment);
Assert.AreEqual(comment.Text, input.Text);
Assert.AreEqual("username", comment.MakerUsername);
}
public IActionResult CreateWorkDescription(int id, [FromBody] WorkDescriptionViewModel workDescription)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Job _jobDb = _jobRepository.GetSingle(id);
WorkDescription _newWorkDescription;
if (_jobDb == null)
{
return(NotFound());
}
else
{
_newWorkDescription = new WorkDescription
{
WorkType = (WorkType)Enum.Parse(typeof(WorkType), workDescription.WorkType),
Revenue = workDescription.Revenue,
JobId = id
};
}
_workDescriptionRepository.Add(_newWorkDescription);
_workDescriptionRepository.Commit();
workDescription = Mapper.Map <WorkDescription, WorkDescriptionViewModel>(_newWorkDescription);
CreatedAtRouteResult result = CreatedAtRoute("GetJobWorkDescription", new { controller = "Jobs", id });
return(result);
}
public async Task <IActionResult> CreateCategory([FromBody] CategoryViewModel category)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Category _newCategory = Mapper.Map <CategoryViewModel, Category>(category);
_newCategory.CreatedDate = DateTime.Now;
await _categoryRepository.AddAsync(_newCategory);
// foreach (var userId in product.)
// {
// _newSchedule.Attendees.Add(new Attendee { UserId = userId });
// }
// _scheduleRepository.Commit();
category = Mapper.Map <Category, CategoryViewModel>(_newCategory);
CreatedAtRouteResult result = CreatedAtRoute("GetCategory", new { controller = "Category", id = category.ID }, category);
return(result);
}
public void Subscribe_ReturnsStatus201_WhenSusbcriptionWorks()
{
//Arrange
SubscribeCommand command = fixture.Create <SubscribeCommand>();
//Act
Task <ActionResult> task = controller.Subscribe(command);
task.Wait();
ActionResult response = task.Result;
//Assert
mediator.Received(1).Send(Arg.Is(command));
response.Should().NotBeNull();
response.Should().BeOfType <CreatedAtRouteResult>();
CreatedAtRouteResult result = response as CreatedAtRouteResult;
result.StatusCode.Should().Be(StatusCodes.Status201Created);
result.Value.Should().NotBeNull();
result.Value.Should().BeOfType <GetUserByUserNameRequest>();
GetUserByUserNameRequest resultValue = result.Value as GetUserByUserNameRequest;
resultValue.UserName.Should().Be(command.UserName);
}
public void BasketsController_Create_Basket_Order_Line_Return_Correct_Order_Line()
{
var baskets = new InMemoryDataStore <Basket>();
var products = new InMemoryDataStore <Product>();
products.Seed();
baskets.Seed(products);
var orderLine = new OrderLineCreateDto()
{
ProductId = new Guid("3aee1758-77b9-4e86-9c57-77adbbc0956f"), //Watermelon
Quantity = 5
};
var bc = new BasketsController(products, baskets, _mapper);
var actionResult = bc.PostAddOrderLineToBasket(_testBasketId, orderLine);
CreatedAtRouteResult createdresult = actionResult as CreatedAtRouteResult;
Assert.IsNotNull(createdresult);
OrderLineDto resultOrderLine = createdresult.Value as OrderLineDto;
Assert.IsNotNull(resultOrderLine);
Assert.AreEqual(resultOrderLine.ProductId, orderLine.ProductId);
}
public void PutCreateTest()
{
//Arrange.
var modelIn = new UpdateUserModelIn()
{
Name = "name1",
Surname = "surname1",
Password = "******",
Email = "*****@*****.**"
};
service.Setup(us => us.ModifyUser(It.IsAny <UserDto>())).Throws(new ServiceException("", ErrorType.ENTITY_NOT_FOUND));
service.Setup(us => us.AddUser(It.IsAny <UserDto>())).Returns(GetFakeUser());
//Act.
IActionResult result = controller.Put("username", modelIn);
CreatedAtRouteResult createdResult = result as CreatedAtRouteResult;
UserModelOut added = createdResult.Value as UserModelOut;
Assert.IsNotNull(result);
Assert.IsNotNull(createdResult);
Assert.IsNotNull(added);
Assert.AreEqual("GetUserById", createdResult.RouteName);
Assert.AreEqual(201, createdResult.StatusCode);
Assert.AreEqual("username", added.Username);
}
public IActionResult Create([FromBody] CustomerViewModel customer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Customer _newCustomer = new Customer
{
FirstName = customer.FirstName,
LastName = customer.LastName,
Email = customer.Email,
CompanyName = customer.CompanyName,
LeadTypeId = customer.LeadTypeId
};
_customerRepository.Add(_newCustomer);
_customerRepository.Commit();
customer = Mapper.Map <Customer, CustomerViewModel>(_newCustomer);
CreatedAtRouteResult result = CreatedAtRoute("GetCustomer", new { controller = "Customer", id = customer.Id }, customer);
return(result);
}
private async Task <IActionResult> Create([FromBody] ProductViewModel product)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Product _newProduct = Mapper.Map <ProductViewModel, Product>(product);
_newProduct.CreatedDate = DateTime.Now;
await _productRepository.AddAsync(_newProduct);
// foreach (var userId in product.)
// {
// _newSchedule.Attendees.Add(new Attendee { UserId = userId });
// }
// _scheduleRepository.Commit();
product = Mapper.Map <Product, ProductViewModel>(_newProduct);
CreatedAtRouteResult result = CreatedAtRoute("GetProduct", new { controller = "Product", id = product.ID }, product);
return(result);
}
//TODO : VIEW MODEL
public IActionResult Put(int id, [FromBody] CmsViewModel cms)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Cms _cmsDb = _cmsRepository.GetSingle(id);
if (_cmsDb == null)
{
return(NotFound());
}
else
{
//TODO : AJUSTAR
_cmsDb.Titulo = cms.Titulo;
_cmsDb.Avatar = cms.Avatar;
_cmsDb.QtdFields = cms.QtdFields;
_cmsDb.FieldsCreated = cms.FieldsCreated;
_cmsDb.WorkItemTypeId = cms.WorkItemTypeId;
_cmsRepository.Commit();
}
//cms = Mapper.Map<Cms, CmsViewModel>(_cmsDb);
CreatedAtRouteResult result = CreatedAtRoute("GetCmsies", new { controller = "Cmsies", _cmsDb.Id }, cms);
return(result);
// return new NoContentResult();
}
public void PostOwner()
{
using (MyProfileDbContext context = new MyProfileDbContext(_dbContextOptions))
{
IMapper mapper = CreateMapperConfig();
MyProfileController myProfileController = new MyProfileController(mapper, new OwnerRepository(context), new AddressRepository(context), new ContactRepository(context), new ExperienceRepository(context));
OwnerDto owner = new OwnerDto()
{
DateBirth = DateTime.Now,
FirstName = $"Post",
LastName = $"Test"
};
IActionResult result = myProfileController.PostOwner(owner);
CreatedAtRouteResult createdAtRouteResult = result as CreatedAtRouteResult;
OwnerDto ownerDtoResult = createdAtRouteResult.Value as OwnerDto;
Assert.Equal("GetOwner", createdAtRouteResult.RouteName);
Assert.Equal(201, createdAtRouteResult.StatusCode);
Assert.NotNull(ownerDtoResult);
Assert.Equal(1, ownerDtoResult.ID);
}
}
public void TestCreateArtist()
{
// Arrange
ArtistForCreationDto artist = new ArtistForCreationDto
{
Name = "Jheronimus Bosch",
City = "Hertogenbosch",
BirthYear = 1450,
Birth = new DateTime(1568, 02, 25),
DeathYear = 1516,
Death = new DateTime(1890, 07, 29),
ShortDescription = "Was a Dutch/Netherlandish draughtsman and painter from Brabant.",
LongDescription = "He is widely considered one of the most notable representatives of Early Netherlandish painting school. His work is known for its fantastic imagery, detailed landscapes, and illustrations of religious concepts and narratives. Within his lifetime his work was collected in the Netherlands, Austria, and Spain, and widely copied, especially his macabre and nightmarish depictions of hell.",
ImageUrl = "/images/Artists/Jheronimus-Bosch.jpg",
ImageThumbnailUrl = "/images/Artists/Jheronimus-Bosch_tn.jpg"
};
// Act
IActionResult actionResult = _cutArtists.CreateArtist(artist);
// Assert
Assert.NotNull(actionResult);
CreatedAtRouteResult result = actionResult as CreatedAtRouteResult;
Assert.NotNull(result);
Assert.Equal(201, result.StatusCode);
}
public void NewGuestHostReservation_Fail()
{
Guest newGuest = new Guest();
newGuest.Id = _guestsRepo.GetNumberOfGuests() + 1;
ActionResult <Guest> guestActionResult = _guestsController.CreateGuest(newGuest);
Assert.IsTrue(guestActionResult.Result is CreatedAtRouteResult);
HostCreateDto newHost = new HostCreateDto();
newHost.Apartment = new ApartmentCreateDto();
newHost.Apartment.Address = new Address();
newHost.Apartment.Address.Country = "Israel";
newHost.Apartment.Address.City = "Netanya";
newHost.Apartment.Address.Street = "Beeri";
ActionResult <HostReadDto> hostActionResult = _hostsController.CreateHost(newHost);
Assert.IsTrue(hostActionResult.Result is CreatedAtRouteResult);
CreatedAtRouteResult hostReadDto = hostActionResult.Result as CreatedAtRouteResult;
ReservationCreateDto newReservations = new ReservationCreateDto();
newReservations.ArrivingDate = new DateTime(2018, 08, 01);
newReservations.LeavingDate = new DateTime(2018, 07, 09);
newReservations.ReservationGuestId = newGuest.Id;
newReservations.ReservationHostId = ((HostReadDto)hostReadDto.Value).Id;
ActionResult <ReservationReadDto> reservationSctionResult = _reservationsController.CreateReservation(newReservations);
Assert.IsTrue(reservationSctionResult.Result is NotFoundObjectResult);
}
public IActionResult Create([FromBody] MeetingSchemaViewModel meetingSchema)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
MeetingSchemas NewMSchemas = Mapper.Map <MeetingSchemaViewModel, MeetingSchemas>(meetingSchema);
NewMSchemas.DateCreated = DateTime.Now;
_meetingSchemasRepository.Add(NewMSchemas);
_meetingSchemasRepository.Commit();
foreach (var item in meetingSchema.Participants)
{
NewMSchemas.Participants.Add(new Participants {
UserId = item
});
}
_meetingSchemasRepository.Commit();
meetingSchema = Mapper.Map <MeetingSchemas, MeetingSchemaViewModel>(NewMSchemas);
//Create
CreatedAtRouteResult result = CreatedAtRoute("Get", new { controller = "MeetingSchemas", Id = meetingSchema.Id }, meetingSchema);
// return result;
return(Json(result));
}
public async Task <IActionResult> Create([FromBody] Employee vM)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//User _newUser = new User { Name = user.Name, Profession = user.Profession, Avatar = user.Avatar };
var dateTime = System.DateTime.Now;
vM.BirthDate = dateTime;
vM.CreatedBy = "Obtener Usuario Actual";
vM.CreatedDate = dateTime;
vM.UpdatedDate = dateTime;
this.employeeService.Add(vM);
await this.employeeService.Commit();
//user = Mapper.Map<User, UserViewModel>(_newUser);
CreatedAtRouteResult result = CreatedAtRoute("GetEmployee", new { controller = "Employee", id = vM.Id }, vM);
return(result);
}
public async Task ExecuteResultAsync(ActionContext context)
{
var createdResult = new CreatedAtRouteResult(_routeName, _result.Result);
createdResult.StatusCode = StatusCodes.Status201Created;
await createdResult.ExecuteResultAsync(context);
}
public void ValueAs_Null_ShouldFail()
{
ActionResult result = new CreatedAtRouteResult(string.Empty, null, null);
string failureMessage = FailureMessageHelper.ExpectedContextTypeXButFoundNull("CreatedAtRouteResult.Value", typeof(object));
Action a = () => result.Should().BeCreatedAtRouteResult().ValueAs <object>();
a.Should().Throw <Exception>().WithMessage(failureMessage);
}
public void WithRouteValue_GivenExpectedKeyValuePair_ShouldPass()
{
var expectedKey = "expectedKey";
var expectedValue = "expectedValue";
var routeValues = new { expectedKey = expectedValue };
var result = new CreatedAtRouteResult(string.Empty, routeValues, null);
result.Should().BeCreatedAtRouteResult().WithRouteValue(expectedKey, expectedValue);
}
