示例#1
0
        public void RaisePostBackEvent(string eventArgument)
        {
            switch (eventArgument)
            {
            case "ResetModuleTabSettings":
                ModulesController.DeleteTabModuleSettings(ModuleContext.TabModuleId);
                break;

            case "SaveSettingsAsDefault":
                SaveSettings();
                var tabModuleSettings = ModulesController.GetTabModuleSettings(ModuleContext.TabModuleId);

                foreach (string key in tabModuleSettings.Keys)
                {
                    ModulesController.UpdateModuleSetting(ModuleContext.ModuleId, key,
                                                          tabModuleSettings[key].ToString());
                }
                break;

            case "DeleteAll":
                UdtController.DeleteRows();
                Response.Redirect(Globals.NavigateURL(ModuleContext.TabId), true);
                break;
            }
        }
示例#2
0
 public void set_up()
 {
     _mockedStorageProvider = new Mock <IStorageProvider>();
     _repositoryModel       = new RepositoryModel(_mockedStorageProvider.Object);
     _controller            = new ModulesController(_repositoryModel);
     _requestBaseMock       = new Mock <HttpRequestBase>();
 }
 protected override void OnLoad(EventArgs e)
 {
     base.OnLoad(e);
     Localization.LocalizeDataGrid(ref grdModules, LocalResourceFile);
     grdModules.DataSource = ModulesController.GetInstalledModules();
     grdModules.DataBind();
 }
        public async Task ShouldReturnOkWithEmptyListIfModuleHasZeroStudents_GetStudentsByModule()
        {
            Module module = new Module()
            {
                Id = 3, Code = "SEM5640", Year = "2020", ClassCode = "AB0", CoordinatorUid = "nst", Title = "Developing Advanced Internet Based-Applications"
            };
            List <Student> studentData = new List <Student>();
            var            mockRepo    = new Mock <IDataRepository>();

            mockRepo.Setup(repo => repo.GetModuleAsync(module.Id)).
            ReturnsAsync(module);
            mockRepo.Setup(repo => repo.StudentsByModuleAsync(module.Id)).
            ReturnsAsync(studentData);

            ModulesController controller = new ModulesController(mockRepo.Object);

            var result = await controller.GetStudentsByModule(module.Id);

            Assert.IsInstanceOfType(result.Result, typeof(OkObjectResult));

            var okResult = result.Result as OkObjectResult;
            var students = okResult.Value as List <Student>;

            Assert.AreEqual(0, students.Count);
        }
        public async Task ShouldReturnNotFoundWhenPassedNull_GetModulesByUser()
        {
            var mockRepo = new Mock <IDataRepository>();
            ModulesController controller = new ModulesController(mockRepo.Object);
            var result = await controller.GetModulesByUser(null);

            Assert.IsInstanceOfType(result.Result, typeof(NotFoundResult));
        }
示例#6
0
        public async Task Delete_ReturnsNoContent()
        {
            var controller = new ModulesController(moqMediator.Object);

            var result = await controller.Delete(1, 1);

            Assert.IsInstanceOf(typeof(NoContentResult), result);
        }
 public void ControllerLogErrorsAndTrowException()
 {
     Assert.Throws <ArgumentNullException>(() =>
     {
         var badController   = new ModulesController(LoggerFactory, null);
         ActionResult result = badController.GetModules().Result as OkObjectResult;
     });
 }
示例#8
0
        public void BrowsePdfShouldReturnMimeApplicationPdf(int fileId, string pdfType)
        {
            //Moqa context(?) TODO
            var controller = new ModulesController();

            var result = controller.Details(2, "facts") as ViewResult;

            Assert.AreEqual("Details", result.ViewName);
        }
        public void Test()
        {
            var optionBuilder = new DbContextOptionsBuilder <ThesisProjectDBContext>();

            optionBuilder.UseInMemoryDatabase();

            _context = new ThesisProjectDBContext(optionBuilder.Options);

            var controller = new ModulesController(_context);
        }
    private void Awake()
    {
        _audioController = new AudioController(new ResourceAudioChannelFactory(), 1);
        var scenarioController = new ScenarioController(_audioController);
        var modulesController  = new ModulesController();

        var gameStateControllerFactory = new GameStateControllerFactory(scenarioController, modulesController);

        _stateController = gameStateControllerFactory.Create();
    }
示例#11
0
        public async Task Update_ReturnsBadRequest_WhenRequestedIdDoesNotMatchCommandId()
        {
            var updateCommand = new UpdateModule {
                Id = 2, Order = 0, Title = "Update title", Description = "Update Description"
            };
            var controller = new ModulesController(moqMediator.Object);

            var result = await controller.Update(1, updateCommand);

            Assert.IsInstanceOf(typeof(BadRequestResult), result.Result);
        }
        public async Task Return_Not_Found_On_Null_Id()
        {
            // Arrange
            var controller = new ModulesController(GetFakeContext());

            // Act
            var result = await controller.Details(null);

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
        public async Task ShouldReturnBadRequestWhenPassedInvalidYear_GetModulesByYear()
        {
            string futureYear = "badyear";
            var    mockRepo   = new Mock <IDataRepository>();

            ModulesController controller = new ModulesController(mockRepo.Object);

            var result = await controller.GetModulesByYear(futureYear);

            Assert.IsInstanceOfType(result.Result, typeof(BadRequestResult));
        }
        public async Task ShouldReturnNotFoundIfModuleDoesntExist_DeleteModule()
        {
            int wrongId = 46;

            var mockRepo = new Mock <IDataRepository>();
            ModulesController controller = new ModulesController(mockRepo.Object);

            var result = await controller.DeleteModule(wrongId);

            Assert.IsInstanceOfType(result, typeof(NotFoundResult));
        }
        public async Task IsValidateModuleName()
        {
            try
            {
                Modules module = new Modules {
                    Name = " "
                };


                // var controller = new ModulesController();
                var controller = new ModulesController();

                var result = await controller.SaveModule(module);

                // var okResult = result as ObjectResult;
                //  var context = new BusinessRulesDataEngineContext();
                ////var connectionString = @"Server=localhost;Database=EmployeeManagementDB;Trusted_Connection=True;";
                ////var builder = new
                ////    DbContextOptionsBuilder<BusinessRulesDataEngineContext>();
                ////builder.UseSqlServer(connectionString);
                ////var options = builder.Options;
                //using (var context = new EfCoreContext(options))
                //{
                //… unit test starts here
                //  IModulesRepository moduleRepository = new  ModulesRepository(context);
                //  var _moduleRepository = new Mock<IModulesRepository>();
                //IModulesRepository moduleRepository = GetModulesRepository();
                //  _moduleRepository = moduleRepository.;
                //  var moduleRepository = new Mock<IModulesRepository>(context) { CallBase = true };

                //   Mock<IModulesRepository> moduleRepository = new Mock<IModulesRepository>();
                //moduleRepository = new Mock<ModulesRepository<context>>();
                //var moq = new Mock<IModulesRepository>();
                // moq.
                // Modules module = new Modules { Name = "Physical Product" };
                //var result = moduleRepository.InsertModule(module);
                // Assert.Equal("Blogs", savedPerson.Surname);
                //var result = moduleRepository.Setup(foo => foo.InsertModule(module));
                Assert.Equal(result.Value.ToString(), "Name is empty");

                //Assert.NotEqual()
            }
            catch (Exception ex)
            {
                Assert.NotNull(ex);
                // Assert.IsType<InvalidOperationException>(ex);
            }

            //Assert.f(Convert.ToInt32(result) > 0, "The DataSved Successfully !!");

            // moduleRepository.in(module);
            //  var result = moduleRepository
        }
示例#16
0
 public ModulesControllerTest()
 {
     this.devicesMock = new Mock <IDevices>();
     this.httpContext = new DefaultHttpContext();
     this.controller  = new ModulesController(this.devicesMock.Object)
     {
         ControllerContext = new ControllerContext()
         {
             HttpContext = this.httpContext,
         },
     };
 }
示例#17
0
    private GameState CreateGameState(ScenarioController scenarioController, ModulesController modulesController)
    {
        var input = new GameStateInput(scenarioController);
        var state = new GameState(input, scenarioController, modulesController);

        var reviewTransition = new EventTransition(ReviewState.StateName);

        input.HandleFinalStateEvent += reviewTransition.ChangeState;

        state.AddTransitions(reviewTransition);

        return(state);
    }
示例#18
0
        public ModulesControllerTests()
        {
            this.modulesDataServiceMock = new Mock <IModulesDataService>();

            this.moduleSessionDataService = new Mock <IModuleSessionDataService>().Object;

            this.mappingServiceMock = new Mock <IMappingService>();

            this.modulesController = new ModulesController(
                this.modulesDataServiceMock.Object,
                this.moduleSessionDataService,
                this.mappingServiceMock.Object);
        }
        public async Task ShouldReturnNotFoundIfDoesNotExist_GetModuleById()
        {
            int id       = 56;
            var mockRepo = new Mock <IDataRepository>();

            mockRepo.Setup(repo => repo.GetModuleAsync(id)).
            ReturnsAsync((Module)null);

            ModulesController controller = new ModulesController(mockRepo.Object);

            var result = await controller.GetModuleById(id);

            Assert.IsInstanceOfType(result.Result, typeof(NotFoundResult));
        }
        public async Task ShouldReturnBadRequestIfModuleIdDoesntMatch_UpdateModule()
        {
            int wrongId = 46;
            var module  = new Module()
            {
                Id = 5, Code = "SEM5640", Year = "2020", ClassCode = "AB0", CoordinatorUid = "nst", Title = "Developing Advanced Internet Based-Applications"
            };

            var mockRepo = new Mock <IDataRepository>();
            ModulesController controller = new ModulesController(mockRepo.Object);

            var result = await controller.UpdateModule(wrongId, module);

            Assert.IsInstanceOfType(result, typeof(BadRequestResult));
        }
示例#21
0
        public async Task Update_ReturnsUpdatedModule_WhenRequestedIdMatchesCommandId()
        {
            var updateCommand = new UpdateModule {
                Id = 1, Order = 0, Title = "Update title", Description = "Update Description"
            };
            var controller = new ModulesController(moqMediator.Object);

            var result = await controller.Update(1, updateCommand);

            var content = GetObjectResultContent <Module>(result.Result);

            Assert.IsInstanceOf(typeof(OkObjectResult), result.Result);
            Assert.IsNotNull(content);
            Assert.AreEqual(1, content.Id);
        }
示例#22
0
        public async Task Create_ReturnsCreatedAtRoute()
        {
            var createCommand = new CreateModule {
                Order = 0, Title = "Create title", Description = "Create Description"
            };
            var controller = new ModulesController(moqMediator.Object);

            var result = await controller.Create(createCommand);

            var content = GetObjectResultContent <Module>(result.Result);

            Assert.IsInstanceOf(typeof(CreatedAtRouteResult), result.Result);
            Assert.AreEqual("GetModule", ((CreatedAtRouteResult)result.Result).RouteName);
            Assert.IsNotNull(content);
            Assert.AreEqual(1, content.Id);
        }
        public async Task Return_Bad_Request_On_Create_With_Invalid_Model()
        {
            // Arrange
            var context = GetFakeContext();

            var controller = new ModulesController(context);

            controller.ModelState.AddModelError("Title", "Required");

            // Act
            var result = await controller.Create(new Fixture().Create <ModuleCreationViewModel>());

            // Assert
            var badRequestResult = Assert.IsAssignableFrom <BadRequestObjectResult>(result);

            Assert.IsType <SerializableError>(badRequestResult.Value);
        }
        public async Task ShouldReturnStudentsOnAModuleWithStudents_GetStudentsByModule()
        {
            Module module = new Module()
            {
                Id = 3, Code = "SEM5640", Year = "2020", ClassCode = "AB0", CoordinatorUid = "nst", Title = "Developing Advanced Internet Based-Applications"
            };
            List <Student> studentData = new List <Student>();

            studentData.Add(new Student()
            {
                Uid = "mwj7", Forename = "Morgan", Surname = "Jones"
            });
            studentData.Add(new Student()
            {
                Uid = "dop2", Forename = "Dominic", Surname = "Parr"
            });

            var mockRepo = new Mock <IDataRepository>();

            mockRepo.Setup(repo => repo.GetModuleAsync(module.Id)).
            ReturnsAsync(module);
            mockRepo.Setup(repo => repo.StudentsByModuleAsync(module.Id)).
            ReturnsAsync(studentData);

            ModulesController controller = new ModulesController(mockRepo.Object);

            var result = await controller.GetStudentsByModule(module.Id);

            Assert.IsInstanceOfType(result.Result, typeof(OkObjectResult));

            var okResult = result.Result as OkObjectResult;
            var students = okResult.Value as List <Student>;

            Assert.AreEqual(2, students.Count);

            int i = 0;

            foreach (Student m in students)
            {
                Assert.AreEqual(studentData[i].Uid, m.Uid);
                Assert.AreEqual(studentData[i].Forename, m.Forename);
                Assert.AreEqual(studentData[i].Surname, m.Surname);
                i++;
            }
        }
        public async Task ShouldReturnBadRequestIfModuleExists_CreateModule()
        {
            var module = new Module()
            {
                Id = 5, Code = "SEM5640", Year = "2020", ClassCode = "AB0", CoordinatorUid = "nst", Title = "Developing Advanced Internet Based-Applications"
            };

            var mockRepo = new Mock <IDataRepository>();

            mockRepo.Setup(repo => repo.GetModuleAsync(module.Id)).
            ReturnsAsync(module);

            ModulesController controller = new ModulesController(mockRepo.Object);

            var result = await controller.CreateModule(module);

            Assert.IsInstanceOfType(result.Result, typeof(BadRequestResult));
        }
        public async Task ShouldReturnOkWithEmptyListIfNoModulesForGivenYear_GetModulesByYear()
        {
            string        futureYear  = "2040";
            List <Module> emptyResult = new List <Module>();
            var           mockRepo    = new Mock <IDataRepository>();

            mockRepo.Setup(repo => repo.ModulesByYearListAsync(futureYear)).
            ReturnsAsync(emptyResult);

            ModulesController controller = new ModulesController(mockRepo.Object);

            var result = await controller.GetModulesByYear(futureYear);

            Assert.IsInstanceOfType(result.Result, typeof(OkObjectResult));

            var okResult = result.Result as OkObjectResult;
            var modules  = okResult.Value as List <Module>;

            Assert.AreEqual(0, modules.Count);
        }
示例#27
0
        public async void GetAll_Called_RetunsOkWithListOfModules()
        {
            IUnitOfWork    unitOfWork    = Substitute.For <IUnitOfWork>();
            ICookieManager cookieManager = Substitute.For <ICookieManager>();

            var testModules = new List <Module>()
            {
                new Module(), new Module(), new Module(), new Module()
            };

            unitOfWork.Modules.GetAll().Returns(testModules);

            var modulesController = new ModulesController(unitOfWork, cookieManager);

            var result = await modulesController.GetAll();

            var okObjectResult = Assert.IsType <OkObjectResult>(result);
            var returnValue    = Assert.IsType <List <Module> >(okObjectResult.Value);

            Assert.Equal(testModules.Count, returnValue.Count);
        }
        public void TestMethod1()
        {
            //Arrangement
            // 1 - Un acces à la base de donnée (ConnectionString)
            // 2 - EntityFrameword à mettre en place
            // 3 - Package MVC
            // 4 - Acces au projet

            //Acte

            //  instancier le controller à tester
            int tested      = 3;
            var _controller = new ModulesController();

            var _result = _controller.Details(3);

            var _viewResult = _result.Result as ViewResult;

            var _model1 = _viewResult.Model as Module;

            Assert.AreEqual(tested, _model1.Id, " Votre module n'existe pas");
        }
        public async Task ShouldGetAllModules_GetAllModules()
        {
            var           mockRepo   = new Mock <IDataRepository>();
            List <Module> moduleData = Modules();

            mockRepo.Setup(repo => repo.ModuleListAsync()).
            ReturnsAsync(moduleData);

            ModulesController controller = new ModulesController(mockRepo.Object);

            var result = await controller.GetAllModules();

            Assert.IsInstanceOfType(result.Result, typeof(OkObjectResult));

            var okResult = result.Result as OkObjectResult;
            var modules  = okResult.Value as List <Module>;

            Assert.AreEqual(2, modules.Count);

            Assert.AreEqual(moduleData[0], modules[0]);
            Assert.AreEqual(moduleData[1], modules[1]);
        }
        public async Task ShouldGetModulesForValidYear_GetModulesByYear()
        {
            string year     = "2020";
            var    mockRepo = new Mock <IDataRepository>();

            mockRepo.Setup(repo => repo.ModulesByYearListAsync(year)).
            ReturnsAsync(ModulesInYear2020());

            ModulesController controller = new ModulesController(mockRepo.Object);
            var result = await controller.GetModulesByYear(year);

            Assert.IsInstanceOfType(result.Result, typeof(OkObjectResult));

            var okResult = result.Result as OkObjectResult;
            var modules  = okResult.Value as List <Module>;

            Assert.AreEqual(2, modules.Count);

            foreach (Module m in modules)
            {
                Assert.AreEqual("2020", m.Year);
            }
        }