public async Task PutSeason_WhenSeasonIsNotFound_ShouldReturnNotFoundResult()
{
// Arrange
var seasonRepository = A.Fake <ISeasonRepository>();
Season?season = null;
A.CallTo(() => seasonRepository.GetSeasonAsync(A <int> .Ignored)).Returns(season);
var sharedRepository = A.Fake <ISharedRepository>();
var mapper = A.Fake <IMapper>();
var linkGenerator = A.Fake <LinkGenerator>();
var testController = new SeasonsController(seasonRepository, sharedRepository, mapper, linkGenerator);
int id = 1;
var model = new SeasonModel();
// Act
var result = await testController.PutSeason(id, model);
// Assert
A.CallTo(() => seasonRepository.GetSeasonAsync(id)).MustHaveHappenedOnceExactly();
result.Result.ShouldBeOfType <NotFoundObjectResult>();
((NotFoundObjectResult)result.Result).Value.ShouldBe($"Could not find season with ID of {id}");
}
public async Task GetSeason_WhenSeasonIsNotNull_ShouldReturnSeasonModelOfDesiredSeason()
{
// Arrange
var seasonRepository = A.Fake <ISeasonRepository>();
Season?season = new Season();
A.CallTo(() => seasonRepository.GetSeasonAsync(A <int> .Ignored)).Returns(season);
var sharedRepository = A.Fake <ISharedRepository>();
var mapper = A.Fake <IMapper>();
SeasonModel?seasonModel = new SeasonModel();
A.CallTo(() => mapper.Map <SeasonModel>(A <Season> .Ignored)).Returns(seasonModel);
var linkGenerator = A.Fake <LinkGenerator>();
var testController = new SeasonsController(seasonRepository, sharedRepository, mapper, linkGenerator);
int id = 1;
// Act
var result = await testController.GetSeason(id);
// Assert
A.CallTo(() => seasonRepository.GetSeasonAsync(id)).MustHaveHappenedOnceExactly();
A.CallTo(() => mapper.Map <SeasonModel>(season)).MustHaveHappenedOnceExactly();
result.Value.ShouldBeOfType <SeasonModel>();
}
public async Task EditPost_WhenIdEqualsSeasonIdAndModelStateIsValidAndDbUpdateConcurrencyExceptionIsCaughtAndSeasonWithIdExists_ShouldRethrowException()
{
// Arrange
var seasonsIndexViewModel = A.Fake <ISeasonsIndexViewModel>();
var seasonsDetailsViewModel = A.Fake <ISeasonsDetailsViewModel>();
var seasonRepository = A.Fake <ISeasonRepository>();
A.CallTo(() => seasonRepository.Update(A <Season> .Ignored)).Throws <DbUpdateConcurrencyException>();
A.CallTo(() => seasonRepository.SeasonExists(A <int> .Ignored)).Returns(true);
var sharedRepository = A.Fake <ISharedRepository>();
var testController = new SeasonsController(seasonsIndexViewModel, seasonsDetailsViewModel,
seasonRepository, sharedRepository);
int id = 1;
var season = new Season
{
ID = 1
};
// Act
var func = new Func <Task <IActionResult> >(async() => await testController.Edit(id, season));
// Assert
await func.ShouldThrowAsync <DbUpdateConcurrencyException>();
}
public async Task EditPost_WhenIdEqualsSeasonIdAndModelStateIsNotValid_ShouldReturnSeasonEditView()
{
// Arrange
var seasonsIndexViewModel = A.Fake <ISeasonsIndexViewModel>();
var seasonsDetailsViewModel = A.Fake <ISeasonsDetailsViewModel>();
var seasonRepository = A.Fake <ISeasonRepository>();
var sharedRepository = A.Fake <ISharedRepository>();
var testController = new SeasonsController(seasonsIndexViewModel, seasonsDetailsViewModel,
seasonRepository, sharedRepository);
int id = 1;
var season = new Season
{
ID = 1
};
testController.ModelState.AddModelError("LongName", "Please enter a long name.");
// Act
var result = await testController.Edit(id, season);
// Assert
A.CallTo(() => seasonRepository.Update(A <Season> .Ignored)).MustNotHaveHappened();
A.CallTo(() => sharedRepository.SaveChangesAsync()).MustNotHaveHappened();
result.ShouldBeOfType <ViewResult>();
((ViewResult)result).Model.ShouldBe(season);
}
public async Task EditPost_WhenIdEqualsSeasonIdAndModelStateIsValidAndDbUpdateConcurrencyExceptionIsNotCaught_ShouldUpdateSeasonInDataStoreAndRedirectToIndexView()
{
// Arrange
var seasonsIndexViewModel = A.Fake <ISeasonsIndexViewModel>();
var seasonsDetailsViewModel = A.Fake <ISeasonsDetailsViewModel>();
var seasonRepository = A.Fake <ISeasonRepository>();
var sharedRepository = A.Fake <ISharedRepository>();
var testController = new SeasonsController(seasonsIndexViewModel, seasonsDetailsViewModel,
seasonRepository, sharedRepository);
int id = 1;
var season = new Season
{
ID = 1
};
// Act
var result = await testController.Edit(id, season);
// Assert
A.CallTo(() => seasonRepository.Update(season)).MustHaveHappenedOnceExactly();
A.CallTo(() => sharedRepository.SaveChangesAsync()).MustHaveHappenedOnceExactly();
result.ShouldBeOfType <RedirectToActionResult>();
((RedirectToActionResult)result).ActionName.ShouldBe <string>(nameof(testController.Index));
}
public async Task EditPost_WhenIdEqualsSeasonIdAndModelStateIsValidAndDbUpdateConcurrencyExceptionIsCaughtAndSeasonWithIdDoesNotExist_ShouldReturnNotFound()
{
// Arrange
var seasonsIndexViewModel = A.Fake <ISeasonsIndexViewModel>();
var seasonsDetailsViewModel = A.Fake <ISeasonsDetailsViewModel>();
var seasonRepository = A.Fake <ISeasonRepository>();
A.CallTo(() => seasonRepository.Update(A <Season> .Ignored)).Throws <DbUpdateConcurrencyException>();
A.CallTo(() => seasonRepository.SeasonExists(A <int> .Ignored)).Returns(false);
var sharedRepository = A.Fake <ISharedRepository>();
var testController = new SeasonsController(seasonsIndexViewModel, seasonsDetailsViewModel,
seasonRepository, sharedRepository);
int id = 1;
var season = new Season
{
ID = 1
};
// Act
var result = await testController.Edit(id, season);
// Assert
result.ShouldBeOfType <NotFoundResult>();
}
public async Task PutSeason_WhenSeasonIsFoundAndSaved_ShouldReturnModelOfSeason()
{
// Arrange
var seasonRepository = A.Fake <ISeasonRepository>();
Season?season = new Season();
A.CallTo(() => seasonRepository.GetSeasonAsync(A <int> .Ignored)).Returns(season);
var sharedRepository = A.Fake <ISharedRepository>();
A.CallTo(() => sharedRepository.SaveChangesAsync()).Returns(1);
var mapper = A.Fake <IMapper>();
var returnModel = new SeasonModel();
A.CallTo(() => mapper.Map <SeasonModel>(season)).Returns(returnModel);
var linkGenerator = A.Fake <LinkGenerator>();
var testController = new SeasonsController(seasonRepository, sharedRepository, mapper, linkGenerator);
int id = 1;
var model = new SeasonModel();
// Act
var result = await testController.PutSeason(id, model);
// Assert
A.CallTo(() => seasonRepository.GetSeasonAsync(id)).MustHaveHappenedOnceExactly();
A.CallTo(() => mapper.Map(model, season)).MustHaveHappenedOnceExactly();
A.CallTo(() => sharedRepository.SaveChangesAsync()).MustHaveHappenedOnceExactly();
A.CallTo(() => mapper.Map <SeasonModel>(season)).MustHaveHappenedOnceExactly();
result.Value.ShouldBe(returnModel);
}
public async Task DeleteSeason_WhenSeasonIsFoundAndNotDeleted_ShouldReturnBadRequest()
{
// Arrange
var seasonRepository = A.Fake <ISeasonRepository>();
Season?season = new Season();
A.CallTo(() => seasonRepository.GetSeasonAsync(A <int> .Ignored)).Returns(season);
var sharedRepository = A.Fake <ISharedRepository>();
A.CallTo(() => sharedRepository.SaveChangesAsync()).Returns(0);
var mapper = A.Fake <IMapper>();
var linkGenerator = A.Fake <LinkGenerator>();
var testController = new SeasonsController(seasonRepository, sharedRepository, mapper, linkGenerator);
int id = 1;
// Act
var result = await testController.DeleteSeason(id);
// Assert
A.CallTo(() => seasonRepository.GetSeasonAsync(id)).MustHaveHappenedOnceExactly();
A.CallTo(() => sharedRepository.SaveChangesAsync()).MustHaveHappenedOnceExactly();
result.Result.ShouldBeOfType <BadRequestResult>();
}
public async Task GetSeason_WhenExceptionIsCaught_ShouldReturnInternalServerError()
{
// Arrange
var seasonRepository = A.Fake <ISeasonRepository>();
Season?season = new Season();
A.CallTo(() => seasonRepository.GetSeasonAsync(A <int> .Ignored)).Throws <Exception>();
var sharedRepository = A.Fake <ISharedRepository>();
var mapper = A.Fake <IMapper>();
SeasonModel?seasonModel = new SeasonModel();
A.CallTo(() => mapper.Map <SeasonModel>(A <Season> .Ignored)).Returns(seasonModel);
var linkGenerator = A.Fake <LinkGenerator>();
var testController = new SeasonsController(seasonRepository, sharedRepository, mapper, linkGenerator);
int id = 1;
// Act
var result = await testController.GetSeason(id);
// Assert
result.Result.ShouldBeOfType <ObjectResult>();
((ObjectResult)result.Result).StatusCode.ShouldBe(StatusCodes.Status500InternalServerError);
((ObjectResult)result.Result).Value.ShouldBe("Database failure");
}
public async Task Details_WhenIdIsNotNullAndSeasonFound_ShouldReturnSeasonDetailsView()
{
// Arrange
var seasonsIndexViewModel = A.Fake <ISeasonsIndexViewModel>();
var seasonsDetailsViewModel = A.Fake <ISeasonsDetailsViewModel>();
var seasonRepository = A.Fake <ISeasonRepository>();
Season?season = new Season();
A.CallTo(() => seasonRepository.GetSeasonAsync(A <int> .Ignored)).Returns(season);
var sharedRepository = A.Fake <ISharedRepository>();
var testController = new SeasonsController(seasonsIndexViewModel, seasonsDetailsViewModel,
seasonRepository, sharedRepository);
int?id = 0;
// Act
var result = await testController.Details(id);
// Assert
seasonsDetailsViewModel.Title.ShouldBe <string>("Season");
A.CallTo(() => seasonRepository.GetSeasonAsync(id.Value)).MustHaveHappenedOnceExactly();
seasonsDetailsViewModel.Season.ShouldBe(season);
result.ShouldBeOfType <ViewResult>();
((ViewResult)result).Model.ShouldBe(seasonsDetailsViewModel);
}
public async void 年度一覧の表示()
{
// Arrange
var mockUseCase = new Mock <ISeasonUseCase>();
var seasons = new List <Season>
{
new Season(
"2020年度",
new DateTime(2020, 4, 1),
new DateTime(2021, 3, 31),
new DateTime(2020, 3, 31),
new TeamRegistrationFee(5000),
new PlayerRegistrationFee(500),
new PlayerTradeFee(200)
),
new Season(
"2021年度",
new DateTime(2021, 4, 1),
new DateTime(2022, 3, 31),
new DateTime(2021, 3, 31),
new TeamRegistrationFee(5000),
new PlayerRegistrationFee(500),
new PlayerTradeFee(200)
),
new Season(
"2022年度",
new DateTime(2022, 4, 1),
new DateTime(2023, 3, 31),
new DateTime(2022, 3, 31),
new TeamRegistrationFee(5000),
new PlayerRegistrationFee(500),
new PlayerTradeFee(200)
),
new Season(
"2023年度",
new DateTime(2023, 4, 1),
new DateTime(2024, 3, 31),
new DateTime(2023, 3, 31),
new TeamRegistrationFee(5000),
new PlayerRegistrationFee(500),
new PlayerTradeFee(200)
)
};
mockUseCase.Setup(m => m.GetSeasons())
.ReturnsAsync(seasons)
.Verifiable();
var controller = new SeasonsController(mockUseCase.Object);
// Act
var result = await controller.Index();
// Assert
mockUseCase.Verify();
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <IndexViewModel>(viewResult.ViewData.Model);
Assert.Equal(4, model.Seasons.Count);
}
public void SetUp()
{
var mapperConfig = new MapperConfiguration(cfg => cfg.AddProfile(new AutoMapperProfiles()));
var mapper = mapperConfig.CreateMapper();
_seasonService = new Mock <ISeasonService>();
_seasonsController = new SeasonsController(mapper, _seasonService.Object);
}
public async void 年度を登録する()
{
// Arrange
var id = 100000;
var viewModel = new EditViewModel(
id,
"2020年度",
new DateTime(2020, 4, 1),
new DateTime(2021, 3, 31),
new DateTime(2020, 3, 31),
5000,
500,
200);
var season = new Season(
"2020年度",
new DateTime(2020, 4, 1),
new DateTime(2021, 3, 31),
new DateTime(2020, 3, 31),
new TeamRegistrationFee(5000),
new PlayerRegistrationFee(500),
new PlayerTradeFee(200))
{
Id = id
};
var mockUseCase = new Mock <ISeasonUseCase>();
mockUseCase.Setup(m => m.UpdateSeason(id, new DateTime(2020, 4, 1), new DateTime(2021, 3, 31), new DateTime(2020, 3, 31), 5000, 500, 200))
.ReturnsAsync(season)
.Verifiable();
var controller = new SeasonsController(mockUseCase.Object);
// Act
var result = await controller.Edit(viewModel);
// Assert
mockUseCase.Verify();
var viewResulut = Assert.IsType <ViewResult>(result);
Assert.Null(viewResulut.ViewName);
var model = Assert.IsType <EditViewModel>(viewResulut.Model);
Assert.Equal(id, model.SeasonId);
Assert.Equal(viewModel.SeasonName, model.SeasonName);
Assert.Equal(viewModel.FromDate, model.FromDate);
Assert.Equal(viewModel.ToDate, model.ToDate);
Assert.Equal(viewModel.RegistrationFromDate, model.RegistrationFromDate);
Assert.Equal(viewModel.TeamRegistrationFee, model.TeamRegistrationFee);
Assert.Equal(viewModel.PlayerRegistrationFee, model.PlayerRegistrationFee);
Assert.Equal(viewModel.PlayerTradeFee, model.PlayerTradeFee);
}
public void 年度新規登録画面を表示()
{
// Arrange
var mockUseCase = new Mock <ISeasonUseCase>();
var controller = new SeasonsController(mockUseCase.Object);
// Act
var result = controller.Register();
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
Assert.IsAssignableFrom <RegisterViewModel>(viewResult.ViewData.Model);
}
public void CreateGet_ShouldReturnSeasonCreateView()
{
// Arrange
var seasonsIndexViewModel = A.Fake <ISeasonsIndexViewModel>();
var seasonsDetailsViewModel = A.Fake <ISeasonsDetailsViewModel>();
var seasonRepository = A.Fake <ISeasonRepository>();
var sharedRepository = A.Fake <ISharedRepository>();
var testController = new SeasonsController(seasonsIndexViewModel, seasonsDetailsViewModel,
seasonRepository, sharedRepository);
// Act
var result = testController.Create();
// Assert
result.ShouldBeOfType <ViewResult>();
}
public async Task Details_WhenIdIsNull_ShouldReturnNotFound()
{
// Arrange
var seasonsIndexViewModel = A.Fake <ISeasonsIndexViewModel>();
var seasonsDetailsViewModel = A.Fake <ISeasonsDetailsViewModel>();
var seasonRepository = A.Fake <ISeasonRepository>();
var sharedRepository = A.Fake <ISharedRepository>();
var testController = new SeasonsController(seasonsIndexViewModel, seasonsDetailsViewModel,
seasonRepository, sharedRepository);
int?id = null;
// Act
var result = await testController.Details(id);
// Assert
result.ShouldBeOfType <NotFoundResult>();
}
public async Task DeleteConfirmed_ShouldDeleteSeasonFromDataStoreAndRedirectToIndexView()
{
// Arrange
var seasonsIndexViewModel = A.Fake <ISeasonsIndexViewModel>();
var seasonsDetailsViewModel = A.Fake <ISeasonsDetailsViewModel>();
var seasonRepository = A.Fake <ISeasonRepository>();
var sharedRepository = A.Fake <ISharedRepository>();
var testController = new SeasonsController(seasonsIndexViewModel, seasonsDetailsViewModel,
seasonRepository, sharedRepository);
int id = 1;
// Act
var result = await testController.DeleteConfirmed(id);
// Assert
A.CallTo(() => seasonRepository.DeleteAsync(id)).MustHaveHappenedOnceExactly();
A.CallTo(() => sharedRepository.SaveChangesAsync()).MustHaveHappenedOnceExactly();
result.ShouldBeOfType <RedirectToActionResult>();
((RedirectToActionResult)result).ActionName.ShouldBe <string>(nameof(testController.Index));
}
public async Task CreatePost_WhenModelStateIsValid_ShouldAddSeasonToDataStoreAndRedirectToIndexView()
{
// Arrange
var seasonsIndexViewModel = A.Fake <ISeasonsIndexViewModel>();
var seasonsDetailsViewModel = A.Fake <ISeasonsDetailsViewModel>();
var seasonRepository = A.Fake <ISeasonRepository>();
var sharedRepository = A.Fake <ISharedRepository>();
var testController = new SeasonsController(seasonsIndexViewModel, seasonsDetailsViewModel,
seasonRepository, sharedRepository);
var season = new Season();
// Act
var result = await testController.Create(season);
// Assert
A.CallTo(() => seasonRepository.AddAsync(season)).MustHaveHappenedOnceExactly();
A.CallTo(() => sharedRepository.SaveChangesAsync()).MustHaveHappenedOnceExactly();
result.ShouldBeOfType <RedirectToActionResult>();
((RedirectToActionResult)result).ActionName.ShouldBe <string>(nameof(testController.Index));
}
public async void 年度を登録()
{
// Arrange
var viewModel = new RegisterViewModel()
{
SeasonName = "2020年度",
FromDate = new DateTime(2020, 4, 1),
ToDate = new DateTime(2021, 3, 31),
RegistrationFromDate = new DateTime(2020, 3, 31),
TeamRegistrationFee = 5000,
PlayerRegistrationFee = 500,
PlayerTradeFee = 200
};
var season = new Season(
"2020年度",
new DateTime(2020, 4, 1),
new DateTime(2021, 3, 31),
new DateTime(2020, 3, 31),
new TeamRegistrationFee(5000),
new PlayerRegistrationFee(500),
new PlayerTradeFee(200));
var mockUseCase = new Mock <ISeasonUseCase>();
mockUseCase.Setup(m => m.RegisterSeason("2020年度", new DateTime(2020, 4, 1), new DateTime(2021, 3, 31), new DateTime(2020, 3, 31), 5000, 500, 200))
.ReturnsAsync(season)
.Verifiable();
var controller = new SeasonsController(mockUseCase.Object);
// Act
var result = await controller.Register(viewModel);
// Assert
mockUseCase.Verify();
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Null(redirectToActionResult.ControllerName);
Assert.Equal(nameof(controller.Edit), redirectToActionResult.ActionName);
}
public async Task EditPost_WhenIdDoesNotEqualSeasonId_ShouldReturnNotFound()
{
// Arrange
var seasonsIndexViewModel = A.Fake <ISeasonsIndexViewModel>();
var seasonsDetailsViewModel = A.Fake <ISeasonsDetailsViewModel>();
var seasonRepository = A.Fake <ISeasonRepository>();
var sharedRepository = A.Fake <ISharedRepository>();
var testController = new SeasonsController(seasonsIndexViewModel, seasonsDetailsViewModel,
seasonRepository, sharedRepository);
int id = 0;
var season = new Season
{
ID = 1
};
// Act
var result = await testController.Edit(id, season);
// Assert
result.ShouldBeOfType <NotFoundResult>();
}
public async Task CreatePost_WhenModelStateIsNotValid_ShouldReturnSeasonCreateView()
{
// Arrange
var seasonsIndexViewModel = A.Fake <ISeasonsIndexViewModel>();
var seasonsDetailsViewModel = A.Fake <ISeasonsDetailsViewModel>();
var seasonRepository = A.Fake <ISeasonRepository>();
var sharedRepository = A.Fake <ISharedRepository>();
var testController = new SeasonsController(seasonsIndexViewModel, seasonsDetailsViewModel,
seasonRepository, sharedRepository);
var season = new Season();
testController.ModelState.AddModelError("Year", "Please enter a year.");
// Act
var result = await testController.Create(season);
// Assert
A.CallTo(() => seasonRepository.AddAsync(season)).MustNotHaveHappened();
A.CallTo(() => sharedRepository.SaveChangesAsync()).MustNotHaveHappened();
result.ShouldBeOfType <ViewResult>();
((ViewResult)result).Model.ShouldBe(season);
}
public async Task GetSeasons_WhenNoExceptionIsCaught_ShouldGetSeasons()
{
// Arrange
var seasonRepository = A.Fake <ISeasonRepository>();
var seasons = new List <Season>();
A.CallTo(() => seasonRepository.GetSeasonsAsync()).Returns(seasons);
var sharedRepository = A.Fake <ISharedRepository>();
var mapper = A.Fake <IMapper>();
var linkGenerator = A.Fake <LinkGenerator>();
var testController = new SeasonsController(seasonRepository, sharedRepository, mapper, linkGenerator);
// Act
var result = await testController.GetSeasons();
// Assert
A.CallTo(() => seasonRepository.GetSeasonsAsync()).MustHaveHappenedOnceExactly();
A.CallTo(() => mapper.Map <SeasonModel[]>(seasons)).MustHaveHappenedOnceExactly();
result.ShouldBeOfType <ActionResult <SeasonModel[]> >();
result.Value.ShouldBe(mapper.Map <SeasonModel[]>(seasons));
}
public async Task Index_ShouldReturnSeasonsIndexView()
{
// Arrange
var seasonsIndexViewModel = A.Fake <ISeasonsIndexViewModel>();
var seasonsDetailsViewModel = A.Fake <ISeasonsDetailsViewModel>();
var seasonRepository = A.Fake <ISeasonRepository>();
var seasons = new List <Season>();
A.CallTo(() => seasonRepository.GetSeasonsAsync()).Returns(seasons);
var sharedRepository = A.Fake <ISharedRepository>();
var testController = new SeasonsController(seasonsIndexViewModel, seasonsDetailsViewModel,
seasonRepository, sharedRepository);
// Act
var result = await testController.Index();
// Assert
A.CallTo(() => seasonRepository.GetSeasonsAsync()).MustHaveHappenedOnceExactly();
seasonsIndexViewModel.Seasons.ShouldBe(seasons);
result.ShouldBeOfType <ViewResult>();
((ViewResult)result).Model.ShouldBe(seasonsIndexViewModel);
}
public async Task Delete_WhenIdIsNotNullAndSeasonNotFound_ShouldReturnNotFound()
{
// Arrange
var seasonsIndexViewModel = A.Fake <ISeasonsIndexViewModel>();
var seasonsDetailsViewModel = A.Fake <ISeasonsDetailsViewModel>();
var seasonRepository = A.Fake <ISeasonRepository>();
Season?season = null;
A.CallTo(() => seasonRepository.GetSeasonAsync(A <int> .Ignored)).Returns(season);
var sharedRepository = A.Fake <ISharedRepository>();
var testController = new SeasonsController(seasonsIndexViewModel, seasonsDetailsViewModel,
seasonRepository, sharedRepository);
int?id = 0;
// Act
var result = await testController.Delete(id);
// Assert
A.CallTo(() => seasonRepository.GetSeasonAsync(id.Value)).MustHaveHappenedOnceExactly();
result.ShouldBeOfType <NotFoundResult>();
}
public async void 年度更新時無効な値の場合再表示する()
{
// Arrange
var viewModel = new EditViewModel(
100000,
"2020年度",
new DateTime(2020, 4, 1),
new DateTime(2021, 3, 31),
new DateTime(2020, 3, 31),
5000,
500,
200);
var mockUseCase = new Mock <ISeasonUseCase>();
var controller = new SeasonsController(mockUseCase.Object);
controller.ModelState.AddModelError("error", "some error");
// Act
var result = await controller.Edit(viewModel);
// Arrange
var viewResult = Assert.IsType <ViewResult>(result);
Assert.Null(viewResult.ViewName);
var model = Assert.IsType <EditViewModel>(viewResult.ViewData.Model);
Assert.Equal(viewModel.SeasonId, model.SeasonId);
Assert.Equal(viewModel.SeasonName, model.SeasonName);
Assert.Equal(viewModel.FromDate, model.FromDate);
Assert.Equal(viewModel.ToDate, model.ToDate);
Assert.Equal(viewModel.RegistrationFromDate, model.RegistrationFromDate);
Assert.Equal(viewModel.TeamRegistrationFee, model.TeamRegistrationFee);
Assert.Equal(viewModel.PlayerRegistrationFee, model.PlayerRegistrationFee);
Assert.Equal(viewModel.PlayerTradeFee, model.PlayerTradeFee);
}
