public void Setup()
{
contextBuilder = InitializeDBContext();
_queries = new Service.Queries.QueriesService(contextBuilder);
flightsController = new FlightsController(_queries);
flights = _queries.GetAllFlights();
}
public void Setup()
{
var flight = new FlightToDisplay()
{
DepartureAirportID = 1, DestinationAirportID = 2, AircraftID = 1
};
var listFlights = new List <FlightToDisplay>()
{
flight
};
fakeService = new Services.Fakes.StubIFlightService()
{
DisposeOfStorage = () => { },
AddFlightFlightToDisplay = (f) => { return(new Result <AddResultStatus>(AddResultStatus.Success)); },
RemoveFlightInt32 = (f) => { return(new Result <RemoveResultStatus>(RemoveResultStatus.Success)); },
EditFlightFlightToDisplay = (f) => { return(new Result <EditResultStatus>(EditResultStatus.Success)); },
GetFlightsToDisplayListOfFlightToDisplayOut = (out List <FlightToDisplay> f) =>
{
f = listFlights;
return(new Result <bool>(true));
},
GetFlightToDisplayInt32FlightToDisplayOut = (int id, out FlightToDisplay f) =>
{
f = flight;
return(new Result <bool>(true));
},
};
sut = new FlightsController(fakeService);
}
public void Get_Should_get_flight_by_id()
{
// Arrange
var flightDTO = new FlightDTO
{
Id = 1,
Number = 1111,
PointOfDeparture = "Lviv",
DepartureTime = new DateTime(2018, 07, 10, 18, 23, 0),
Destination = "London",
DestinationTime = new DateTime(2018, 07, 11, 18, 23, 0)
};
var flightService = A.Fake <IFlightService>();
A.CallTo(() => flightService.GetEntity(A <int> ._)).Returns(flightDTO);
var flightsController = new FlightsController(flightService);
//Act
var actionResult = flightsController.Get(1);
//Assert
Assert.NotNull(actionResult);
OkObjectResult result = actionResult as OkObjectResult;
Assert.NotNull(result);
FlightDTO flightDTOResult = result.Value as FlightDTO;
Assert.AreEqual(flightDTO, flightDTOResult);
}
async public Task PostNew_ShouldAddFlightAndRedirect()
{
// Arrange
var controller = new FlightsController(this.flightApiService, this.airportApiService, this.aircraftApiService);
var flightEditViewModel = new FlightEditViewModel
{
DepartureAirportId = "SRC",
DestinationAirportId = "DST",
AircraftId = "AIR"
};
// Act
var result = await controller.New(flightEditViewModel);
// Assert
var viewResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal(nameof(Tui.WebApplication.Controllers.FlightsController.Index), viewResult.ActionName);
// The new flight is in the repository ?
var newFlight = (await this.flightApiService.GetAll()).SingleOrDefault(f =>
f.Aircraft.Id == flightEditViewModel.AircraftId &&
f.DepartureAirport.Id == flightEditViewModel.DepartureAirportId &&
f.DestinationAirport.Id == flightEditViewModel.DestinationAirportId);
Assert.NotNull(flightEditViewModel);
}
public async Task PutShouldReturnReturnOkResultWithModelDataUpdated()
{
// Arrange
var model = new Flight {
Id = 1
};
var datetimeoffset = DateTimeOffset.UtcNow;
Mock.Arrange(() => DateTimeOffset.UtcNow).Returns(datetimeoffset);
var userid = Guid.NewGuid().ToString();
var fakeContext = Mock.Create <HttpContext>(Constructor.Mocked);
Mock.Arrange(() => HttpContext.Current).Returns(fakeContext);
Mock.Arrange(() => HttpContext.Current.User.Identity.GetUserId()).Returns(userid);
var fakeSql = Substitute.For <IDatabase>();
fakeSql.UpdateAsync(model).Returns(Task.FromResult(true));
var controller = new FlightsController(fakeSql);
// Act
var result = await controller.Put(2, model);
// Assert
var viewResult = Assert.IsType <OkNegotiatedContentResult <Flight> >(result);
Assert.Equal(viewResult.Content.UserId, userid);
Assert.Equal(viewResult.Content.ModifiedDate, datetimeoffset);
Assert.Equal(viewResult.Content.Id, 2);
}
public void GetAll_ShouldReturnAllFlights()
{
// Arrange
FlightsController controller = new FlightsController(this.flightRepository);
// Act
var actionResult = controller.Get();
// Asserts
// Assert 1 : Call OK - 200
var okResult = Assert.IsType <OkObjectResult>(actionResult.Result);
// Assert 2 : same number of flights
var apiFlights = okResult.Value as IEnumerable <Flight>;
Assert.Equal(this.flights.Count, apiFlights.Count());
// Assert 3 : find each flight
foreach (var flight in flights)
{
var apiFlight = apiFlights.Single(a => a.Id == flight.Id);
Assert.Equal(flight.Aircraft.Name, apiFlight.Aircraft.Name);
Assert.Equal(flight.DepartureAirport.Name, apiFlight.DepartureAirport.Name);
Assert.Equal(flight.DestinationAirport.Name, apiFlight.DestinationAirport.Name);
}
}
public void Test_GetFlight()
{
// Setup
Location location = new Location(38.112375, 23.879437, DateTime.UtcNow);
List <Segment> segments = new List <Segment>();
segments.Add(new Segment(31.922629, 31.522594, 50)); // Egypt
segments.Add(new Segment(32.426506, 34.743033, 50)); // Cyprus
segments.Add(new Segment(26.209199, 35.055211, 50)); // Greece
FlightPlan flightPlan = new FlightPlan(8, "Company", location, segments);
var stubRemoteServersConnector = new RemoteServersConnector();
var stubFlightsManager = new FlightsManager(stubRemoteServersConnector);
stubFlightsManager.AddFlightPlan(flightPlan);
var flightsController = new FlightsController(stubFlightsManager);
Thread.Sleep(1000);
// Act
IActionResult getAction = flightsController.GetFlights(DateTime.UtcNow.ToString());
// Assert
OkObjectResult okAction = Assert.IsType <OkObjectResult>(getAction);
string flightsStr = Assert.IsType <string>(okAction.Value);
var flights = JsonConvert.DeserializeObject(flightsStr);
Assert.Single((System.Collections.IEnumerable)flights);
}
public void FlightControllerDateTimeTest()
{
// Arrange
var context = new Mock <HttpContext>();
context.SetupGet(x => x.Request.QueryString).Returns(new QueryString("?"));
var controllerContext = new ControllerContext()
{
HttpContext = context.Object,
};
var relative_to = "Invalid_Date_Time";
var stub = new Mock <IScheduledCache>();
var flightManager = new FlightManager(stub.Object);
var flightsController = new FlightsController(flightManager)
{
ControllerContext = controllerContext,
};
// Act
var result = flightsController.GetFlightsAsync(relative_to, "");
// Assert
var action = Assert.IsType <BadRequestObjectResult>(result.Result);
var message = Assert.IsAssignableFrom <string>(action.Value);
Assert.Equal("Date: Invalid_Date_Time has wrong format", message);
}
public void FlightsModel_Sync_all()
{
//set up:
string time = DateTime.UtcNow.ToString();
IMemoryCache cache = new MemoryCache(new MemoryCacheOptions());
Mock <IFlightsModel> mockModel = new Mock <IFlightsModel>();
List <Flight> response = new List <Flight>();
Server server = new Server();
server.ServerId = 123;
server.ServerURL = "www.test.com";
List <Server> servers = new List <Server>();
servers.Add(server);
cache.Set("ServerList", servers);
Flight flight = SetFlight();
response.Add(flight);
List <Flight> curr = new List <Flight>();
//mock method definition:
mockModel.Setup(model => model.GetCurrentFromServer(It.IsAny <Server>(), It.IsAny <string>(), It.IsAny <List <Flight> >()))
.Returns((Server server, string time, List <Flight> curr) => { return(Task.FromResult(response)); });
FlightsController controller = new FlightsController(cache);
controller.SetModel(mockModel.Object);
//execution:
Task <List <Flight> > flights = controller.GetAllFlightsByTimeAsync(time);
//assert:
Assert.AreEqual(flights.Result, response);
}
public void FlightControllerRelativetoAndSyncAllTest()
{
// Arrange
var context = new Mock <HttpContext>();
//sync_all specified for the controller to get flights from the server and from remote servers.
context.SetupGet(x => x.Request.QueryString).Returns(new QueryString("?sync_all"));
var controllerContext = new ControllerContext()
{
HttpContext = context.Object,
};
var relative_to = "2020-05-09T18:23:18Z";
//the controller suppose to use "Get_AllFlights_Relative_ToAsync" method in the IFlightManager object.
var flightManagerMock = new Mock <IFlightManager>();
flightManagerMock.Setup(repo => repo.GetAllFlightsRelativeToAsync(relative_to))
.Returns(TestGetAllFlightsRelativeToAsync());
var flightsController = new FlightsController(flightManagerMock.Object)
{
ControllerContext = controllerContext,
};
// Act
var result = flightsController.GetFlightsAsync(relative_to, "sync_all");
// Assert
var action = Assert.IsType <OkObjectResult>(result.Result);
var flightArray = Assert.IsAssignableFrom <Flight[]>(action.Value);
Assert.Equal(2, flightArray.Length);
}
public void FlightControllerRelativetoTest()
{
var context = new Mock <HttpContext>();
//the sync_all isnt part of the request so the controller
context.SetupGet(x => x.Request.QueryString).Returns(new QueryString("?"));
var controllerContext = new ControllerContext()
{
HttpContext = context.Object,
};
// Arrange
var relative_to = "2020-05-09T18:23:18Z";
var mockRepo = new Mock <IFlightManager>();
//the controller suppose to use "GetFlightsRelativeToAsync" method in the IFlightManager object.
mockRepo.Setup(repo => repo.GetFlightsRelativeToAsync(relative_to))
.Returns(TestGetAllFlightsRelativeToAsync());
var flightsController = new FlightsController(mockRepo.Object)
{
ControllerContext = controllerContext,
};
// Act
var result = flightsController.GetFlightsAsync(relative_to, "");
// Assert
var action = Assert.IsType <OkObjectResult>(result.Result);
var flightArray = Assert.IsAssignableFrom <Flight[]>(action.Value);
Assert.Equal(2, flightArray.Length);
}
public async Task GetFlightsInternalTest()
{
// determining the flight times
var relativeTo = "2020-05-27T15:35:05Z";
var startTime = DateTime.Parse("2020-05-27T12:05:00Z");
var endTime = DateTime.Parse("2020-05-27T13:05:00Z");
// context
var context = await CreateTestContext(startTime, endTime);
// mock http client factory
var mockClientFactory = new Mock <IHttpClientFactory>();
// controller
var controller = new FlightsController(context, mockClientFactory.Object);
// calculating the location
var testSegmentFirst = CreateTestSegment(1, 1, 23.240702, 34.921971, 1800, startTime, startTime.AddSeconds(1800));
var testSegmentSecond = CreateTestSegment(2, 1, 21.346370, 39.419221, 1800, startTime.AddSeconds(1800), endTime);
var secondsInSegment = 5.0;
var delta = secondsInSegment / testSegmentSecond.TimeSpanSeconds;
var expectedLatitude = testSegmentFirst.Latitude + delta *
(testSegmentSecond.Latitude - testSegmentFirst.Latitude);
var expectedLongitude = testSegmentFirst.Longitude + delta *
(testSegmentSecond.Longitude - testSegmentFirst.Longitude);
// Act - running method and checking results
await GetResultsAndCheck(controller, relativeTo, expectedLongitude, expectedLatitude);
}
/*
* Run the GetFlights method with the test objects, get the results and check if they are correct
*/
private static async Task GetResultsAndCheck(FlightsController controller, string relativeTo, double expectedLongitude, double expectedLatitude)
{
// run GetFlights and get the result
var result = (await controller.GetFlights(relativeTo)).FirstOrDefault();
// check that result is not null and parse the result for further checks
Assert.IsNotNull(result);
var resultFlightId = result.FlightId;
var resultLongitude = result.Longitude;
var resultLatitude = result.Latitude;
var resultPassengers = result.Passengers;
var resultCompanyName = result.CompanyName;
var pattern = "dd-MMM-yy h:mm:ss tt";
var culture = new CultureInfo("en-US");
var resultDateTime = result.CurrDateTime.ToString(pattern, culture);
var resultIsExternal = result.IsExternal;
// checking GetFlights returned the right results
Assert.AreEqual("IL30357629", resultFlightId);
Assert.AreEqual(expectedLongitude, resultLongitude);
Assert.AreEqual(expectedLatitude, resultLatitude);
Assert.AreEqual(247, resultPassengers);
Assert.AreEqual("United Airlines", resultCompanyName);
Assert.AreEqual("27-May-20 3:35:05 PM", resultDateTime);
Assert.AreEqual(false, resultIsExternal);
}
public void PostFlightShouldNotValidate()
{
// Arrange
Flight flight = new Flight(null, "Santiago", "Antofagasta", 40, 100, "101", new DateTime(2021, 07, 20, 20, 00, 00), new DateTime(2021, 07, 20, 23, 00, 00));
DBEntities db = new DBEntities();
FlightsController controller = new FlightsController();
// Act
IHttpActionResult actionResult = controller.PostFlight(flight);
var createdResult = actionResult as CreatedAtRouteNegotiatedContentResult <Flight>;
try
{
if (createdResult.RouteName == "DefaultApi")
{
db.Entry(flight).State = EntityState.Deleted;
db.SaveChanges();
}
}
catch (Exception)
{
}
// Assert
Assert.IsType <BadRequestResult>(actionResult);
}
public void Create_many_flights(int id)
{
var options = new DbContextOptionsBuilder <FlyingContext>()
.UseInMemoryDatabase(databaseName: "create_many_database")
.Options;
// Run the test against one instance of the context
using (var context = new FlyingContext(options))
{
// Create a new flight
var flight = new Flight();
flight.FlightId = id;
flight.DepartureName = "Ronald Reagan Washington National Airport" + id;
flight.DepartureLatitude = 38.8521d;
flight.DepartureLongitude = -77.037697d;
flight.DestinationName = "Ken Jones Airport" + id;
flight.DestinationLatitude = 18.1987991333d;
flight.DestinationLongitude = -76.53450012210001d;
flight.FuelConsumption = 1.26d;
flight.TakeoffEffort = 1.001d;
flight.Speed = 500;
// Save the flight in the data base
var controller = new FlightsController(context);
var result = controller.Create(flight).Result as RedirectToActionResult;
Assert.IsNotNull(result, $"Flight {id} was not created");
Assert.AreEqual("Index", result.ActionName);
}
}
public async Task GetFlightsAvailabilityAsync_WhenHasAvailability()
{
// Create test data and setup the mock object before the call
string queryArgIssues = null;
_mockAvailabilityService.Setup(o => o.QueryArgsIssues(
It.IsAny <DateTime?>(),
It.IsAny <DateTime?>(),
It.IsAny <int?>()
)).Returns(queryArgIssues);
IEnumerable <Availability> availabilities = new Availability[] {
new Availability {
FlightId = 1,
BookingDate = DateTime.UtcNow.Date,
Passengers = 2
}
};
_mockAvailabilityService.Setup(o => o.GetAvailabilityAsync(
It.IsAny <DateTime>(),
It.IsAny <DateTime>(),
It.IsAny <int>(),
It.IsAny <CancellationToken>()
)).Returns(Task.FromResult(availabilities));
FlightsController controller = new FlightsController(_mockAvailabilityService.Object, _mockFlightService.Object);
// Make the call
var result = await controller.GetFlightsAvailabilityAsync(DateTime.UtcNow.Date, DateTime.UtcNow.Date, 2, CancellationToken.None);
// Validate the outcome
Assert.NotNull(result);
Assert.IsType <OkObjectResult>(result);
}
public void Update_ShouldModifyFlight()
{
// Arrange
FlightsController controller = new FlightsController(this.flightRepository);
Guid modifiedFlightId = this.flightRepository.GetAll().First().Id;
// Create a completely new flight
Flight modifiedFlight = new Flight(
new Airport("MODIF1", "Modified DepartureAirport", 33.94250107, -118.4079971),
new Airport("MODIF2", "Modified DestinationAirport", 33.94250107, -118.4079971),
new Aircraft("MODIF3", "Modified Aircraft", 33.94250107, -118.4079971)
);
modifiedFlight.Id = modifiedFlightId; // Keep the id of the flight
// Act
var actionResult = controller.Update(modifiedFlight);
// Asserts
// Assert 1 : Call OK - 200
Assert.IsType <CreatedAtActionResult>(actionResult.Result);
// retrieve the new flight in the repository
var flightFromRepository = this.flightRepository.GetById(modifiedFlight.Id);
// Assert 2 : check created flight match the new one
Assert.Equal(modifiedFlight.Aircraft.Name, flightFromRepository.Aircraft.Name);
Assert.Equal(modifiedFlight.DepartureAirport.Name, flightFromRepository.DepartureAirport.Name);
Assert.Equal(modifiedFlight.DestinationAirport.Name, flightFromRepository.DestinationAirport.Name);
}
public async Task GetAllFlightsGetHttpRequestException_ShouldReturnBadRequest()
{
// Arrange
this.managerMock.Setup(x => x.GetAllFlights(It.IsAny <string>(), It.IsAny <bool>())).Throws(
new HttpRequestException());
this.myContext.SetupGet(x => x.Request.QueryString).Returns(new QueryString
("?relative_to=2020-11-27T01:56:22Z"));
var controllerContext = new ControllerContext()
{
HttpContext = myContext.Object,
};
var controller = new FlightsController(managerMock.Object)
{
ControllerContext = controllerContext,
};
// Act
var response = await controller.GetAllFlights("asdfd");
// Assert check if he handles HttpRequestException
var action = Assert.IsType <BadRequestObjectResult>(response.Result);
string message = Assert.IsAssignableFrom <string>(action.Value);
Assert.Equal("problem in request to servers", message);
}
public void Create_ShouldAddFlight()
{
// Arrange
var flightToAdd = new Flight(
new Airport("HND", "Tokyo Haneda International Airport (Japan)", 35.552299, 139.779999),
new Airport("LAX", "Los Angeles International Airport (United States)", 33.94250107, -118.4079971),
new Aircraft("OO-JAA", "VICTORY", 0, 0)
);
FlightsController controller = new FlightsController(this.flightRepository);
// Act
var actionResult = controller.Create(flightToAdd);
// Asserts
// Assert 1 : Call OK - 200
Assert.IsType <CreatedAtActionResult>(actionResult.Result);
// retrieve the new flight in the repository
var newFlightIdFromApi = (Guid)(actionResult.Result as CreatedAtActionResult).RouteValues["id"];
var flightFromRepository = this.flightRepository.GetById(newFlightIdFromApi);
// Assert 2 : check created flight match the new one
Assert.Equal(flightToAdd.Aircraft.Name, flightFromRepository.Aircraft.Name);
Assert.Equal(flightToAdd.DepartureAirport.Name, flightFromRepository.DepartureAirport.Name);
Assert.Equal(flightToAdd.DestinationAirport.Name, flightFromRepository.DestinationAirport.Name);
}
public async Task GetAllFlightsGetFormatException_ShouldReturnBadRequest()
{
// Arrange
this.managerMock.Setup(x => x.GetAllFlights(It.IsAny <string>(), It.IsAny <bool>())).Throws(
new FormatException());
this.myContext.SetupGet(x => x.Request.QueryString).Returns(new QueryString
("?relative_to=2020-11-27T01:56:22Z"));
var controllerContext = new ControllerContext()
{
HttpContext = myContext.Object,
};
var controller = new FlightsController(managerMock.Object)
{
ControllerContext = controllerContext,
};
// Act
ActionResult <IEnumerable <Flight> > response = await controller.GetAllFlights("asdfd");
// Assert
var action = Assert.IsType <BadRequestObjectResult>(response.Result);
string message = Assert.IsAssignableFrom <string>(action.Value);
Assert.Equal("Date and time not in format", message);
}
public void Test_DeleteFlight()
{
// Setup
Location location = new Location(38.112375, 23.879437, DateTime.UtcNow);
List <Segment> segments = new List <Segment>();
segments.Add(new Segment(31.922629, 31.522594, 50)); // Egypt
segments.Add(new Segment(32.426506, 34.743033, 50)); // Cyprus
segments.Add(new Segment(26.209199, 35.055211, 50)); // Greece
FlightPlan flightPlan = new FlightPlan(8, "Company", location, segments);
var stubRemoteServersConnector = new RemoteServersConnector();
var mockFlightsManager = new FlightsManager(stubRemoteServersConnector);
mockFlightsManager.AddFlightPlan(flightPlan);
List <Flight> flights = mockFlightsManager.GetRelativeFlights(DateTime.UtcNow, false);
string flightId = flights.ToArray()[0].Flight_Id;
var flightsController = new FlightsController(mockFlightsManager);
// Act
IActionResult delAction = flightsController.DeleteFlight(flightId);
// Assert
Assert.IsType <OkResult>(delAction);
Assert.Empty(mockFlightsManager.GetRelativeFlights(DateTime.UtcNow, false));
}
public async Task Delete_ValidRequest_Success()
{
// Arrange
var flightId = _fixture.Create <Guid>();
var tempData = new TempDataDictionary(
new DefaultHttpContext(),
Mock.Of <ITempDataProvider>())
{
[nameof(DefaultMessages.FlightDeletedMessage)] = DefaultMessages.FlightDeletedMessage
};
var target = new FlightsController(_mediatorMock.Object)
{
TempData = tempData
};
// Act
var result = await target.Delete(flightId);
// Assert
var viewResult = result
.Should()
.BeOfType <RedirectToActionResult>().Subject;
viewResult.ActionName
.Should()
.Be(nameof(FlightsController.Index));
_mediatorMock.Verify(x => x.Send(
It.IsAny <FlightDelete.Command>(),
It.IsAny <CancellationToken>()));
}
// Arrange the mocks and controller for the sync tests.
private FlightsController ArrangeForSyncTests(bool withSync, List <Flight> flightsToReturn)
{
Mock <IFlightsManager> managerMock =
new Mock <IFlightsManager>();
managerMock.Setup(x => x.GetAllFlights(It.IsAny <string>(), false)).Returns(
Task.Run(() => flightsToReturn.AsEnumerable()));
managerMock.Setup(x => x.GetAllFlights(It.IsAny <string>(), true)).Returns(
Task.Run(() => flightsToReturn.AsEnumerable()));
Mock <HttpContext> myContext = new Mock <HttpContext>();
string returnedValue = "?relative_to=2020-11-27T01:56:22Z";
if (withSync)
{
returnedValue = "?relative_to=2020-11-27T01:56:22Z&sync_all";
}
myContext.SetupGet(x => x.Request.QueryString).Returns(new QueryString
(returnedValue));
ControllerContext controllerContext = new ControllerContext()
{
HttpContext = myContext.Object,
};
FlightsController controller = new FlightsController(managerMock.Object)
{
ControllerContext = controllerContext,
};
return(controller);
}
public async Task CreateGet_ValidRequest_Success()
{
// Arrange
var expectedAirports = _fixture.CreateMany <Airport>().ToList();
_mediatorMock
.Setup(x => x.Send(
It.IsAny <AirportAll.Query>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(expectedAirports);
var target = new FlightsController(_mediatorMock.Object);
// Act
var result = await target.Create();
// Assert
var viewResult = result
.Should()
.BeOfType <ViewResult>().Subject;
var model = viewResult.ViewData.Model
.Should()
.BeOfType <AddFlightViewModel>().Subject;
model.Airports
.Should()
.HaveCount(expectedAirports.Count);
}
public async Task ShouldReturnStatusCode()
{
//ARRANGE
var mockFactory = new Mock <IHttpClientFactory>();
var client = new HttpClient(new HttpMessageHandlerStub());
mockFactory.Setup(_ => _.CreateClient(It.IsAny <string>())).Returns(client);
IHttpClientFactory factory = mockFactory.Object;
FlightsController controller = new FlightsController(factory);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
//prepare the query parameters with external servers
controller.ControllerContext.HttpContext.Request.QueryString = new QueryString("?sync_all");
MyServersManager myServersManager = new MyServersManager();
Servers server = new Servers();
server.ServerId = "123";
server.ServerURL = "http://mock.com";
myServersManager.AddServer(server);
//ACT
var res = await controller.Get("2020-12-27T01:56:21Z");
//ASSERT
Assert.AreEqual(StatusCodes.Status400BadRequest, (res.Result as StatusCodeResult).StatusCode);
}
public async Task FlightControllerTests_Update_ShouldReturnBadRequest_WhenAircraftIdIsZero()
{
// Arrange
var newFlight = new CreateFlightArgs
{
FlightNumber = string.Empty,
AircraftId = 0,
DepartureAirportId = 1,
DestinationAirportId = 2,
FlightDate = DateTime.Now,
FlightTime = DateTime.Now
};
var flightController = new FlightsController(_flightCoreServicesMock.Object, _airportCoreServicesMock.Object, _aircraftCoreServicesMock.Object);
flightController.ModelState.AddModelError("AircraftId", "Aircraft Id is not Valid.");
// Act
var result = await flightController.CreateFlightPost(newFlight);
// Assert
Check.That(result).IsInstanceOfType(typeof(BadRequestObjectResult));
var viewResult = result as BadRequestObjectResult;
Check.That(viewResult).IsNotNull();
Check.That(flightController.ModelState.IsValid).IsFalse();
Check.That(viewResult.StatusCode).IsEqualTo(400);
_flightCoreServicesMock.Verify(service => service.CreateFlight(It.IsAny <CreateFlightArgs>()), Times.Never);
}
public void Delete_Should_delete_flight_by_id_return_statusCode_204()
{
// Arrange
var flightDTO = new FlightDTO
{
Id = 1,
Number = 1111,
PointOfDeparture = "Lviv",
DepartureTime = new DateTime(2018, 07, 10, 18, 23, 0),
Destination = "London",
DestinationTime = new DateTime(2018, 07, 11, 18, 23, 0)
};
var flightService = A.Fake <IFlightService>();
A.CallTo(() => flightService.GetEntity(A <int> ._)).Returns(flightDTO);
var flightsController = new FlightsController(flightService);
//Act
var actionResult = flightsController.Delete(1);
//Assert
Assert.NotNull(actionResult);
NoContentResult result = actionResult as NoContentResult;
Assert.NotNull(result);
Assert.AreEqual(204, result.StatusCode);
}
public async Task FlightControllerTests_Update_ShouldCallFlightService_WhenModelIsValid()
{
// Arrange
var newFlight = new CreateFlightArgs
{
FlightNumber = "NewFlight",
AircraftId = 1,
DepartureAirportId = 1,
DestinationAirportId = 2,
FlightDate = DateTime.Now,
FlightTime = DateTime.Now
};
var flightController = new FlightsController(_flightCoreServicesMock.Object, _airportCoreServicesMock.Object, _aircraftCoreServicesMock.Object);
// Act
var result = await flightController.CreateFlightPost(newFlight);
// Assert
Check.That(result).IsInstanceOfType(typeof(RedirectToActionResult));
var viewResult = result as RedirectToActionResult;
Check.That(viewResult).IsNotNull();
Check.That(flightController.ModelState.IsValid).IsTrue();
_flightCoreServicesMock.Verify(service => service.CreateFlight(It.IsAny <CreateFlightArgs>()), Times.Once);
}
public void Post_Should_create_new_flight_return_statusCode_200()
{
// Arrange
var flightDTO = new FlightDTO
{
Number = 1111,
PointOfDeparture = "Lviv",
DepartureTime = new DateTime(2018, 07, 10, 18, 23, 0),
Destination = "London",
DestinationTime = new DateTime(2018, 07, 11, 18, 23, 0)
};
var flightService = A.Fake <IFlightService>();
var flightsController = new FlightsController(flightService);
//Act
var actionResult = flightsController.Post(flightDTO);
//Assert
Assert.NotNull(actionResult);
OkObjectResult result = actionResult as OkObjectResult;
Assert.NotNull(result);
Assert.AreEqual(200, result.StatusCode);
}
public void FlightsController_GetTheListOFALLFlights_ARE_TRUE()
{
//Arrange
var mockRepository = new Mock <IFlightManager>();
List <FlightDetail> listFD = new List <FlightDetail>();
listFD.Add(new FlightDetail()
{
DepartureCityCode = "DXB",
ArrivalCityCode = "DEL",
FlightNumber = "101",
Capacity = 20
});
listFD.Add(new FlightDetail()
{
DepartureCityCode = "MEL",
ArrivalCityCode = "SYD",
FlightNumber = "103",
Capacity = 25
});
mockRepository.Setup(x => x.GetAllFlightsList()).ReturnsAsync(listFD);
var controller = new FlightsController(mockRepository.Object);
//Act
var result = controller.GetAllFlightList();
var contentResult = result.Result as OkNegotiatedContentResult <List <FlightDetail> >;
//Assert
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Assert.AreEqual(contentResult.Content.Count, 2);
}
