public void AddWork_Post_Test()
        {
            // Act
            var       uow       = new UnitOfWorkFakeFactory().Uow.Object;
            const int jobId     = 1;
            var       paramUser = new AddWorkModel()
            {
                JobId = jobId,
                Texts = new List <TextModel>()
                {
                    new TextModel()
                    {
                        Language = uow.LanguagesRepository.Get().ToList()[0], Value = "NewJob.fr"
                    },
                    new TextModel()
                    {
                        Language = uow.LanguagesRepository.Get().ToList()[1], Value = "NewJob.en"
                    }
                }
            };

            var expected = paramUser.ToDto(uow.JobsRepository.Get().ToList(),
                                           uow.LanguagesRepository.Get().ToList());

            expected.Id = uow.WorksRepository.Get().Count() + 1;

            var nbWorks = uow.WorksRepository.Get().ToList().Count;
            var result  = new IntroductionController(uow).AddWork(paramUser) as RedirectToRouteResult;

            // Assert
            Assert.IsNotNull(result);
            Assert.AreEqual(result.RouteValues["Action"], nameof(IntroductionController.ShowJobs));
            Assert.AreEqual(nbWorks + 1, uow.WorksRepository.Get().Count());
            AssertExtension.PropertyValuesAreEquals(expected, uow.WorksRepository.Get().Last());
        }
Esempio n. 2
0
 public ActionResult AddWork(AddWorkModel model)
 {
     if (ModelState.IsValid)
     {
         _uow.WorksRepository.Insert(model.ToDto(_uow.JobsRepository.Get().ToList(), _uow.LanguagesRepository.Get().ToList()));
         _uow.Save();
         return(RedirectToAction(nameof(ShowJobs)));
     }
     return(RedirectToAction(nameof(AddWork)));
 }
        public void Should_Transform_AddWorkModel_To_Work()
        {
            var jobs = new List <Job>()
            {
                new Job()
                {
                    Id = 1, Works = new List <Work>()
                },
                new Job()
                {
                    Id = 2, Works = new List <Work>()
                },
            };

            var expected = new Work()
            {
                Id = 1,
                DisplayPriority = 1,
                Job             = jobs[0],
                Texts           = new List <Text>()
                {
                    new Text()
                    {
                        Language = _languages[0], Value = "wk1.fr"
                    },
                    new Text()
                    {
                        Language = _languages[1], Value = "wk1.en"
                    }
                }
            };

            var act = new AddWorkModel()
            {
                DisplayPriority = 1,
                JobId           = 1,
                Texts           = new List <TextModel>()
                {
                    new TextModel()
                    {
                        Language = _languages[0], Value = "wk1.fr"
                    },
                    new TextModel()
                    {
                        Language = _languages[1], Value = "wk1.en"
                    }
                }
            };

            var result = act.ToDto(jobs, _languages);

            Assert.AreEqual(expected.Job, result.Job);
            Assert.AreEqual(expected.DisplayPriority, result.DisplayPriority);
            AssertExtension.CompareIEnumerable(expected.Texts, result.Texts, (x, y) => x.Language == y.Language && x.Value == y.Value);
        }
        public static Work ToDto(this AddWorkModel model, List <Job> jobs, List <Language> languages)
        {
            var dto = new Work()
            {
                Job             = jobs.First(x => x.Id == model.JobId),
                DisplayPriority = model.DisplayPriority,
                Texts           = model.Texts.ToDto(languages)
            };

            return(dto);
        }
        public void AddWork_Get_Test()
        {
            // Act
            var       uow            = new UnitOfWorkFakeFactory().Uow.Object;
            var       controller     = new IntroductionController(uow);
            const int workCategoryId = 1;
            var       expected       = new AddWorkModel()
            {
                JobId = workCategoryId,
                Texts = uow.LanguagesRepository.Get().Select(language => new TextModel()
                {
                    Language = language
                }).ToList()
            };

            var result = controller.AddWork(workCategoryId) as ViewResult;

            // Assert
            Assert.IsNotNull(result);
            AssertExtension.PropertyValuesAreEquals(expected, result.Model);
        }