public static void ValidateAuditoriumDoesNotExist(byte number, int cinemaId, string cinemaName)
{
if (AuditoriumService.IsAuditoriumExisting(number, cinemaId))
{
throw new InvalidOperationException(string.Format(Constants.ErrorMessages.AuditoriumAlreadyExists, number, cinemaName));
}
}
public static void CheckAuditoriumExists(byte number, int cinemaId, string cinemaName)
{
if (!AuditoriumService.IsAuditoriumExisting(number, cinemaId))
{
throw new InvalidOperationException(string.Format(Constants.ErrorMessages.AuditoriumDoesntExist, number, cinemaName));
}
}
public void AuditoriumsService_CreateAuditorium_ReturnCreateAuditoriumResultModel_AuditoriumWithSameNameExists()
{
//Arrange
CreateAuditoriumResultModel expectedResultModel = new CreateAuditoriumResultModel()
{
ErrorMessage = "Cannot create new auditorium, auditorium with same name already exist.",
IsSuccessful = false
};
IEnumerable <Auditorium> auditoriums = _listOFAuditoriums;
AuditoriumDomainModel auditoriumDomainModel = _auditoriumDomainModel;
var numberOfSeatsPerRow = 2;
var numberOfRows = 2;
Data.Cinema cinema = _cinema;
Task <Data.Cinema> responseTaskCinemasRepository = Task.FromResult(cinema);
_mockCinemasRepository = new Mock <ICinemasRepository>();
_mockCinemasRepository.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(responseTaskCinemasRepository);
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
Task <IEnumerable <Auditorium> > responseTaskAuditoriumsRepository = Task.FromResult(auditoriums);
_mockAuditoriumsRepository.Setup(x => x.GetByAuditName(auditoriumDomainModel.Name, cinema.Id)).Returns(responseTaskAuditoriumsRepository);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.CreateAuditorium(_auditoriumDomainModel, numberOfRows, numberOfSeatsPerRow).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(resultAction);
Assert.AreEqual(expectedResultModel.ErrorMessage, resultAction.ErrorMessage);
Assert.IsFalse(resultAction.IsSuccessful);
Assert.IsInstanceOfType(resultAction, typeof(CreateAuditoriumResultModel));
}
public void TestInitialize()
{
_auditorium = new Auditorium
{
Id = 1,
CinemaId = 1,
AuditName = "Novi auditorium",
};
_auditoriumDomainModel = new AuditoriumDomainModel
{
Id = _auditorium.Id,
CinemaId = _auditorium.CinemaId,
Name = _auditorium.AuditName
};
_cinema = new Data.Cinema
{
Id = 1,
CityId = 1,
Name = "test bioskop 1"
};
_cinemaDomainModel = new CinemaDomainModel
{
Id = _cinema.Id,
CityId = _cinema.CityId,
Name = _cinema.Name
};
_mockAuditoriumRepository = new Mock <IAuditoriumsRepository>();
_mockCinemaRepository = new Mock <ICinemasRepository>();
_auditoriumService = new AuditoriumService(_mockAuditoriumRepository.Object, _mockCinemaRepository.Object);
}
private void AddScreeningForm_Load(object sender, EventArgs e)
{
DateCalendar.MinDate = DateTime.Now;
this.ScreeningTaken.Visible = false;
movieComboBox.Items.AddRange(MovieService.GetAllMovies().Select(m => m.Name + "," + m.ReleaseYear).ToArray());
auditoriumComboBox.Items.AddRange(AuditoriumService.GetAudtitoriums(cinema.Id).Select(a => a.Number.ToString()).ToArray());
}
private static void ImportAuditorium(AuditoriumDTO auditoriumDto)
{
string cinemaName = auditoriumDto.CinemaName;
InputDataValidator.ValidateStringMaxLength(cinemaName, Constants.MaxCinemaNameLength);
string townName = auditoriumDto.CinemaTownName;
TownValidator.CheckTownExisting(townName);
int townId = TownService.GetTownId(townName);
int cinemaId = CinemaService.GetCinemaId(cinemaName, townId);
CinemaValidator.CheckCinemaExisting(cinemaName, townId);
byte number = auditoriumDto.Number;
AuditoriumValidator.ValidateAuditoriumDoesNotExist(number, cinemaId, cinemaName);
AuditoriumService.AddAuditorium(number, cinemaId);
Console.WriteLine(string.Format(Constants.ImportSuccessMessages.AuditoriumAddedSuccess, number, cinemaName, townName));
}
public void AuditoriumService_UpdateAuditorium_Returns_AuditoriumResultModel_AuditoriumUpdateError()
{
//Arrange
AuditoriumResultModel expectedResultModel = new AuditoriumResultModel()
{
ErrorMessage = "Error happened when auditorium was updating. "
};
AuditoriumDomainModel auditoriumDomainModel = _auditoriumDomainModel;
Auditorium auditorium = null;
IEnumerable <Projection> projections = null;
IEnumerable <Seat> seats = null;
_mockProjectionRepository = new Mock <IProjectionsRepository>();
_mockProjectionRepository.Setup(x => x.GetAllOfSpecificAuditorium(It.IsAny <int>())).Returns(projections);
_mockSeatsRepository = new Mock <ISeatsRepository>();
_mockSeatsRepository.Setup(x => x.GetAllOfSpecificAuditorium(It.IsAny <int>())).Returns(seats);
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
_mockAuditoriumsRepository.Setup(x => x.Update(It.IsAny <Auditorium>())).Returns(auditorium);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.UpdateAuditorium(auditoriumDomainModel).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(resultAction);
Assert.IsFalse(resultAction.IsSuccessful);
Assert.AreEqual(expectedResultModel.ErrorMessage, resultAction.ErrorMessage);
Assert.IsInstanceOfType(resultAction, typeof(AuditoriumResultModel));
}
private static void ImportSeat(SeatDto seatDto)
{
string cinemaTown = seatDto.CinemaTown;
TownValidator.CheckTownExisting(cinemaTown);
int townId = TownService.GetTownId(cinemaTown);
string cinemaName = seatDto.CinemaName;
CinemaValidator.CheckCinemaExisting(cinemaName, townId);
int cinemaId = CinemaService.GetCinemaId(cinemaName, townId);
byte auditoriumNumber = seatDto.AuditoriumNumber;
AuditoriumValidator.CheckAuditoriumExists(auditoriumNumber, cinemaId, cinemaName);
int auditoriumId = AuditoriumService.GetAuditoriumId(auditoriumNumber, cinemaId);
int row = seatDto.Row;
int number = seatDto.Number;
SeatValidator.ValidateSeatDoesntExist(number, auditoriumId, auditoriumNumber);
SeatService.AddSeat(number, row, auditoriumId);
Console.WriteLine(string.Format(Constants.ImportSuccessMessages.SeatAddedSuccess, number, auditoriumNumber, cinemaName, cinemaTown));
}
public void AuditoriumsService_CreateAuditorium_ReturnCreateAuditoriumResultModel_Successful()
{
IEnumerable <Auditorium> auditoriums = _listOFAuditoriums;
AuditoriumDomainModel auditoriumDomainModel = _auditoriumDomainModel;
Auditorium auditorium = _auditorium;
Auditorium newAuditorium = _newAuditorium;
var numberOfSeatsPerRow = 1;
var numberOfRows = 1;
Data.Cinema cinema = _cinema;
Task <Data.Cinema> responseTaskCinemasRepository = Task.FromResult(cinema);
_mockCinemasRepository = new Mock <ICinemasRepository>();
_mockCinemasRepository.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(responseTaskCinemasRepository);
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
Task <IEnumerable <Auditorium> > responseTaskAuditoriumsRepository = Task.FromResult(auditoriums);
_mockAuditoriumsRepository.Setup(x => x.GetByAuditName(auditoriumDomainModel.Name, cinema.Id)).Returns(responseTaskAuditoriumsRepository);
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
_mockAuditoriumsRepository.Setup(x => x.Insert(It.IsAny <Auditorium>())).Returns(newAuditorium);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.CreateAuditorium(_auditoriumDomainModel, numberOfRows, numberOfSeatsPerRow).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(resultAction);
Assert.IsNull(resultAction.ErrorMessage);
Assert.IsTrue(resultAction.IsSuccessful);
Assert.IsInstanceOfType(resultAction, typeof(CreateAuditoriumResultModel));
Assert.AreEqual(1, resultAction.Auditorium.Id);
}
public static void ImportScreening(ScreeeningDto screeningDto)
{
byte auditoriumNumber = screeningDto.AuditoriumNumber;
string cinemaTown = screeningDto.CinemaTown;
TownValidator.CheckTownExisting(cinemaTown);
int townId = TownService.GetTownId(cinemaTown);
string cinemaName = screeningDto.CinemaName;
CinemaValidator.CheckCinemaExisting(cinemaName, townId);
int cinemaId = CinemaService.GetCinemaId(cinemaName, townId);
AuditoriumValidator.CheckAuditoriumExists(auditoriumNumber, cinemaId, cinemaName);
string movieName = screeningDto.MovieName;
int movieReleaseYear = screeningDto.MovieReleaseYear;
MovieValidator.CheckMovieExists(movieName, movieReleaseYear);
int auditoriumId = AuditoriumService.GetAuditoriumId(auditoriumNumber, cinemaId);
DateTime date = screeningDto.Date;
ScreeningValidator.ValidateScreeningDoesntExist(auditoriumId, date);
int movieId = MovieService.GetMovieId(movieName, movieReleaseYear);
ScreeningService.AddScreening(auditoriumId, movieId, date);
Console.WriteLine(string.Format(Constants.ImportSuccessMessages.ScreeningAddedSuccess, auditoriumNumber, cinemaName));
}
public void AuditoriumService_DeleteAuditorium_ReturnsDeletedAuditorium_ReturnsDeletedProjectionsAndSeats()
{
//Arrange
List <ProjectionDomainModel> projectionsModelsList = new List <ProjectionDomainModel>();
projectionsModelsList.Add(_projectionDomainModel);
IEnumerable <ProjectionDomainModel> projections = projectionsModelsList;
Task <IEnumerable <ProjectionDomainModel> > projectionsResponseTask = Task.FromResult(projections);
List <SeatDomainModel> seatsModelsList = new List <SeatDomainModel>();
seatsModelsList.Add(_seatDomainModel);
IEnumerable <SeatDomainModel> seats = seatsModelsList;
Task <IEnumerable <SeatDomainModel> > seatsResponseTask = Task.FromResult(seats);
AuditoriumService auditoriumService = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockProjectionService.Object, _mockSeatService.Object);
_mockProjectionService.Setup(x => x.DeleteByAuditoriumId(It.IsAny <int>())).Returns(projectionsResponseTask);
_mockSeatService.Setup(x => x.DeleteByAuditoriumId(It.IsAny <int>())).Returns(seatsResponseTask);
_mockAuditoriumsRepository.Setup(x => x.Delete(It.IsAny <int>())).Returns(_auditorium);
//Act
var result = auditoriumService.DeleteAuditorium(_auditorium.Id).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(AuditoriumDomainModel));
Assert.IsNotNull(result.SeatsList);
Assert.AreEqual(result.Id, _auditorium.Id);
}
private void AddScreeningButton_Click(object sender, EventArgs e)
{
try
{
string movieName = GetMovieName(movieComboBox.Text);
int year = GetMovieYear(movieComboBox.Text);
DateTime getDate = DateCalendar.SelectionRange.Start;
string date = getDate.Day.ToString() + " " + getDate.ToString("MMM") + " " + getDate.DayOfWeek.ToString();
DateTime getTime = TimePicker.Value;
string time = getTime.ToString("hh") + ":" + getTime.ToString("mm") + " " + getTime.ToString("tt", CultureInfo.InvariantCulture);
DateTime startTime = ScreeningService.GetDateTimeFromDateAndTime(date, time);
byte auditoriumNumber = byte.Parse(auditoriumComboBox.Text);
int auditoriumId = AuditoriumService.GetAuditoriumId(auditoriumNumber, this.cinema.Id);
int movieId = MovieService.GetMovieId(movieName, year);
ScreeningValidator.ValidateScreeningTimeAvailable(startTime, auditoriumId, movieName, year);
ScreeningService.AddScreening(auditoriumId, movieId, startTime);
MessageBox.Show("Screening added successfully!");
Cinema cinema = CinemaService.GetCinemaWithScreenings(this.cinema.Id);
SelectScreeningForm screeningsForm = new SelectScreeningForm(cinema);
screeningsForm.TopLevel = false;
screeningsForm.AutoScroll = true;
this.Hide();
((Button)sender).Parent.Parent.Controls.Add(screeningsForm);
screeningsForm.Show();
}
catch (Exception exception)
{
MessageBox.Show("Add screening failed!");
}
}
public void AuditoriumService_DeleteAuditorium_AuditoriumResultModel_PROJECTION_IN_FUTURE()
{
//Arrange
AuditoriumResultModel expectedResultModel = new AuditoriumResultModel()
{
ErrorMessage = "Cannot delete projection as it is scheduled in the future. "
};
Auditorium auditorium = _auditorium;
IEnumerable <Projection> projections = _listOfProjections;
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
Task <Auditorium> responseTask = Task.FromResult(auditorium);
_mockAuditoriumsRepository.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(responseTask);
_mockProjectionRepository = new Mock <IProjectionsRepository>();
_mockProjectionRepository.Setup(x => x.GetAllOfSpecificAuditorium(It.IsAny <int>())).Returns(projections);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.DeleteAuditorium(It.IsAny <int>()).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(resultAction);
Assert.IsFalse(resultAction.IsSuccessful);
Assert.AreEqual(expectedResultModel.ErrorMessage, resultAction.ErrorMessage);
Assert.IsInstanceOfType(resultAction, typeof(AuditoriumResultModel));
}
public void AuditoriumService_DeleteAuditorium_AuditoriumResultModel_Successful()
{
//Arrange
Auditorium auditorium = _auditorium;
IEnumerable <Projection> projections = null;
IEnumerable <Seat> seats = null;
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
Task <Auditorium> responseTaskAuditoriumsRepository = Task.FromResult(auditorium);
_mockAuditoriumsRepository.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(responseTaskAuditoriumsRepository);
_mockProjectionRepository = new Mock <IProjectionsRepository>();
_mockProjectionRepository.Setup(x => x.GetAllOfSpecificAuditorium(It.IsAny <int>())).Returns(projections);
_mockSeatsRepository = new Mock <ISeatsRepository>();
_mockSeatsRepository.Setup(x => x.GetAllOfSpecificAuditorium(It.IsAny <int>())).Returns(seats);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.DeleteAuditorium(It.IsAny <int>()).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(resultAction);
Assert.IsTrue(resultAction.IsSuccessful);
Assert.IsNull(resultAction.ErrorMessage);
Assert.IsInstanceOfType(resultAction, typeof(AuditoriumResultModel));
Assert.AreEqual(auditorium.Name, resultAction.Auditorium.Name);
}
public void AuditoriumService_DeleteAuditoriumByCinemaId_SeatServiceReturnsNull_ReturnsNull()
{
//Arrange
List <Auditorium> auditoriumsModelsList = new List <Auditorium>();
auditoriumsModelsList.Add(_auditorium);
IEnumerable <Auditorium> auditoriums = auditoriumsModelsList;
Task <IEnumerable <Auditorium> > responseTask = Task.FromResult(auditoriums);
int expectedCount = 1;
List <ProjectionDomainModel> projectionsModelsList = new List <ProjectionDomainModel>();
projectionsModelsList.Add(_projectionDomainModel);
IEnumerable <ProjectionDomainModel> projections = projectionsModelsList;
Task <IEnumerable <ProjectionDomainModel> > projectionsResponseTask = Task.FromResult(projections);
IEnumerable <SeatDomainModel> seats = null;
Task <IEnumerable <SeatDomainModel> > seatsResponseTask = Task.FromResult(seats);
AuditoriumService auditoriumService = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockProjectionService.Object, _mockSeatService.Object);
_mockProjectionService.Setup(x => x.DeleteByAuditoriumId(It.IsAny <int>())).Returns(projectionsResponseTask);
_mockSeatService.Setup(x => x.DeleteByAuditoriumId(It.IsAny <int>())).Returns(seatsResponseTask);
_mockAuditoriumsRepository.Setup(x => x.GetByCinemaId(It.IsAny <int>())).Returns(responseTask);
_mockAuditoriumsRepository.Setup(x => x.Delete(It.IsAny <int>())).Returns(_auditorium);
//Act
var result = auditoriumService.DeleteAuditoriumsByCinemaId(_auditorium.CinemaId).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNull(result);
}
public void AuditoriumService_DeleteAuditorium_AuditoriumRepositoryReturnsNull_ReturnsNull()
{
//Arrange
Auditorium nullAuditorium = null;
List <ProjectionDomainModel> projectionsModelsList = new List <ProjectionDomainModel>();
projectionsModelsList.Add(_projectionDomainModel);
IEnumerable <ProjectionDomainModel> projections = projectionsModelsList;
Task <IEnumerable <ProjectionDomainModel> > projectionsResponseTask = Task.FromResult(projections);
List <SeatDomainModel> seatsModelsList = new List <SeatDomainModel>();
seatsModelsList.Add(_seatDomainModel);
IEnumerable <SeatDomainModel> seats = seatsModelsList;
Task <IEnumerable <SeatDomainModel> > seatsResponseTask = Task.FromResult(seats);
AuditoriumService auditoriumService = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockProjectionService.Object, _mockSeatService.Object);
_mockProjectionService.Setup(x => x.DeleteByAuditoriumId(It.IsAny <int>())).Returns(projectionsResponseTask);
_mockSeatService.Setup(x => x.DeleteByAuditoriumId(It.IsAny <int>())).Returns(seatsResponseTask);
_mockAuditoriumsRepository.Setup(x => x.Delete(It.IsAny <int>())).Returns(nullAuditorium);
//Act
var result = auditoriumService.DeleteAuditorium(_auditorium.Id).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNull(result);
}
private void CheckScreeningAvailable()
{
if (movieComboBox.Text == "")
{
return;
}
if (auditoriumComboBox.Text == "")
{
return;
}
string movieName = GetMovieName(movieComboBox.Text);
int year = GetMovieYear(movieComboBox.Text);
DateTime getDate = DateCalendar.SelectionRange.Start;
string date = getDate.Day.ToString() + " " + getDate.ToString("MMM") + " " + getDate.DayOfWeek.ToString();
DateTime getTime = TimePicker.Value;
string time = getTime.ToString("hh") + ":" + getTime.ToString("mm") + " " + getTime.ToString("tt", CultureInfo.InvariantCulture);
DateTime startTime = ScreeningService.GetDateTimeFromDateAndTime(date, time);
byte auditoriumNumber = byte.Parse(auditoriumComboBox.Text);
int auditoriumId = AuditoriumService.GetAuditoriumId(auditoriumNumber, this.cinema.Id);
if (!ScreeningService.IsScreeningAvailableInAuditorium(auditoriumId, startTime, movieName, year))
{
ScreeningTaken.Visible = true;
ScreeningTaken.Text = "Screening is already taken!";
}
else
{
ScreeningTaken.Visible = false;
}
}
public void AuditoriumsService_CreateAuditorium_ReturnCreateAuditoriumResultModel_InvalidCinemaId()
{
//Arrange
CreateAuditoriumResultModel expectedResultModel = new CreateAuditoriumResultModel()
{
ErrorMessage = "Cannot create new auditorium, auditorium with given cinemaId does not exist.",
IsSuccessful = false
};
AuditoriumDomainModel auditoriumDomainModel = _auditoriumDomainModel;
var numberOfSeatsPerRow = 2;
var numberOfRows = 2;
Data.Cinema cinema = null;
Task <Data.Cinema> responseTask = Task.FromResult(cinema);
_mockCinemasRepository = new Mock <ICinemasRepository>();
_mockCinemasRepository.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(responseTask);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.CreateAuditorium(_auditoriumDomainModel, numberOfRows, numberOfSeatsPerRow).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(resultAction);
Assert.AreEqual(expectedResultModel.ErrorMessage, resultAction.ErrorMessage);
Assert.IsFalse(resultAction.IsSuccessful);
Assert.IsInstanceOfType(resultAction, typeof(CreateAuditoriumResultModel));
}
public AuditoriumImportService()
{
this.auditoriumService = new AuditoriumService();
this.auditoriumValidator = new AuditoriumValidator(auditoriumService);
this.cinemaService = new CinemaService();
this.cinemaValidator = new CinemaValidator(cinemaService);
this.townService = new TownService();
this.townValidator = new TownValidator(townService);
}
public AddScreeningForm(Cinema cinema)
{
this.movieService = new MovieService();
this.auditoriumService = new AuditoriumService();
this.cinemaService = new CinemaService();
this.screeningService = new ScreeningService();
this.screeningValidator = new ScreeningValidator(screeningService);
this.cinema = cinema;
InitializeComponent();
}
public ScreeningImportService()
{
this.auditoriumService = new AuditoriumService();
this.cinemaService = new CinemaService();
this.auditoriumValidator = new AuditoriumValidator(auditoriumService);
this.cinemaValidator = new CinemaValidator(cinemaService);
this.movieService = new MovieService();
this.movieValidator = new MovieValidator(movieService);
this.townService = new TownService();
this.townValidator = new TownValidator(townService);
this.screeningService = new ScreeningService();
this.screeningValidator = new ScreeningValidator(screeningService);
}
public void AuditoriumsService_GetAllOfSpecificCinema_ReturnNull()
{
//Arrange
IEnumerable <Auditorium> auditoriums = null;
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
_mockAuditoriumsRepository.Setup(x => x.GetAllOfSpecificCinema(It.IsAny <int>())).Returns(auditoriums);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.GetAllOfSpecificCinema(It.IsAny <int>());
var result = (List <AuditoriumDomainModel>)resultAction;
//Assert
Assert.IsNull(result);
}
public void AuditoriumService_GetByIdAsync_RepositoryReturnsNull_ReturnsNull()
{
//Arrange
Auditorium nullAuditorium = null;
Task <Auditorium> auditorium = Task.FromResult(nullAuditorium);
AuditoriumService auditoriumService = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockProjectionService.Object, _mockSeatService.Object);
_mockAuditoriumsRepository.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(auditorium);
//Act
var result = auditoriumService.GetByIdAsync(_auditorium.Id).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNull(result);
}
public void AuditoriumsService_GetAuditoriumByIdAsync_ReturnNull()
{
//Arrange
Auditorium auditorium = null;
Task <Auditorium> responseTask = Task.FromResult(auditorium);
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
_mockAuditoriumsRepository.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(responseTask);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.GetAuditoriumByIdAsync(It.IsAny <int>()).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNull(resultAction);
}
public void AuditoriumService_GetByIdAsync_ReturnsAuditoriumModel()
{
//Arrange
Task <Auditorium> auditorium = Task.FromResult(_auditorium);
AuditoriumService auditoriumService = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockProjectionService.Object, _mockSeatService.Object);
_mockAuditoriumsRepository.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(auditorium);
//Act
var result = auditoriumService.GetByIdAsync(_auditorium.Id).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(AuditoriumDomainModel));
Assert.AreEqual(result.Id, _auditorium.Id);
}
public void AuditoriumService_GetByCinemaid_RepositoryReturnsNull_ReturnsNull()
{
//Arrange
IEnumerable <Auditorium> auditoriums = null;
Task <IEnumerable <Auditorium> > responseTask = Task.FromResult(auditoriums);
AuditoriumService auditoriumService = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockProjectionService.Object, _mockSeatService.Object);
_mockAuditoriumsRepository.Setup(x => x.GetByCinemaId(It.IsAny <int>())).Returns(responseTask);
//Act
var result = auditoriumService.GetByCinemaId(_auditorium.CinemaId).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNull(result);
}
public void AuditoriumsService_GetAllAsync_ReturnNull()
{
//Arrange
IEnumerable <Auditorium> auditoriums = null;
Task <IEnumerable <Auditorium> > responseTask = Task.FromResult(auditoriums);
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
_mockAuditoriumsRepository.Setup(x => x.GetAll()).Returns(responseTask);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.GetAllAsync().ConfigureAwait(false).GetAwaiter().GetResult();
var result = (List <AuditoriumDomainModel>)resultAction;
//Assert
Assert.IsNull(result);
}
public void AuditoriumsService_GetAuditoriumByIdAsync_ReturnAuditoriumDomainModel()
{
//Arrange
Auditorium auditorium = _auditorium;
Task <Auditorium> responseTask = Task.FromResult(auditorium);
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
_mockAuditoriumsRepository.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(responseTask);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.GetAuditoriumByIdAsync(It.IsAny <int>()).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(resultAction);
Assert.IsInstanceOfType(resultAction, typeof(AuditoriumDomainModel));
Assert.AreEqual(resultAction.CinemaId, auditorium.CinemaId);
}
public void AuditoriumsService_GetAllOfSpecificCinema_ReturnListOfAuditoriumDomainModel()
{
//Arrange
int expectedResultCount = 1;
IEnumerable <Auditorium> auditoriums = _listOFAuditoriums;
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
_mockAuditoriumsRepository.Setup(x => x.GetAllOfSpecificCinema(It.IsAny <int>())).Returns(auditoriums);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.GetAllOfSpecificCinema(It.IsAny <int>());
var result = (List <AuditoriumDomainModel>)resultAction;
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(expectedResultCount, result.Count);
Assert.AreEqual(_auditorium.Id, result[0].Id);
Assert.IsInstanceOfType(result[0], typeof(AuditoriumDomainModel));
}
public void AuditoriumsService_GetAllAsync_ReturnListOfAuditoriumDomainModel()
{
//Arrange
int expectedResultCount = 1;
IEnumerable <Auditorium> auditoriums = _listOFAuditoriums;
Task <IEnumerable <Auditorium> > responseTask = Task.FromResult(auditoriums);
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
_mockAuditoriumsRepository.Setup(x => x.GetAll()).Returns(responseTask);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.GetAllAsync().ConfigureAwait(false).GetAwaiter().GetResult();
var result = (List <AuditoriumDomainModel>)resultAction;
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(expectedResultCount, result.Count);
Assert.AreEqual(_auditorium.Id, result[0].Id);
Assert.IsInstanceOfType(result[0], typeof(AuditoriumDomainModel));
}
