public void SchoolsShouldreturnListOfSchool()
{
//Arrange
var schoolService = new Mock <ISchoolService>();
schoolService
.Setup(s => s.ListOfSchools())
.Returns(new List <SchoolListingModel>()
{
new SchoolListingModel {
Id = 1, Name = "119"
}
});
var controller = new SchoolController(schoolService.Object, null);
//Act
var result = controller.Schools();
//Assert
result
.Should()
.BeOfType <ViewResult>()
.Subject
.Model
.Should()
.Match(m => m.As <IEnumerable <SchoolListingModel> >()
.First()
.Name == "119");
}
public void TestAddCorrectSchool()
{
bool isItemAdded = false;
var repository = Mock.Create <IRepository <School> >();
var schoolModel = new SchoolModel()
{
Name = "PMG",
Location = "Sofia"
};
var schoolEntity = new School()
{
Id = 1,
Name = schoolModel.Name,
Location = schoolModel.Location
};
Mock.Arrange(() => repository.Add(Arg.IsAny <School>()))
.DoInstead(() => isItemAdded = true)
.Returns(schoolEntity);
var controller = new SchoolController(repository);
SetupController.Create(controller, "post", "school");
var result = controller.PostSchool(schoolEntity);
Assert.IsTrue(result.IsSuccessStatusCode);
Assert.IsTrue(isItemAdded);
}
public JsonResult DeleteSchool(int ID)
{
SchoolController obj = new SchoolController();
var response = obj.Delete(ID);
return(Json(response, JsonRequestBehavior.AllowGet));;
}
public JsonResult GetSessions()
{
SchoolController obj = new SchoolController();
var Session = obj.GetSessions();
return(Json(Session, JsonRequestBehavior.AllowGet));
}
public JsonResult AddSchool(School School)
{
SchoolController obj = new SchoolController();
var response = obj.Post(School);
return(Json(((SchoolApi.School)(((System.Net.Http.ObjectContent)(response.Content)).Value)).ID, JsonRequestBehavior.AllowGet));
}
public JsonResult UpdateSchool(int ID, School School)
{
SchoolController obj = new SchoolController();
var response = obj.Put(ID, School);
return(Json(response, JsonRequestBehavior.AllowGet));
}
public JsonResult GetSchool()
{
SchoolController obj = new SchoolController();
List <School> objSchool = obj.GetSchool();
return(Json(objSchool, JsonRequestBehavior.AllowGet));
}
public void TestGetByIdSchool()
{
var repository = Mock.Create <IRepository <School> >();
var school = new School()
{
Id = 1,
Name = "PMG",
Location = "Sofia"
};
Mock.Arrange <School>(
() => repository.Get(school.Id))
.IgnoreArguments()
.Returns(school)
.MustBeCalled();
var controller = new SchoolController(repository);
SetupController.Create(controller, "get", "school");
var result = controller.GetSchool(school.Id);
Assert.AreEqual(result.Id, school.Id);
Assert.AreEqual(result.Name, school.Name);
Assert.AreEqual(result.Location, school.Location);
}
public void SchoolControllerTestL0_Initialise()
{
// act
_controller = new SchoolController(_mockSchoolBusinessService.Object, _mockLoggingService.Object);
//assert
_controller.Should().NotBeNull();
}
public JsonResult GetActiveSession()
{
SchoolController obj = new SchoolController();
var activeSession = obj.GetCurrentSession();
var result = Json(activeSession, JsonRequestBehavior.AllowGet);
return(result);
}
public async Task DetailShouldKeepUnitTypeBetweenExpenditureAndIncomeTabsAsync()
{
var fakeEdubaseObject = new EdubaseDataObject
{
URN = 123,
FinanceType = "Maintained"
};
var mockEdubaseDataService = new Mock <IContextDataService>();
var GetSchoolDataObjectByUrnAsyncTask = Task.Run(() =>
{
return(fakeEdubaseObject);
});
mockEdubaseDataService.Setup(m => m.GetSchoolDataObjectByUrnAsync(123)).Returns((long urn) => GetSchoolDataObjectByUrnAsyncTask);
var financialCalculationsService = new Mock <IFinancialCalculationsService>();
var mockFinancialDataService = new Mock <IFinancialDataService>();
var mockDownloadCsvBuilder = new Mock <IDownloadCSVBuilder>();
var mockCookieManager = new Mock <ISchoolBenchmarkListService>();
var mockLaSearchService = new Mock <ILocalAuthoritiesService>();
var mockActiveUrnsService = new Mock <IActiveEstablishmentsService>();
var mockCscpLookupService = new Mock <ICscpLookupService>();
var mockGiasLookupService = new Mock <IGiasLookupService>();
var mockSchoolVMBuilder = new Mock <ISchoolVMBuilder>();
var fakeSVM = new SchoolViewModel(fakeEdubaseObject);
fakeSVM.HistoricalFinancialDataModels = new List <FinancialDataModel> {
new FinancialDataModel()
};
fakeSVM.HistoricalCharts = new List <ChartViewModel> {
new ChartViewModel()
};
mockSchoolVMBuilder.Setup(m => m.GetResult()).Returns(fakeSVM);
var controller = new SchoolController(mockFinancialDataService.Object, financialCalculationsService.Object,
mockEdubaseDataService.Object, mockDownloadCsvBuilder.Object, mockCookieManager.Object, mockActiveUrnsService.Object,
mockSchoolVMBuilder.Object, mockGiasLookupService.Object, mockCscpLookupService.Object);
controller.ControllerContext = new ControllerContext(_rc, controller);
await controller.Detail(123, UnitType.PerPupil, CentralFinancingType.Exclude, TabType.Income);
mockSchoolVMBuilder.Verify(f => f.AddHistoricalChartsAsync(
It.IsAny <TabType>(),
It.IsAny <ChartGroupType>(),
It.IsAny <CentralFinancingType>(),
UnitType.PerPupil));
}
public async Task SchoolControllerTestL0_Register_Failure()
{
// Assemble
_mockSchoolBusinessService.Setup(m => m.Register(It.IsAny <RegistrationRequest>())).Throws(new OperationCanceledException());
_controller = new SchoolController(_mockSchoolBusinessService.Object, _mockLoggingService.Object);
// Act
var res = await _controller.Register(It.IsAny <Guid>(), new RegistrationModel());
}
static void Main(string[] args)
{
List <Student> studentLst;
//1.Input all data
BaseController.CreateData();
//Get
SchoolController controller = new SchoolController();
controller.GetSchoolNameById(1);
controller.GetSchoolNameById(2);
controller.GetSchoolNameById(3);
//2.Search students come from VN
StudentController stController = new StudentController();
studentLst = stController.GetStudentByCountry("VN");
stController.DisplayStudent(studentLst);
//3. Search student > 20 years old
Console.WriteLine("---more 20 years old");
studentLst = stController.GetStudentMoreAge(20);
stController.DisplayStudent(studentLst);
//4.Each student belongs to a department, find students learning IT and > 23 years
Console.WriteLine("---IT and more 23 years old");
studentLst = stController.GetStudentByDepartmentNMoreAge("IT", 23);
stController.DisplayStudent(studentLst);
//5.Find students having Fullname which inlcude *hu*
Console.WriteLine("---fullName includ *hu*");
studentLst = stController.GetStudentIncludeCharacter("hu");
stController.DisplayStudent(studentLst);
//6.In Each school, print students who have old than normal
Console.WriteLine("---In Each school, print students who have old than normal");
List <School> schoolLst = BaseController.schoolLst;
foreach (School school in schoolLst)
{
Console.WriteLine($"---In Each school {school.Name}");
List <Student> studentLst2 = new List <Student>();
studentLst = school.StudentLst;
foreach (Student st in studentLst)
{
if (st.Age > school.AgeThreshold)
{
studentLst2.Add(st);
}
}
stController.DisplayStudent(studentLst2);
}
}
public void OnEnable()
{
targetObj = target as SchoolController;
if (targetObj._bubbles == null)
{
targetObj._bubbles = (SchoolBubbles)Transform.FindObjectOfType(typeof(SchoolBubbles));
}
myProperty = serializedObject.FindProperty("_childPrefab");
bubbles = serializedObject.FindProperty("_bubbles");
}
static void Main(string[] args)
{
var schoolController = new SchoolController();
Console.WriteLine("Creating students...");
schoolController.PopulateStudents();
Console.WriteLine("Creating courses...");
schoolController.PopulateCourses();
Console.WriteLine("Associating students-courses...");
schoolController.AssociateStudentsToCourses();
Console.WriteLine("All done.");
Console.ReadKey();
}
public async Task SchoolControllerTestL0_Register_Success()
{
// Assemble
_mockSchoolBusinessService.Setup(m => m.Register(It.IsAny <RegistrationRequest>())).Returns(Task.FromResult(true));
_controller = new SchoolController(_mockSchoolBusinessService.Object, _mockLoggingService.Object);
// Act
var res = await _controller.Register(It.IsAny <Guid>(), new RegistrationModel());
//Assert
res.Should().NotBeNull();
res.Should().BeAssignableTo(typeof(AcceptedResult));
}
public void DetailShouldKeepUnitTypeBetweenExpenditureAndIncomeTabs()
{
var mockEdubaseDataService = new Mock <IContextDataService>();
dynamic testEduResult = new Document();
testEduResult.URN = "123";
mockEdubaseDataService.Setup(m => m.GetSchoolByUrn("123")).Returns((string urn) => testEduResult);
var mockHistoricalChartBuilder = new Mock <IHistoricalChartBuilder>();
mockHistoricalChartBuilder
.Setup(cb => cb.Build(It.IsAny <RevenueGroupType>(), It.IsAny <ChartGroupType>(), It.IsAny <SchoolFinancialType>(), It.IsAny <UnitType>()))
.Returns((RevenueGroupType revenueGroup, ChartGroupType chartGroupType, SchoolFinancialType schoolFinancialType, UnitType unit) => new List <ChartViewModel>()
{
new ChartViewModel()
{
ChartGroup = ChartGroupType.Staff
}
});
mockHistoricalChartBuilder
.Setup(cb => cb.Build(It.IsAny <RevenueGroupType>(), It.IsAny <SchoolFinancialType>()))
.Returns((RevenueGroupType revenueGroup, SchoolFinancialType schoolFinancialType) => new List <ChartViewModel>()
{
new ChartViewModel()
{
ChartGroup = ChartGroupType.Staff
}
});
var financialCalculationsService = new Mock <IFinancialCalculationsService>();
var mockFinancialDataService = new Mock <IFinancialDataService>();
var mockDownloadCsvBuilder = new Mock <IDownloadCSVBuilder>();
var controller = new SchoolController(mockHistoricalChartBuilder.Object, mockFinancialDataService.Object, financialCalculationsService.Object, mockEdubaseDataService.Object, mockDownloadCsvBuilder.Object);
controller.ControllerContext = new ControllerContext(_rc, controller);
controller.Detail(123, UnitType.PerPupil, CentralFinancingType.Exclude, RevenueGroupType.Income);
financialCalculationsService.Verify(f => f.PopulateHistoricalChartsWithSchoolData(
It.IsAny <List <ChartViewModel> >(),
It.IsAny <List <SchoolFinancialDataModel> >(),
It.IsAny <string>(),
It.IsAny <RevenueGroupType>(),
UnitType.PerPupil,
It.IsAny <SchoolFinancialType>()));
}
public void GetAllSchools()
{
// Arrange
Mock.Get(_repositoryWrapper.School).Setup(x => x.GetAllSchools()).ReturnsAsync(DataSeeder.SchoolSeeder.Objects);
var controller = new SchoolController(_loggerManager, _mapper, _repositoryWrapper);
// Act
var actionResult = controller.GetAllSchools().Result;
// Assert
var okObjectResult = actionResult as OkObjectResult;
Assert.IsNotNull(okObjectResult);
var reviews = okObjectResult.Value as IEnumerable <School>;
Assert.IsTrue(reviews.Count() == DataSeeder.SchoolSeeder.Objects.Count());
}
// ToDo: Figure out why the mock setup for SchoolRepository.DeleteSchool() is not being mocked correctly
//[TestMethod]
public void DeleteSchool()
{
// Arrange
var school = DataSeeder.SchoolSeeder.Objects[0];
Mock.Get(_repositoryWrapper.School).Setup(x => x.DeleteSchool(school));
Mock.Get(_repositoryWrapper.School).Setup(x => x.GetSchoolById(school.Id)).ReturnsAsync(school);
Mock.Get(_repositoryWrapper.SchoolStudent).Setup(x => x.SchoolStudentsBySchool(school.Id)).ReturnsAsync(new List <SchoolStudent>());
var controller = new SchoolController(_loggerManager, _mapper, _repositoryWrapper);
// Act
var actionResult = controller.DeleteSchool(school.Id).Result;
// Assert
var noContentResult = actionResult as NoContentResult;
Assert.IsNotNull(noContentResult);
}
public void GetSchoolById()
{
// Arrange
var school = DataSeeder.SchoolSeeder.Objects.FirstOrDefault();
Assert.IsNotNull(school, string.Format("No schools were setup in the DataSeeder"));
Mock.Get(_repositoryWrapper.School).Setup(x => x.GetSchoolById(school.Id)).ReturnsAsync(school);
var controller = new SchoolController(_loggerManager, _mapper, _repositoryWrapper);
// Act
var actionResult = controller.GetSchoolById(school.Id).Result;
// Assert
var okObjectResult = actionResult as OkObjectResult;
Assert.IsNotNull(okObjectResult);
var resultList = okObjectResult.Value as School;
Assert.IsTrue(resultList.Id == school.Id);
}
public void SetUp()
{
_schoolDetails = SetUpSchoolDetails();
_schoolRepository = SetSchoolRepository();
_redisCache = new Mock <IDistributedCache>();
//we can't set property to mock object directly. To achive that implemented below code
var unitOfData = new Mock <IUnitOfWork>();
unitOfData.SetupGet(u => u.Repository).Returns(_schoolRepository);
_unitOfWork = unitOfData.Object;
_unitOfWork.Repository = _schoolRepository;
_schoolService = new SchoolService(_unitOfWork, _redisCache.Object);
_schoolController = new SchoolController(_schoolService, SchoolAutoMapper.Mapper());
}
protected void SchoolDataBind()
{
try
{
SchoolController sysmgr = new SchoolController();
List <School> info = sysmgr.School_List();
info.Sort((x, y) => x.SchoolName.CompareTo(y.SchoolName));
SchoolList.DataSource = info;
SchoolList.DataValueField = "SchoolCode";
SchoolList.DataTextField = "SchoolName";
SchoolList.DataBind();
SchoolList.Items.Insert(0, "select ...");
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException.InnerException != null)
{
errormsgs.Add(updateException.InnerException.Message.ToString());
}
else
{
errormsgs.Add(updateException.Message);
}
LoadMessageDisplay(errormsgs, "alert alert-danger");
}
catch (DbEntityValidationException ex)
{
foreach (var entityValidationErrors in ex.EntityValidationErrors)
{
foreach (var validationError in entityValidationErrors.ValidationErrors)
{
errormsgs.Add(validationError.ErrorMessage);
}
}
LoadMessageDisplay(errormsgs, "alert alert-danger");
}
catch (Exception ex)
{
errormsgs.Add(GetInnerException(ex).ToString());
LoadMessageDisplay(errormsgs, "alert alert-danger");
}
}
public void CreateSchool()
{
// Arrange
var schoolDto = new SchoolDto
{
Name = "New School 1"
};
var school = _mapper.Map <School>(schoolDto);
Mock.Get(_repositoryWrapper.School).Setup(x => x.CreateSchool(school));
Mock.Get(_repositoryWrapper.School).Setup(x => x.GetSchoolById(school.Id)).ReturnsAsync(school);
var controller = new SchoolController(_loggerManager, _mapper, _repositoryWrapper);
// Act
var actionResult = controller.CreateSchool(schoolDto).Result;
// Assert
var okObjectResult = actionResult as OkObjectResult;
Assert.IsNotNull(okObjectResult);
}
protected void BindSchoolList()
{
try
{
SchoolController sysmgr = new SchoolController();
List <Schools> info = null;
info = sysmgr.List();
info.Sort((x, y) => x.SchoolName.CompareTo(y.SchoolName));
SchoolList.DataSource = info;
SchoolList.DataTextField = nameof(Schools.SchoolName);
SchoolList.DataValueField = nameof(Schools.SchoolCode);
SchoolList.DataBind();
SchoolList.Items.Insert(0, "select...");
}
catch (Exception ex)
{
errormsgs.Add(GetInnerException(ex).ToString());
LoadMessageDisplay(errormsgs, "alert alert-danger");
}
}
public void UpdateSchool()
{
// Arrange
var schoolDto = new SchoolDto
{
Name = "Update School 1"
};
var school = _mapper.Map <School>(schoolDto);
school.Id = Guid.NewGuid();
Mock.Get(_repositoryWrapper.School).Setup(x => x.UpdateSchool(school, school));
Mock.Get(_repositoryWrapper.School).Setup(x => x.GetSchoolById(school.Id)).ReturnsAsync(school);
var controller = new SchoolController(_loggerManager, _mapper, _repositoryWrapper);
// Act
var actionResult = controller.UpdateSchool(school.Id, schoolDto).Result;
// Assert
var noContentResult = actionResult as NoContentResult;
Assert.IsNotNull(noContentResult);
}
protected void BindList()
{
try
{
Fetch02.Enabled = false;
List02.Enabled = false;
SchoolController sysmgr = new SchoolController();
List <Schools> info = null;
info = sysmgr.List();
info.Sort((x, y) => x.SchoolName.CompareTo(y.SchoolName));
List01.DataSource = info;
List01.DataTextField = nameof(Schools.SchoolName);
List01.DataValueField = nameof(Schools.SchoolCode);
List01.DataBind();
List01.Items.Insert(0, "select...");
}
catch (Exception ex)
{
MessageLabel.Text = ex.Message;
}
}
protected void BindSchoolList()
{
try
{
SchoolController sysmgr = new SchoolController();
List <Schools> info = null;
info = sysmgr.List();
info.Sort((x, y) => x.SchoolCode.CompareTo(y.SchoolCode));
SchoolList.DataSource = info;
SchoolList.DataTextField = nameof(Schools.SchoolName);
SchoolList.DataValueField = nameof(Schools.SchoolCode);
SchoolList.DataBind();
ListItem myitem = new ListItem();
myitem.Value = "0";
myitem.Text = "select...";
SchoolList.Items.Insert(0, myitem);
}
catch (Exception ex)
{
ShowMessage(GetInnerException(ex).ToString(), "alert alert-danger");
}
}
public void TestDeleteSchool()
{
bool isItemDeleted = false;
bool isItemAdded = false;
var repository = Mock.Create <IRepository <School> >();
var schoolModel = new SchoolModel()
{
Location = "sofia",
Name = "HMG"
};
var schoolEntity = new School()
{
Id = 1,
Location = schoolModel.Location,
Name = schoolModel.Name
};
Mock.Arrange(() => repository.Add(Arg.IsAny <School>()))
.DoInstead(() => isItemAdded = true)
.Returns(schoolEntity);
var controller = new SchoolController(repository);
SetupController.Create(controller, "post", "school");
controller.PostSchool(schoolEntity);
Mock.Arrange(() => repository.Delete(Arg.IsAny <School>()))
.DoInstead(() => isItemDeleted = true);
SetupController.Create(controller, "delete", "school");
controller.DeleteSchool(schoolEntity.Id);
Assert.IsFalse(isItemDeleted);
}
public SchoolControllerTest()
{
_seed = Guid.NewGuid().ToString();
_controller = MockController.CreateController <SchoolController>(_seed, "user");
}
public void SetupRepository()
{
//Mock SchoolPerformanceRepository
_mockSchoolResult = new Mock <ISchoolPerformanceRepository <SchoolResult> >();
_mockSchoolContextual = new Mock <ISchoolPerformanceRepository <SchoolContextual> >();
//Mock data
var results = MockData.GetSchoolResultList(true);
var contextuals = MockData.GetSchoolContextualList(true);
//When the Get method is called return results
//excluding national data
_mockSchoolResult.Setup(m => m.Get(
It.IsAny <Expression <Func <SchoolResult, bool> > >(),
It.IsAny <Func <IQueryable <SchoolResult>, IOrderedQueryable <SchoolResult> > >(),
It.IsAny <Expression <Func <SchoolResult, object> >[]>()
))
.Returns(Task.FromResult <IEnumerable <SchoolResult> >(results.Where(r => r.URN != 9)));
//When the GetNational method is called return results
//with national data only
_mockSchoolResult.Setup(m => m.GetNational(
It.IsAny <Expression <Func <SchoolResult, bool> > >(),
It.IsAny <Expression <Func <SchoolResult, object> >[]>()
))
.Returns(Task.FromResult <IEnumerable <SchoolResult> >(results.Where(r => r.URN == 9)));
//When the GetNational is called return contextuals
//with national data only
_mockSchoolContextual.Setup(m => m.GetNational(
It.IsAny <Expression <Func <SchoolContextual, bool> > >(),
It.IsAny <Func <IQueryable <SchoolContextual>, IOrderedQueryable <SchoolContextual> > >()
))
.Returns(Task.FromResult <IEnumerable <SchoolContextual> >(contextuals.Where(r => r.URN == 9)));
//When the Get method is called return contextuals
//excluding national data
_mockSchoolContextual.Setup(m => m.Get(
It.IsAny <Expression <Func <SchoolContextual, bool> > >(),
It.IsAny <Func <IQueryable <SchoolContextual>, IOrderedQueryable <SchoolContextual> > >(),
It.IsAny <Expression <Func <SchoolContextual, object> >[]>()
))
.Returns(Task.FromResult <IEnumerable <SchoolContextual> >(contextuals.Where(r => r.URN != 9)));
//When the GetByUrnOrLAESATB is called return get data where URN matches
_mockSchoolContextual.Setup(m => m.GetByUrnOrLAESATB(
It.IsAny <int>(),
It.IsAny <Expression <Func <SchoolContextual, bool> > >(),
It.IsAny <Expression <Func <SchoolContextual, object> >[]>()
))
.Returns(
(int x,
Expression <Func <SchoolContextual, bool> > y,
Expression <Func <SchoolContextual, object> >[] z) =>
Task.FromResult <IEnumerable <SchoolContextual> >(contextuals.Where(r => r.URN == x)));
_mockSchoolResult.Setup(m => m.GetByUrnOrLAESATB(
It.IsAny <int>(),
It.IsAny <Expression <Func <SchoolResult, bool> > >(),
It.IsAny <Expression <Func <SchoolResult, object> >[]>()
))
.Returns(
(int x,
Expression <Func <SchoolResult, bool> > y,
Expression <Func <SchoolResult, object> >[] z) =>
Task.FromResult <IEnumerable <SchoolResult> >(results.Where(r => r.URN == x)));
_logger = new NullLogger <SchoolController>();
_controller = new SchoolController(_mockSchoolResult.Object, _mockSchoolContextual.Object, _logger);
}
// Use this for initialization
void Start()
{
mSchoolController = GameObject.Find("SchoolController").GetComponent<SchoolController>();
mScenesManager = GameObject.Find("ScenesManager").GetComponent<ScenesManager>();
}
