public async Task ShouldDeleteCrew()
{
// Create 2 crews
await CreateCrew(_crewName2);
await CreateCrew(_crewName3);
// Delete the first
CrewService crewService = new CrewService(_dbContext, _mainEventProvider);
CrewController crewController = new CrewController(crewService);
CrewVm crewVm = new CrewVm
{
CrewId = 2
};
await crewController.DeleteCrewAsync(crewVm);
// Check that we have deleted only one
// Check that the others still has data
Crew crew1 = _dbContext.Crews.Find(1);
Assert.IsNotNull(crew1);
Crew crew2 = _dbContext.Crews.Find(2);
Assert.IsNull(crew2);
Crew crew3 = _dbContext.Crews.Find(3);
Assert.IsNotNull(crew3);
Assert.AreEqual(_crewName3, crew3.Name);
}
public CrewVM()
{
service = new CrewService();
Crews = new ObservableCollection <Crew>();
SelectedCrew = new Crew();
ListInit();
}
[Test] // behaviour test
public void Create_When_entity_is_invalid_Then_it_makes_no_calls_to_repository_and_unit_of_work()
{
// Arrange
var crewDTOToCreate = new CrewDTO()
{
PilotId = 2
};
var crewRepositoryFake = A.Fake <ICrewRepository>();
var unitOfWorkFake = A.Fake <IUnitOfWork>();
A.CallTo(() => unitOfWorkFake.Set <Crew>()).Returns(crewRepositoryFake);
var crewService = new CrewService(unitOfWorkFake, AlwaysInValidValidator);
// Act + Assert
var exception = Assert.Throws <BadRequestException>(() => crewService.Create(crewDTOToCreate));
// Assert. Just behaviour
A.CallTo(() => crewRepositoryFake.Create(A <Crew> ._)).MustNotHaveHappened();
A.CallTo(() => unitOfWorkFake.CrewRepository).MustNotHaveHappened();
A.CallTo(() => unitOfWorkFake.Set <Crew>()).MustNotHaveHappened();
A.CallTo(() => unitOfWorkFake.SaveChanges()).MustNotHaveHappened();
}
public async Task ShouldUpdateCrewName()
{
// Create 2 crews
await CreateCrew(_crewName2);
await CreateCrew(_crewName3);
// Update one
CrewService crewService = new CrewService(_dbContext, _mainEventProvider);
CrewController crewController = new CrewController(crewService);
CrewVm crewNewData = new CrewVm
{
CrewId = 2,
CrewName = "New Name"
};
await crewController.UpdateCrewAsync(crewNewData);
// Check that only one has been changed
Crew crew1 = _dbContext.Crews.Find(2);
Assert.AreEqual(crewNewData.CrewName, crew1.Name);
Crew crew2 = _dbContext.Crews.Find(3);
Assert.AreEqual(crew2.Name, _crewName3);
}
public async Task LocalSetup()
{
var serviceProvider = new ServiceCollection().AddLogging().BuildServiceProvider();
var logger = serviceProvider.GetService <ILoggerFactory>().CreateLogger <UserManager <ApplicationUser> >();
UserStore <ApplicationUser> store = new UserStore <ApplicationUser>(_dbContext);
_userManager = new UserManager <ApplicationUser>(store, null, new PasswordHasher <ApplicationUser>(), null, null, null, null, null, logger);
_securityService = new SecurityService(_dbContext, _userManager, _roleManager);
_securityController = new SecurityController(_securityService);
SetUser(_securityController, _createdUser2.Entity.Id);
_crew = _dbContext.Crews.Find(1);
CrewService crewService = new CrewService(_dbContext, _mainEventProvider);
CrewController crewController = new CrewController(crewService);
await crewController.AddCrewLeaderAsync(_crew.Id, _createdUser2.Entity.Id);
await _securityController.SetPoliciesAsync(
new List <CrewPermissionsVm> {
new CrewPermissionsVm {
Name = "CheckInAdmin", Value = 0, CrewHasPermission = true
},
new CrewPermissionsVm {
Name = "CrewAdmin", Value = 1, CrewHasPermission = true
}
},
_crew.Id
);
}
public CrewServiceTests()
{
IMapper mapper = new Shared.DTO.MapperConfiguration().Configure().CreateMapper();
IUnitOfWork unitOfWork = new UnitOfWork(new DataAccess.Model.DataContext());
crewService = new CrewService(unitOfWork, mapper);
}
public void Create_When_entity_is_invalid_Then_bad_request_exception_is_thrown()
{
// Arrange
var crewMock = new Crew()
{
Id = 2,
PilotId = 2
};
var crewDTOToCreate = new CrewDTO()
{
PilotId = 2
};
var crewRepositoryFake = A.Fake <ICrewRepository>();
A.CallTo(() => crewRepositoryFake.Create(A <Crew> ._)).Returns(crewMock);
var unitOfWorkFake = A.Fake <IUnitOfWork>();
A.CallTo(() => unitOfWorkFake.Set <Crew>()).Returns(crewRepositoryFake);
var crewService = new CrewService(unitOfWorkFake, AlwaysInValidValidator);
// Act + Assert
var exception = Assert.Throws <BadRequestException>(() => crewService.Create(crewDTOToCreate), "");
Assert.AreEqual(exception.Message, "Is Invalid");
}
public void UpdateCrew_WhenInvalid_ThrowsArgumentNullException()
{
var crew = new CrewDTO
{
Stewardesses = new List <StewardessDTO>
{
new StewardessDTO
{
FirstName = "Maria",
LastName = "Petrova",
DateOfBirth = new DateTime(1970, 05, 03)
},
new StewardessDTO
{
FirstName = "Anna",
LastName = "Ivanova",
DateOfBirth = new DateTime(1990, 11, 09)
}
}
};
var service = new CrewService(fakeUnitOfWork, mapper);
Assert.ThrowsAsync <ArgumentNullException>(
() => service.Update(crew));
}
public void UpdateEntity_Should_Update_crew_typeof_Crew()
{
// Arrange
CrewDTO crewDTO = new CrewDTO
{
Id = 1,
PilotId = 1
};
Crew crew = new Crew
{
Id = 1,
PilotId = 1
};
var crewRepository = A.Fake <IRepository <Crew> >();
A.CallTo(() => crewRepository.Get(A <int> ._)).Returns(new Crew {
Id = 1
});
var crewService = new CrewService(crewRepository);
//Act
crewService.UpdateEntity(1, crewDTO);
var result = crewRepository.Get(1);
// Assert
Assert.AreEqual(crew, result);
}
public void TestSetUp()
{
var connection = @"Server=DESKTOP-DMYTRO\SQLEXPRESS;Initial Catalog=Academy;Trusted_Connection=True;ConnectRetryCount=0";
DbContextOptionsBuilder <MyContext> t = new DbContextOptionsBuilder <MyContext>();
t.UseSqlServer(connection);
mc = new MyContext(t.Options);
CrewRepository crewRepository = new CrewRepository(mc);
PilotRepository pilotRepository = new PilotRepository(mc);
StewardessRepository stewardessRepository = new StewardessRepository(mc);
FlightRepository flightRepository = new FlightRepository(mc);
TicketRepository ticketRepository = new TicketRepository(mc);
TakeOffRepository takeOffRepository = new TakeOffRepository(mc);
PlaneRepository planeRepository = new PlaneRepository(mc);
PlaneTypeRepository planeTypeRepository = new PlaneTypeRepository(mc);
UnitOfWork unitOfWork = new UnitOfWork(crewRepository, flightRepository, pilotRepository,
planeRepository, planeTypeRepository, stewardessRepository,
takeOffRepository, ticketRepository, mc);
CrewService crewService = new CrewService(unitOfWork);
FlightService flightService = new FlightService(unitOfWork);
StewardessService stewardessService = new StewardessService(unitOfWork);
PilotService pilotService = new PilotService(unitOfWork);
TicketService ticketService = new TicketService(unitOfWork);
TakeOffService takeOffService = new TakeOffService(unitOfWork);
PlaneService planeService = new PlaneService(unitOfWork);
PlaneTypeService planeTypeService = new PlaneTypeService(unitOfWork);
pilotController = new PilotController(pilotService);
flightController = new FlightController(flightService);
}
public void GetCrewById_WhenNegativeId_ThrowsArgumentException()
{
var id = -1;
var service = new CrewService(fakeUnitOfWork, mapper);
Assert.ThrowsAsync <ArgumentException>(
() => service.GetById(id));
}
public void GetCrewById_WhenWrongId_ThrowsNotFoundException()
{
var id = 10;
var service = new CrewService(fakeUnitOfWork, mapper);
Assert.ThrowsAsync <NotFoundException>(
() => service.GetById(id));
}
public void DeleteCrew_WhenNegativeId_ThrowsArgumentException()
{
var id = -1;
var service = new CrewService(fakeUnitOfWork, mapper);
Assert.ThrowsAsync <ArgumentException>(
() => service.Remove(id));
}
public void DeleteCrew_WhenWrongId_ThrowsNotFoundException()
{
var id = 10;
var service = new CrewService(fakeUnitOfWork, mapper);
Assert.ThrowsAsync <NotFoundException>(
() => service.Remove(id));
}
public Crews()
{
this.InitializeComponent();
cs = new CrewService();
list = cs.GetAll().Result;
Add.Click += (sender, e) => Create();
}
public async Task GetCrewById_WhenCorrectId_ReturnsCrew()
{
var id = 1;
var service = new CrewService(fakeUnitOfWork, mapper);
var result = await service.GetById(id);
Assert.IsTrue(result != null);
}
// Helper methods
private async Task <ActionResult> CreateCrew(string crewName)
{
CrewService crewService = new CrewService(_dbContext, _mainEventProvider);
CrewController crewController = new CrewController(crewService);
SetUser(crewController, _createdUser1.Entity.Id);
return(await crewController.CreateCrewAsync(crewName));
}
public CrewViewModel()
{
Title = "Crew";
CrewService = new CrewService();
SearchFilter = "";
Crews = new ObservableCollection <Crew>();
Crew = new Crew();
Search();
}
public CrewServiceTest()
{
this.logger = new Mock <ILogger <CrewService> >();
this.webHostEnvironment = new Mock <IWebHostEnvironment>();
var path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location.Replace("CrewOnDemandServiceTest\\bin\\Debug\\netcoreapp3.1", "CrewOnDemandService"));
this.webHostEnvironment.Setup(m => m.ContentRootPath).Returns(path);
this.crewService = new CrewService(this.logger.Object, this.webHostEnvironment.Object);
}
public async Task Update_WhenCrewNull_ThenReturnExeption()
{
var Crews = new IFakeRepository <Crew>();
var context = new IFakeUnitOfFactory();
CrewDto CrewDto = null;
CrewService service = new CrewService(context);
CrewDto CrewDtoSaved = await service.Update(CrewDto);
}
public async Task DeleteCrew_WhenCorrectId_DeletesCrew()
{
var id = 1;
var service = new CrewService(fakeUnitOfWork, mapper);
await service.Remove(id);
Assert.ThrowsAsync <NotFoundException>(
() => service.GetById(id));
}
public void GetById_Negative_ArgumentException()
{
//Arrange
ICrewRepository crewRepository = new CrewRepository();
ICrewService crewService = new CrewService(crewRepository);
const int NegativeId = -1;
//Act & Assert
Assert.ThrowsAsync <ArgumentException>(() => crewService.GetById(NegativeId));
}
public CrewViewModel(IDialogService dialogService)
{
_dialogService = dialogService;
_service = new CrewService();
AddCommand = new RelayCommand(AddCrew);
UpdateCommand = new RelayCommand(UpdateCrew);
DeleteCommand = new RelayCommand(DeleteCrew);
DownloadData();
}
public CrewViewModel()
{
this.service = new CrewService(ApiService.GetInstance());
pilotService = new PilotService(ApiService.GetInstance());
stewardessService = new StewardessService(ApiService.GetInstance());
Crews = new ObservableCollection <Crew>();
Pilots = new ObservableCollection <Pilot>();
Stewardesses = new ObservableCollection <Stewardess>();
FillCrewsCollection();
FillAdditionalCollections();
}
public void ShouldNotGetCrewMembersFromCrewWithInvalidId()
{
CrewService crewService = new CrewService(_dbContext, _mainEventProvider);
CrewController crewController = new CrewController(crewService);
var ex = Assert.ThrowsAsync <HttpException>(async() =>
{
ActionResult <List <CrewMembersListVm> > result = await crewController.GetCrewMembersAsync(123);
});
Assert.That(ex.Message == "Fant ikke arbeidslaget med ID: 123");
}
public void ShouldNotGetCrewByIdIfDoesntExist()
{
CrewService crewService = new CrewService(_dbContext, _mainEventProvider);
CrewController crewController = new CrewController(crewService);
var ex = Assert.ThrowsAsync <HttpException>(async() =>
{
ActionResult <CrewVm> result = await crewController.GetCrewAsync(123);
});
Assert.That(ex.Message == "Fant ikke arbeidslaget med id 123");
}
public CrewsViewModel(INavigationService navigationService)
{
_crewService = new CrewService();
_navigationService = navigationService;
NewCrew = new RelayCommand(New);
AddCrew = new RelayCommand(Create);
UpdateCrew = new RelayCommand(Update);
DeleteCrew = new RelayCommand(Delete);
LoadCrews().ConfigureAwait(false);
Crew = new Crew();
}
public CrewsViewModel(INavigationService navigationService)
{
Crewservice = new CrewService();
navService = navigationService;
RefreshEntity = new RelayCommand(Refresh);
AddEntity = new RelayCommand(Create);
UpdateEntity = new RelayCommand(Update);
DeleteEntity = new RelayCommand(Delete);
LoadEntity().ConfigureAwait(false);
Crew = new Crew();
}
public async Task ShouldNotCreateCrewIfNameAlreadyUsed()
{
CrewService crewService = new CrewService(_dbContext, _mainEventProvider);
CrewController crewController = new CrewController(crewService);
await CreateCrew(_crewName2);
var ex = Assert.ThrowsAsync <HttpException>(async() =>
{
ActionResult <CrewVm> result = await CreateCrew(_crewName2);
});
Assert.That(ex.Message == "Arbeidslaget: Test Crew 2 eksisterer allerede");
}
public void Create_WhenDtoIsEmpty_ThenThrowValidExeption()
{
// Arrange
var dto = new CrewDto()
{
};
var service = new CrewService(unitOfWorkFake, mapper, validator);
// Act
// Assert
Assert.Throws <ValidationException>(() => service.Create(dto));
}
