private void SetUpRepository()
{
sportsService = new Mock <ISportService>();
teamsRepo = new Mock <ITeamService>();
Mock <IEncounterRepository> matchesRepo = new Mock <IEncounterRepository>();
Mock <IAuthenticationService> mockService = new Mock <IAuthenticationService>();
Mock <IImageService> mockImgService = new Mock <IImageService>();
SportDto testSport1 = new SportDto()
{
name = "Tennis", isTwoTeams = true
};
SportDto testSport2 = new SportDto()
{
name = "Basketball", isTwoTeams = true
};
sportsService.Setup(s => s.AddSport(It.IsAny <SportDto>())).Returns(testSport1);
sportsService.Setup(r => r.GetSport("Tennis")).Returns(testSport1);
sportsService.Setup(r => r.GetSport(It.Is <String>(x => (x != "Tennis") && (x != "Basketball")))).Throws(new SportNotFoundException());
sportsService.Setup(r => r.GetAllSports()).Returns(new List <SportDto>()
{
testSport1, testSport2
});
IFixtureService dummyService = new Mock <IFixtureService>().Object;
tableGenerator = new Mock <ISportTableService>();
controllerToTest = new SportsController(sportsService.Object, teamsRepo.Object, dummyService,
tableGenerator.Object, mockService.Object, mockImgService.Object);
controllerToTest.ControllerContext = GetFakeControllerContext();
}
private IActionResult TryGet(string name)
{
SportDto retrieved = sports.GetSport(name);
SportModelOut output = CreateModelOut(retrieved);
return(Ok(output));
}
public void ReturnSuccessMessage_WhenInvokedWithValidParameters()
{
// Arrange
var sportscardFactoryMock = new Mock <ISportscardFactory>();
var sportServiceMock = new Mock <ISportService>();
var sportName = "Gym";
var expectedMessage = $"Sport {sportName} was added to database.";
var expectedSport = new SportDto()
{
Name = sportName
};
sportscardFactoryMock
.Setup(x => x.CreateSportDto(sportName))
.Returns(expectedSport);
var addSportCommand = new AddSportCommand(sportscardFactoryMock.Object, sportServiceMock.Object);
var parameters = new List <string>()
{
sportName
};
//Act
var actualMessage = addSportCommand.Execute(parameters);
//Assert
Assert.AreEqual(expectedMessage, actualMessage);
}
public void CallSportAddMethodOnce_WhenInvokedWithValidParameters()
{
// Arrange
var sportscardFactoryMock = new Mock <ISportscardFactory>();
var sportServiceMock = new Mock <ISportService>();
var sportName = "Gym";
var expectedSport = new SportDto()
{
Name = sportName
};
sportscardFactoryMock
.Setup(x => x.CreateSportDto(sportName))
.Returns(expectedSport);
var addSportCommand = new AddSportCommand(sportscardFactoryMock.Object, sportServiceMock.Object);
var parameters = new List <string>()
{
sportName
};
//Act
addSportCommand.Execute(parameters);
//Assert
sportServiceMock.Verify(x => x.AddSport(expectedSport), Times.Once);
}
public bool UpdateSport(SportDto sportDto)
{
if (sportDto == null)
{
GenerateFaultException("UpdateSport", "ArgumentException");
}
var parameters = new List <Parameter>();
parameters.Add(new Parameter {
Type = DbType.Int32, Name = "@SportId", Value = sportDto.SportId
});
parameters.Add(new Parameter {
Type = DbType.String, Name = "@Name", Value = sportDto.Name
});
var connection = new Connection <SportDto>();
try
{
return(connection.GetConnectionUpdate(CommandType.StoredProcedure, "UpdateSport", parameters));
}
catch (SqlException sqlEx)
{
var exception = new CustomException();
exception.Title = "UpdateSport";
log.Error(sqlEx.Message);
throw new FaultException <CustomException>(exception, sqlEx.Message);
}
}
public bool UpdateSport(Sport sport)
{
var sportDto = new SportDto();
sportDto = convert.ToSportDto(sport);
var model = new bool();
using (var client = new ToteService.BetListServiceClient())
{
try
{
client.Open();
model = client.UpdateSport(sportDto);
client.Close();
}
catch (FaultException <CustomException> customEx)
{
log.Error(customEx.Message);
return(false);
}
catch (CommunicationException commEx)
{
log.Error(commEx.Message);
return(false);
}
}
return(model);
}
private SportModelOut CreateModelOut(SportDto aSport)
{
return(new SportModelOut()
{
Name = aSport.name, IsTwoTeams = aSport.isTwoTeams
});
}
public SportDto GetSport(int?id)
{
var model = new SportDto();
using (var client = new ToteService.BetListServiceClient())
{
try
{
client.Open();
model = client.GetSport(id);
client.Close();
if (model == null)
{
throw new NullReferenceException();
}
}
catch (FaultException <CustomException> customEx)
{
log.Error(customEx.Message);
return(null);
}
catch (CommunicationException commEx)
{
log.Error(commEx.Message);
return(null);
}
catch (NullReferenceException nullEx)
{
log.Error(nullEx.Message);
return(null);
}
}
return(model);
}
public async Task <IActionResult> Post([FromBody] SportDto dto)
{
var sport = _mapper.Map <Sport>(dto);
await _sportService.AddAsync(sport);
return(Created("localhost", ""));
}
public void ThrowArgumentNullException_WhenInvokedWithInvalidNullSportNameParameter()
{
// Arrange
var sportscardFactoryMock = new Mock <ISportscardFactory>();
var sportServiceMock = new Mock <ISportService>();
var sportName = "Gym";
var expectedMessage = $"{sportName} sport was added to database.";
var expectedSport = new SportDto()
{
Name = sportName
};
sportscardFactoryMock
.Setup(x => x.CreateSportDto(sportName))
.Returns(expectedSport);
var addSportCommand = new AddSportCommand(sportscardFactoryMock.Object, sportServiceMock.Object);
var parameters = new List <string>()
{
null
};
//Act && Assert
Assert.ThrowsException <ArgumentNullException>(() => addSportCommand.Execute(parameters));
}
// GET: Sport/Details/5
public ActionResult Details(int id)
{
UpdateSport ViewModel = new UpdateSport();
ViewModel.isadmin = User.IsInRole("Admin");
string url = "Sportdata/FindSport/" + id;
HttpResponseMessage response = client.GetAsync(url).Result;
//Can catch the status code (200 OK, 301 REDIRECT), etc.
//Debug.WriteLine(response.StatusCode);
if (response.IsSuccessStatusCode)
{
//Put data into Sport data transfer object
SportDto SelectedSport = response.Content.ReadAsAsync <SportDto>().Result;
ViewModel.sport = SelectedSport;
//find teams that play this sport
url = "SportData/GetTeamsforSport/" + id;
response = client.GetAsync(url).Result;
//Put data into Sport data transfer object
IEnumerable <TeamDto> SelectedTeams = response.Content.ReadAsAsync <IEnumerable <TeamDto> >().Result;
ViewModel.teams = SelectedTeams;
return(View(ViewModel));
}
else
{
return(RedirectToAction("Error"));
}
}
public void ThrowArgumentNullException_WhenThereIsNoSports()
{
//Arrange
var dbContextMock = new Mock <ISportscardSystemDbContext>();
var mapperMock = new Mock <IMapper>();
var sport = new Sport()
{
Id = new Guid("db97a0eb-9411-4f1d-9ead-3997e6271324"),
Name = "Gym",
IsDeleted = false
};
var visit = new Visit()
{
Id = new Guid("db97a0eb-9411-4f1d-9ead-3997e6271325"),
IsDeleted = false,
Sport = sport,
Sportshall = new Sportshall()
{
Name = "Topfit"
},
CreatedOn = DateTime.Now.Date
};
var visits = new List <Visit>();
visits.Add(visit);
sport.Visits = visits;
var data = new List <Sport>
{
};
//data.Add(sport);
var mockSet = new Mock <DbSet <Sport> >();
mockSet.SetupData(data);
dbContextMock
.Setup(x => x.Sports)
.Returns(mockSet.Object);
var expectedSportDto = new SportDto()
{
Id = new Guid("db97a0eb-9411-4f1d-9ead-3997e6271324"),
Name = "Gym"
};
mapperMock
.Setup(x => x.Map <SportDto>(sport))
.Returns(expectedSportDto);
var sportService = new SportService(dbContextMock.Object, mapperMock.Object);
//Act && Assert
Assert.ThrowsException <ArgumentNullException>(() => sportService.GetMostPlayedSport());
}
// GET: Team/Details/5
public ActionResult Details(int id)
{
ShowTeam ViewModel = new ShowTeam();
ViewModel.isadmin = User.IsInRole("Admin");
ViewModel.isfan = User.IsInRole("Fan");
ViewModel.userid = User.Identity.GetUserId();
string url = "teamdata/findteam/" + id;
HttpResponseMessage response = client.GetAsync(url).Result;
//Can catch the status code (200 OK, 301 REDIRECT), etc.
//Debug.WriteLine(response.StatusCode);
if (response.IsSuccessStatusCode)
{
//Put data into Team data transfer object
TeamDto SelectedTeam = response.Content.ReadAsAsync <TeamDto>().Result;
ViewModel.team = SelectedTeam;
//Grab the sport associated with this team
url = "TeamData/FindSportForTeam/" + id;
response = client.GetAsync(url).Result;
//Can catch the status code (200 OK, 301 REDIRECT), etc.
//Debug.WriteLine(response.StatusCode);
SportDto Sport = response.Content.ReadAsAsync <SportDto>().Result;
ViewModel.sport = Sport;
//We don't need to throw any errors if this is null
//A team not having any players is not an issue.
url = "teamdata/getplayersforteam/" + id;
response = client.GetAsync(url).Result;
//Can catch the status code (200 OK, 301 REDIRECT), etc.
//Debug.WriteLine(response.StatusCode);
IEnumerable <PlayerDto> SelectedPlayers = response.Content.ReadAsAsync <IEnumerable <PlayerDto> >().Result;
ViewModel.teamplayers = SelectedPlayers;
url = "teamdata/getsponsorsforteam/" + id;
response = client.GetAsync(url).Result;
//Can catch the status code (200 OK, 301 REDIRECT), etc.
//Debug.WriteLine(response.StatusCode);
//Put data into Team data transfer object
IEnumerable <SponsorDto> SelectedSponsors = response.Content.ReadAsAsync <IEnumerable <SponsorDto> >().Result;
ViewModel.teamsponsors = SelectedSponsors;
//Grab the messages of support for this team
url = "supportdata/getsupportsforteam/" + id;
response = client.GetAsync(url).Result;
IEnumerable <SupportDto> SupportMessages = response.Content.ReadAsAsync <IEnumerable <SupportDto> >().Result;
ViewModel.supportmessages = SupportMessages;
return(View(ViewModel));
}
else
{
return(RedirectToAction("Error"));
}
}
public void AddSportTest()
{
GrantAdminPermissions();
SportDto result = serviceToTest.AddSport(testDto);
sportsStorage.Verify(r => r.Add(It.IsAny <Sport>()), Times.Once);
Assert.AreEqual(testSport.Name, result.name);
Assert.AreEqual(testSport.IsTwoTeams, result.isTwoTeams);
}
private IActionResult TryAddSport(SportModelIn modelIn)
{
SportDto data = BuildSportDto(modelIn);
SportDto added = sports.AddSport(data);
SportModelOut modelOut = CreateModelOut(added);
IActionResult result = CreatedAtRoute("GetSportById", new { name = added.name }, modelOut);
return(result);
}
public async Task <int> Update(SportDto teamDto)
{
Sport team = _teamsDbContext.Sports.Find(teamDto.Id);
AplyDtoToEntity(team, teamDto);
await _teamsDbContext.SaveChangesAsync();
return(team.Id);
}
public async Task <IActionResult> Save([FromBody] SportDto dto)
{
if (!this._service.HasAccess(dto))
{
return(Forbid());
}
await this._service.SaveAsync(dto);
return(Ok());
}
public void AddSport(SportDto sportDto)
{
var config = new MapperConfiguration(cfg =>
cfg.CreateMap <SportDto, Sport>());
var mapper = new Mapper(config);
var sport = mapper.Map <Sport>(sportDto);
_memberService.AddSport(sport);
}
public async Task <int> Update(SportDto judgeDto)
{
Sport judge = _judgesDbContext.Sports.Find(judgeDto.Id);
AplyDtoToEntity(judge, judgeDto);
await _judgesDbContext.SaveChangesAsync();
return(judge.Id);
}
public SportDto ToSportDto(Sport sport)
{
var sportDto = new SportDto
{
SportId = sport.SportId,
Name = sport.Name
};
return(sportDto);
}
public Sport ToSport(SportDto sportDto)
{
var sport = new Sport
{
SportId = sportDto.SportId,
Name = sportDto.Name
};
return(sport);
}
public async Task <int> Create(SportDto teamDto)
{
Sport team = new Sport();
AplyDtoToEntity(team, teamDto);
_teamsDbContext.Sports.Add(team);
await _teamsDbContext.SaveChangesAsync();
return(team.Id);
}
public async Task <int> Create(SportDto judgeDto)
{
Sport judge = new Sport();
AplyDtoToEntity(judge, judgeDto);
_judgesDbContext.Sports.Add(judge);
await _judgesDbContext.SaveChangesAsync();
return(judge.Id);
}
private Sport TryCreate(SportDto dto)
{
Sport built;
try {
built = new Sport(dto.name, dto.isTwoTeams);
}
catch (InvalidSportDataException e) {
throw new ServiceException(e.Message, ErrorType.INVALID_DATA);
}
return(built);
}
public void ThrowArgumentNullException_WhenInvokedWithInvalidParameter()
{
//Arrange
var dbContextMock = new Mock <ISportscardSystemDbContext>();
var mapperMock = new Mock <IMapper>();
SportDto sportDto = null;
var sportService = new SportService(dbContextMock.Object, mapperMock.Object);
//Act && Assert
Assert.ThrowsException <ArgumentNullException>(() => sportService.AddSport(sportDto));
}
public void GetSportTest()
{
GrantFollowerPermissions();
sportsStorage.Setup(r => r.Get(testSport.Name)).Returns(testSport);
SportDto result = serviceToTest.GetSport(testSport.Name);
authentication.Verify(r => r.Authenticate(), Times.Once);
authentication.Verify(r => r.AuthenticateAdmin(), Times.Never);
sportsStorage.Verify(r => r.Get(testSport.Name), Times.Once);
Assert.AreEqual(testSport.Name, result.name);
Assert.AreEqual(testSport.IsTwoTeams, result.isTwoTeams);
}
public void SetUp()
{
sportsStorage = new Mock <ISportRepository>();
teamsStorage = new Mock <ITeamRepository>();
authentication = new Mock <IAuthenticationService>();
serviceToTest = new SportService(sportsStorage.Object, teamsStorage.Object, authentication.Object);
testSport = new Sport("Sport", true);
testDto = new SportDto()
{
name = testSport.Name, isTwoTeams = testSport.IsTwoTeams
};
}
public async Task <IActionResult> Put(int id, [FromBody] SportDto dto)
{
if (id == 0)
{
return(BadRequest());
}
var sport = _mapper.Map <Sport>(dto);
sport.Id = id;
await _sportService.UpdateAsync(sport);
return(Ok("Updated"));
}
private SportDto CreateSportDtoWithLinks(Sport sport)
{
SportDto sportDto = new SportDto
{
Name = sport.Name
};
sportDto.Links.Add(new Link(
_urlHelper.Link(nameof(GetLeagues), new { sport = sport.Name }).ToLower(),
"leagues",
"GET"));
return(sportDto);
}
public void InvokeSaveChangesMethod_WhenSportWithTheSameNameDoesNotExistAtDb()
{
//Arrange
var dbContextMock = new Mock <ISportscardSystemDbContext>();
var mapperMock = new Mock <IMapper>();
var expectedSport = new Sport()
{
Name = "Gym"
};
var data = new List <Sport>
{
new Sport {
Name = "GymGymy"
},
new Sport {
Name = "Yoga"
},
new Sport {
Name = "Pilates"
}
};
var mockSet = new Mock <DbSet <Sport> >();
mockSet.SetupData(data);
mockSet.Setup(m => m.Add(It.IsAny <Sport>()));
dbContextMock
.Setup(x => x.Sports)
.Returns(mockSet.Object);
var sportDto = new SportDto()
{
Name = "Gym"
};
mapperMock
.Setup(x => x.Map <Sport>(sportDto))
.Returns(expectedSport);
var sportService = new SportService(dbContextMock.Object, mapperMock.Object);
//Act
sportService.AddSport(sportDto);
//Assert
dbContextMock.Verify(x => x.SaveChanges(), Times.Once);
}
