public void CreateSportOkSportsController()
{
sportServicesMock.Setup(s => s.CreateSport(It.IsAny <SportDTO>()));
ILoginServices login = new LoginServicesMock(mariano);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
var controller = new SportsController(login, sportServicesMock.Object, encounterServicesMock.Object, encounterQueryServices.Object, positionServicesMock.Object, teamServicesMock.Object)
{
ControllerContext = controllerContext,
};
SportDTO footballIn = new SportDTO()
{
Name = "Futbol"
};
var result = controller.CreateSport(footballIn);
sportServicesMock.Verify(s => s.CreateSport(It.IsAny <SportDTO>()), Times.AtMostOnce);
var createdResult = result as CreatedAtRouteResult;
var footballOut = createdResult.Value as SportDTO;
Assert.IsNotNull(createdResult);
Assert.AreEqual("GetSport", createdResult.RouteName);
Assert.AreEqual(201, createdResult.StatusCode);
Assert.AreEqual(footballIn.Name, footballOut.Name);
}
public void GetAllEncountersOfASpecificSport2()
{
string sportName = "Tennis";
var expectedEncounters = new List <EncounterDTO>()
{
};
var encounterQueryServicesMock = new Mock <IEncounterQueryServices>();
encounterQueryServicesMock.Setup(s => s.GetEncountersBySport(sportName)).Returns(expectedEncounters);
ILoginServices login = new LoginServicesMock(mariano);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
var controller = new SportsController(login, sportServicesMock.Object, encounterServicesMock.Object, encounterQueryServicesMock.Object, positionServicesMock.Object, teamServicesMock.Object)
{
ControllerContext = controllerContext,
};
var obtainedResult = controller.GetEncountersBySport("Tennis") as ActionResult <List <EncounterModelOut> >;
var value = obtainedResult.Result;
encounterServicesMock.VerifyAll();
Assert.IsNull(value);
}
public void DeleteSportWithoutPermissionSportsController()
{
string name = "Futbol";
var modelIn = new SportDTO()
{
Name = name
};
sportServicesMock.Setup(s => s.DeleteSport(name)).Throws(new InsufficientPermissionException());
ILoginServices loginServices = new LoginServicesMock(mariano);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
var controller = new SportsController(loginServices, sportServicesMock.Object, encounterServicesMock.Object, encounterQueryServices.Object, positionServicesMock.Object, teamServicesMock.Object)
{
ControllerContext = controllerContext,
};
var result = controller.DeleteSport(name);
sportServicesMock.Verify(s => s.DeleteSport(name), Times.AtMostOnce);
var badRequestResult = result as UnauthorizedResult;
Assert.AreEqual(401, badRequestResult.StatusCode);
}
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();
}
public void GetAllSportsOkSportsController()
{
var expectedSports = new List <SportDTO>()
{
football, tennis
};
sportServicesMock.Setup(s => s.GetAllSports()).Returns(expectedSports);
var encounterQueryServicesMock = new Mock <IEncounterQueryServices>();
ILoginServices login = new LoginServicesMock(mariano);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
var controller = new SportsController(login, sportServicesMock.Object, encounterServicesMock.Object, encounterQueryServicesMock.Object, positionServicesMock.Object, teamServicesMock.Object)
{
ControllerContext = controllerContext,
};
var obtainedResult = controller.GetAllSports() as ActionResult <List <SportModelOut> >;
var val = obtainedResult.Value;
sportServicesMock.Verify(s => s.GetAllSports(), Times.AtMostOnce);
Assert.IsNotNull(obtainedResult);
Assert.IsNotNull(obtainedResult.Value);
Assert.AreEqual(expectedSports[0].Name, obtainedResult.Value[0].Name);
}
public void GetSport()
{
int sportId = 1;
String name = "test";
Sport testObject = new Sport();
testObject.sportId = sportId;
testObject.name = name;
Mock <ISportRepository> myMock = new Mock <ISportRepository>();
myMock.Setup(x => x.GetById(1))
.Returns(Task.FromResult(testObject));
SportsController sportsController = new SportsController(myMock.Object);
Task <IHttpActionResult> returnedTask = sportsController.GetSport(1);
var contentResult = returnedTask.Result as OkNegotiatedContentResult <Sport>;
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Assert.AreEqual(contentResult.Content.sportId, sportId);
Assert.AreEqual(contentResult.Content.name, name);
myMock.VerifyAll();
}
public void CreateSportAlreadyExistsSportsController()
{
sportServicesMock.Setup(s => s.CreateSport(It.IsAny <SportDTO>())).Throws(new ServicesException());
ILoginServices login = new LoginServicesMock(rodolfo);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
var controller = new SportsController(login, sportServicesMock.Object, encounterServicesMock.Object, encounterQueryServices.Object, positionServicesMock.Object, teamServicesMock.Object)
{
ControllerContext = controllerContext,
};
SportDTO footballIn = new SportDTO()
{
Name = "Futbol"
};
var result = controller.CreateSport(footballIn);
sportServicesMock.Verify(s => s.CreateSport(It.IsAny <SportDTO>()), Times.AtMostOnce);
var createdResult = result as BadRequestObjectResult;
Assert.IsNotNull(createdResult);
Assert.AreEqual(400, createdResult.StatusCode);
}
public void DeleteSport_NotFound()
{
int sportId = 1;
String name = "test";
Sport testObject = new Sport();
testObject.sportId = sportId;
testObject.name = name;
Mock <ISportRepository> myMock = new Mock <ISportRepository>();
myMock.Setup(x => x.GetById(sportId))
.Returns(Task.FromResult((Sport)null));
myMock.Setup(x => x.Delete(testObject))
.Returns(Task.FromResult(sportId));
SportsController sportsController = new SportsController(myMock.Object);
Task <IHttpActionResult> returnedTask = sportsController.DeleteSport(sportId);
var contentResult = returnedTask.Result as NotFoundResult;
Assert.IsNotNull(contentResult);
myMock.Verify(mock => mock.GetById(sportId), Times.Once());
}
public void getSports()
{
List <Sport> testObjects = new List <Sport>();
testObjects.Add(new Sport {
sportId = 1, name = "test1"
});
testObjects.Add(new Sport {
sportId = 2, name = "test2"
});
Mock <ISportRepository> myMock = new Mock <ISportRepository>();
myMock.Setup(x => x.GetAll())
.Returns(testObjects.AsQueryable);
SportsController sportsController = new SportsController(myMock.Object);
IQueryable <Sport> returnedTask = sportsController.GetSports();
var contentResult = returnedTask.ToList();
Assert.IsNotNull(contentResult);
Assert.AreEqual(contentResult.Count, 2);
Assert.AreEqual(contentResult[0].sportId, 1);
Assert.AreEqual(contentResult[1].sportId, 2);
myMock.VerifyAll();
}
public async System.Threading.Tasks.Task PutSportTestAsync()
{
var manager = new Mock <ISportManager>();
Sport s = new Sport()
{
Id = 1,
Name = "Sport"
};
manager.Setup(m => m.Update(1, s))
.Callback((int id, Sport sport) =>
{
id.Should().Be(1);
sport.Id.Should().Be(1);
sport.Name.Should().Be("Sport");
})
.ReturnsAsync(s);
var controller = new SportsController(manager.Object);
var actionResult = await controller.PutSport(1, s);
// Checks the 204 response
actionResult.Should().NotBeNull();
actionResult.Should().BeOfType <NoContentResult>();
}
public void GetSportsByNameOkSportsController()
{
sportServicesMock.Setup(s => s.GetSport(football.Name)).Returns(football);
ILoginServices login = new LoginServicesMock(mariano);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
var controller = new SportsController(login, sportServicesMock.Object, encounterServicesMock.Object, encounterQueryServices.Object, positionServicesMock.Object, teamServicesMock.Object)
{
ControllerContext = controllerContext,
};
var obtainedResult = controller.GetSportById(football.Name) as ActionResult <SportModelOut>;
var val = obtainedResult.Value;
sportServicesMock.Verify(s => s.GetSport(football.Name), Times.AtMostOnce);
Assert.IsNotNull(obtainedResult);
Assert.IsNotNull(obtainedResult.Value);
SportModelOut sport = obtainedResult.Value;
Assert.AreEqual(football.Name, sport.Name);
}
public async System.Threading.Tasks.Task PostSportTestAsync()
{
var manager = new Mock <ISportManager>();
Sport s = new Sport()
{
Id = 1,
Name = "Sport"
};
manager.Setup(m => m.Add(s))
.Callback((Sport sport) =>
{
sport.Id.Should().Be(1);
sport.Name.Should().Be("Sport");
})
.ReturnsAsync(s);
var controller = new SportsController(manager.Object);
var actionResult = await controller.PostSport(s);
// Checks the 201 response
actionResult.Result.Should().BeOfType <CreatedAtActionResult>();
var result = actionResult.Result as CreatedAtActionResult;
//Checks the content of the response
var responseValue = result.Value as Sport;
responseValue.Id.Should().Be(1);
responseValue.Name.Should().Be("Sport");
}
public void ConstructorTest()
{
var manager = new Mock <ISportManager>();
var controller = new SportsController(manager.Object);
controller.Should().NotBeNull();
}
public async System.Threading.Tasks.Task DeleteSportTestAsync()
{
var manager = new Mock <ISportManager>();
Sport s = new Sport()
{
Id = 1,
Name = "Sport"
};
manager.Setup(m => m.DeleteAsync(1))
.Callback((int id) =>
{
id.Should().Be(1);
})
.ReturnsAsync(s);
var controller = new SportsController(manager.Object);
var actionResult = await controller.DeleteSport(1);
actionResult.Should().NotBeNull();
actionResult.Should().BeOfType <ActionResult <Sport> >();
// Checks the 200 response
actionResult.Result.Should().BeOfType <OkObjectResult>();
var result = actionResult.Result as OkObjectResult;
//Checks the content of the response
var responseValue = result.Value as Sport;
responseValue.Id.Should().Be(1);
responseValue.Name.Should().Be("Sport");
}
public async System.Threading.Tasks.Task GetSportTestAsync()
{
var manager = new Mock <ISportManager>();
manager.Setup(m => m.Get(11))
.ReturnsAsync(new Sport()
{
Id = 11
});
var controller = new SportsController(manager.Object);
var actionResult = await controller.GetSport(11);
actionResult.Should().NotBeNull();
actionResult.Should().BeOfType <ActionResult <Sport> >();
// Checks the 200 response
actionResult.Result.Should().BeOfType <OkObjectResult>();
var result = actionResult.Result as OkObjectResult;
//Checks the content of the response
var responseValue = result.Value as Sport;
responseValue.Id.Should().Be(11);
}
public void Get_Should_Return_Items()
{
TestHelpers.SetupDbSet(this.mockSet, this.data);
SportsController controller = new SportsController(this.mockContext.Object);
IQueryable <sport> result = controller.GetSports();
Assert.IsNotNull(result);
Assert.AreNotEqual(0, result.Count());
}
public void Get_Zero_Items()
{
TestHelpers.SetupDbSet(this.mockSet, new List <sport>());
SportsController controller = new SportsController(this.mockContext.Object);
IQueryable <sport> result = controller.GetSports();
Assert.IsNotNull(result);
Assert.AreEqual(0, result.Count());
}
public async void SportsController_GetEventsBySportAndDate_JsonResult()
{
var expected = new List <SportEvent>
{
new SportEvent()
{
EventId = 1,
SportId = 2,
EventName = "Fake Event",
EventDate = new DateTime(1870, 4, 22),
Team1Price = 1.23M,
Team2Price = 4.56M,
DrawPrice = 7.89M
},
new SportEvent()
{
EventId = 2,
SportId = 3,
EventName = "FFake EEvent",
EventDate = new DateTime(1879, 11, 7),
Team1Price = 3.21M,
Team2Price = 6.54M,
DrawPrice = 9.87M
},
};
var logMock = new Mock <ILogger <SportsController> >();
var eventsRepoMock = new Mock <IEventsRepository>();
var sportsRepoMock = new Mock <ISportsRepository>();
eventsRepoMock.Setup(
r => r.GetEventsBySportAndDate(It.IsAny <int>(), It.IsAny <DateTime>()))
.ReturnsAsync(expected);
var spControl = new SportsController(logMock.Object, eventsRepoMock.Object, sportsRepoMock.Object);
var result = await spControl.Get(1, DateTime.Now);
Assert.NotNull(result);
Assert.True(result.Result == null);
Assert.IsType <ActionResult <IEnumerable <SportEvent> > >(result);
Assert.IsType <List <SportEvent> >(result.Value);
Assert.NotNull(result.Value);
var actual = result.Value;
var pairs = expected.Zip(actual, (exp, act) => new { Expected = exp, Actual = act });
foreach (var p in pairs)
{
Assert.Equal(p.Expected, p.Actual);
}
}
public async System.Threading.Tasks.Task PutSportBadRequestTestAsync()
{
var manager = new Mock <ISportManager>();
Sport s = new Sport()
{
Id = 1,
Name = "Sport"
};
var controller = new SportsController(manager.Object);
var actionResult = await controller.PutSport(2, s);
// Checks the 400 response
actionResult.Should().NotBeNull();
actionResult.Should().BeOfType <BadRequestResult>();
}
public async void SportsController_GetAll_NotFound_WithNoDatabaseConnection()
{
var logMock = new Mock <ILogger <SportsController> >();
var eventsRepo = new EventsRepository("");
var sportsRepo = new SportsRepository("");
var spControl = new SportsController(logMock.Object, eventsRepo, sportsRepo);
var result = await spControl.Get();
Assert.NotNull(result);
Assert.IsType <ActionResult <IEnumerable <SportInfo> > >(result);
Assert.NotNull(result.Result);
Assert.IsType <NotFoundResult>(result.Result);
Assert.True(result.Value == null);
Assert.True((result.Result as NotFoundResult).StatusCode == 404);
}
public async System.Threading.Tasks.Task GetSportNotFoundTestAsync()
{
var manager = new Mock <ISportManager>();
Sport s = null;
manager.Setup(m => m.Get(11))
.ReturnsAsync(s);
var controller = new SportsController(manager.Object);
var actionResult = await controller.GetSport(11);
actionResult.Should().NotBeNull();
actionResult.Should().BeOfType <ActionResult <Sport> >();
// Checks the 404 response
actionResult.Result.Should().BeOfType <NotFoundResult>();
}
public void Get_Sport_By_ID_Should_Return_Sport()
{
TestHelpers.SetupDbSet(this.mockSet, this.data);
SportsController controller = new SportsController(this.mockContext.Object);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
IHttpActionResult response = controller.GetSport(data.First().id);
var result = response as OkNegotiatedContentResult <sport>;
var coutryResult = result.Content;
Assert.IsNotNull(response);
Assert.IsNotNull(coutryResult);
Assert.AreEqual(data.First(), coutryResult);
}
public void CreateFailedUserTest()
{
var modelIn = new SportModelIn();
var userService = new Mock <ISportService>();
var controller = new SportsController(userService.Object);
controller.ModelState.AddModelError("", "Error");
var result = controller.Post(modelIn);
var createdResult = result as BadRequestObjectResult;
Assert.IsNotNull(createdResult);
Assert.AreEqual(400, createdResult.StatusCode);
}
public void TestGetSportsShouldReturnOKReturnSports()
{
var mock = new Mock <ISportService>(MockBehavior.Strict);
mock.Setup(m => m.GetAllSports()).Returns(new List <Sport> {
new Sport("Basketball"), new Sport("Tennis")
});
var sut = new SportsController(mock.Object);
var response = sut.Get();
mock.Verify(m => m.GetAllSports(), Times.Once);
var result = response as OkObjectResult;
var model = result.Value as IEnumerable <SportModelOut>;
Assert.AreEqual(200, result.StatusCode);
Assert.AreEqual(2, model.Count());
}
public void GetSportTest()
{
var sportModel = new Sport("Basketball");
sportModel.SportId = 1;
var mock = new Mock <ISportService>(MockBehavior.Strict);
mock.Setup(m => m.GetSportById(sportModel.SportId)).Returns(sportModel);
var controller = new SportsController(mock.Object);
var result = controller.Get(sportModel.SportId);
var createdResult = result as OkObjectResult;
var model = createdResult.Value as SportModelOut;
mock.VerifyAll();
// Assert.AreEqual(sportModel.Name, model.Name);
Assert.AreEqual(sportModel.SportId, model.SportId);
}
public async void SportsController_GetSportsWithEventsCount_JsonResult()
{
var expected = new List <SportInfo>
{
new SportInfo()
{
SportId = 1, Name = "First", EventsCount = 12
},
new SportInfo()
{
SportId = 2, Name = "Second", EventsCount = 23
},
new SportInfo()
{
SportId = 3, Name = "Third", EventsCount = 34
},
};
var logMock = new Mock <ILogger <SportsController> >();
var eventsRepoMock = new Mock <IEventsRepository>();
var sportsRepoMock = new Mock <ISportsRepository>();
sportsRepoMock.Setup(
r => r.GetSportsWithEventsCount())
.ReturnsAsync(expected);
var spControl = new SportsController(logMock.Object, eventsRepoMock.Object, sportsRepoMock.Object);
var result = await spControl.Get();
Assert.NotNull(result);
Assert.True(result.Result == null);
Assert.IsType <ActionResult <IEnumerable <SportInfo> > >(result);
Assert.IsType <List <SportInfo> >(result.Value);
Assert.NotNull(result.Value);
var actual = result.Value;
var pairs = expected.Zip(actual, (exp, act) => new { Expected = exp, Actual = act });
foreach (var p in pairs)
{
Assert.Equal(p.Expected, p.Actual);
}
}
public void GetSportsEmptyTest()
{
var mockDB = new Mock <IUnitOfWork>();
var mocksportservice = new Mock <ISportService>();
var controller = new SportsController(mocksportservice.Object);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = UserAdmin()
}
};
var obtainedResult = controller.Get() as OkObjectResult;
mocksportservice.VerifyAll();
Assert.IsNotNull(obtainedResult);
Assert.AreEqual(200, obtainedResult.StatusCode);
}
public void TestInitalize()
{
// this method runs automatically before each individual test
// create a new mock data object to hold a fake list of albums
mock = new Mock <ISportsMock>();
// populate mock list
sports = new List <Sport>
{
new Sport {
Boys = 200, Soccer = "Real Madrid", Rugby = "OBJ"
},
new Sport {
Baseball = "Yankee", Soccer = "Man United", Rugby = "Rock"
}
};
mock.Setup(m => m.Sports).Returns(sports.AsQueryable());
controller = new SportsController(mock.Object);
}
public void GetEncountersBySportOkSportsController()
{
var encounterQueryServicesMock = new Mock <IEncounterQueryServices>();
EncounterDTO encounter = CreateAEncounter(football.Name);
List <EncounterDTO> encounters = new List <EncounterDTO>()
{
encounter
};
encounterQueryServicesMock.Setup(e => e.GetEncountersBySport(football.Name)).Returns(encounters);
ILoginServices login = new LoginServicesMock(mariano);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
var controller = new SportsController(login, sportServicesMock.Object, encounterServicesMock.Object, encounterQueryServicesMock.Object, positionServicesMock.Object, teamServicesMock.Object)
{
ControllerContext = controllerContext,
};
var obtainedResult = controller.GetEncountersBySport(football.Name) as ActionResult <List <EncounterModelOut> >;
encounterQueryServicesMock.Verify(e => e.GetEncountersBySport(football.Name), Times.AtMostOnce);
Assert.IsNotNull(obtainedResult);
Assert.IsNotNull(obtainedResult.Value);
List <EncounterModelOut> encounterResult = obtainedResult.Value;
Assert.AreEqual(encounter.Id, encounterResult[0].Id);
Assert.AreEqual(encounter.SportName, encounterResult[0].SportName);
Assert.AreEqual(encounter.TeamIds.First(), encounterResult[0].TeamIds.First());
Assert.AreEqual(encounter.TeamIds.Last(), encounterResult[0].TeamIds.Last());
Assert.AreEqual(encounter.DateTime, encounterResult[0].DateTime);
}
public void GetAllEncountersOfASpecificSport1()
{
string sportName = "Futbol";
EncounterDTO encounter = CreateAEncounter(sportName);
var expectedEncounters = new List <EncounterDTO>()
{
encounter
};
var encounterQueryServicesMock = new Mock <IEncounterQueryServices>();
encounterQueryServicesMock.Setup(s => s.GetEncountersBySport(sportName)).Returns(expectedEncounters);
ILoginServices login = new LoginServicesMock(mariano);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
var controller = new SportsController(login, sportServicesMock.Object, encounterServicesMock.Object, encounterQueryServicesMock.Object, positionServicesMock.Object, teamServicesMock.Object)
{
ControllerContext = controllerContext,
};
var obtainedResult = controller.GetEncountersBySport(sportName) as ActionResult <List <EncounterModelOut> >;
var val = obtainedResult.Value;
encounterQueryServicesMock.Verify(e => e.GetEncountersBySport(sportName), Times.AtMostOnce);
Assert.IsNotNull(obtainedResult);
Assert.IsNotNull(obtainedResult.Value);
Assert.AreEqual(encounter.Id, obtainedResult.Value[0].Id);
Assert.AreEqual(encounter.SportName, obtainedResult.Value[0].SportName);
Assert.AreEqual(encounter.TeamIds.First(), obtainedResult.Value[0].TeamIds.First());
Assert.AreEqual(encounter.TeamIds.Last(), obtainedResult.Value[0].TeamIds.Last());
Assert.AreEqual(encounter.DateTime, obtainedResult.Value[0].DateTime);
}
