示例#1
0
        public void Setup()
        {
            _actioningUserId = Guid.NewGuid();
            _actioningUser = new UserForAuditing() { Id = _actioningUserId };

            _userForAuditingRepo = new Mock<IUserForAuditingRepository>();
            _userForAuditingRepo
                .Setup(x => x.GetByIdAndCompanyId(_actioningUserId, _companyId))
                .Returns(_actioningUser);

            _responsibilityRepo = new Mock<IResponsibilityRepository>();
            _responsibility = new Mock<Responsibility>();
            _responsibility
                .Setup(x => x.HasUndeletedTasks())
                .Returns(false);

            _responsibility
                .Setup(x => x.MarkForDelete(_actioningUser));

            _responsibilityRepo
                .Setup(x => x.GetByIdAndCompanyId(_responsibilityId, _companyId))
                .Returns(_responsibility.Object);

            _log = new Mock<IPeninsulaLog>();

        }
示例#2
0
        public void Given_FCM_is_reocurring_weekly_Then_when_it_is_completed_Then_following_task_should_be_created_with_due_date_a_week_later()
        {
            var assignedTo = new Employee { Id = Guid.NewGuid() };
            var user1= new UserForAuditing { Id = Guid.NewGuid() };
            var user2= new UserForAuditing { Id = Guid.NewGuid() };

            var furtherControlMeasureTask = HazardousSubstanceRiskAssessmentFurtherControlMeasureTask.Create(
                "FCM",
                "Test FCM",
                "Description",
                new DateTime(2012, 09, 13),
                TaskStatus.Outstanding,
                assignedTo,
                user1,
                new System.Collections.Generic.List<CreateDocumentParameters>
                    {
                        new CreateDocumentParameters
                            {
                                DocumentLibraryId = 2000L,
                                Description = "Test File 1",
                                DocumentType = new DocumentType {Id = 5L},
                                Filename = "Test File 1.txt"
                            }
                    },
                new TaskCategory {Id = 9L},
                (int) TaskReoccurringType.Weekly,
                new DateTime(2013, 09, 13),
                false,
                false,
                false,
                false,
                Guid.NewGuid());

            furtherControlMeasureTask.Complete("Test Comments", new List<CreateDocumentParameters>(), new List<long>(), user2, null, DateTime.Now);

            Assert.IsNotNull(furtherControlMeasureTask.FollowingTask);
            Assert.AreEqual(furtherControlMeasureTask,
                            furtherControlMeasureTask.FollowingTask.
                                PrecedingTask);
            Assert.AreEqual(furtherControlMeasureTask.Reference,
                            furtherControlMeasureTask.FollowingTask.Reference);
            Assert.AreEqual(furtherControlMeasureTask.Title,
                            furtherControlMeasureTask.FollowingTask.Title);
            Assert.AreEqual(furtherControlMeasureTask.Description,
                            furtherControlMeasureTask.FollowingTask.Description);
            Assert.AreEqual(new DateTime(2012, 09, 20),
                                         furtherControlMeasureTask.FollowingTask.TaskCompletionDueDate);
            Assert.AreEqual(furtherControlMeasureTask.TaskAssignedTo.Id,
                            furtherControlMeasureTask.FollowingTask.TaskAssignedTo.Id);
            Assert.AreEqual(user2.Id,
                            furtherControlMeasureTask.FollowingTask.CreatedBy.Id);
            Assert.AreEqual(1, furtherControlMeasureTask.FollowingTask.Documents.Count);
            Assert.AreEqual(furtherControlMeasureTask.Documents[0].DocumentLibraryId, furtherControlMeasureTask.FollowingTask.Documents[0].DocumentLibraryId);
            Assert.AreEqual(furtherControlMeasureTask.Documents[0].Description, furtherControlMeasureTask.FollowingTask.Documents[0].Description);
            Assert.AreEqual(furtherControlMeasureTask.Documents[0].DocumentType.Id, furtherControlMeasureTask.FollowingTask.Documents[0].DocumentType.Id);
            Assert.AreEqual(furtherControlMeasureTask.Documents[0].Filename, furtherControlMeasureTask.FollowingTask.Documents[0].Filename);
            Assert.AreEqual(furtherControlMeasureTask.Category.Id, furtherControlMeasureTask.FollowingTask.Category.Id);
            Assert.AreEqual(furtherControlMeasureTask.TaskReoccurringType, furtherControlMeasureTask.FollowingTask.TaskReoccurringType);
            Assert.AreEqual(furtherControlMeasureTask.TaskReoccurringEndDate, furtherControlMeasureTask.FollowingTask.TaskReoccurringEndDate);
        }
        public virtual void UpdateSummary(string title, string reference, DateTime? assessmentDate, RiskAssessor riskAssessor, Site site, UserForAuditing currentUser)
        {
            if (IsDifferentRiskAssessor(riskAssessor))
            {
                if (AreThereAnyFurtherControlMeasureTasks())
                {
                    Hazards
                        .Where(h => h.FurtherControlMeasureTasks != null)
                        .SelectMany(h => h.FurtherControlMeasureTasks)
                        .ToList()
                        .ForEach(task =>
                                     {
                                         task.SendTaskCompletedNotification = riskAssessor == null ? true : !riskAssessor.DoNotSendTaskCompletedNotifications;
                                         task.SendTaskOverdueNotification = riskAssessor == null ? true : !riskAssessor.DoNotSendTaskOverdueNotifications;
                                         task.SetLastModifiedDetails(currentUser);
                                     });
                }
            }

            Title = title;
            Reference = reference;
            RiskAssessor = riskAssessor;
            AssessmentDate = assessmentDate;
            RiskAssessmentSite = site;
            SetLastModifiedDetails(currentUser);

        }
        public void Given_significant_finding_with_further_control_measure_tasks_When_mark_as_delete_Then_sets_correct_properties()
        {
            // Given
            var user = new UserForAuditing();
            var significantFinding = new SignificantFinding
            {
                FurtherControlMeasureTasks = new List<FireRiskAssessmentFurtherControlMeasureTask>
                                                 {
                                                     new FireRiskAssessmentFurtherControlMeasureTask
                                                         {
                                                             Deleted = false
                                                         }
                                                         ,
                                                         new FireRiskAssessmentFurtherControlMeasureTask
                                                         {
                                                             Deleted = false
                                                         }
                                                 }
            };

            // When
            significantFinding.MarkForDelete(user);

            // Then
            Assert.That(significantFinding.FurtherControlMeasureTasks.Count(x => x.Deleted), Is.EqualTo(2));
        }
 public void SetUp()
 {
     _sourceOFIgnitionRepository = new Mock<ISourceOfIgnitionRepository>();
     _user = new UserForAuditing();
     _userRepository = new Mock<IUserForAuditingRepository>();
     _log = new Mock<IPeninsulaLog>();
 }
        public void Given_valid_request_When_update_supplier_Then_should_call_correct_methods()
        {
            // Given
            var target = CreateRolesService();

            var request = new SaveSupplierRequest()
                              {
                                  UserId = Guid.NewGuid(),
                                  Name = "Updated Supplier Name",
                                  CompanyId = 2
                              };

            var user = new UserForAuditing();
            _usersRepository
                .Setup(s => s.GetByIdAndCompanyId(request.UserId, request.CompanyId))
                .Returns(user);

            var supplier = new Mock<Supplier>();
            _suppliersRepository
                .Setup(x => x.GetByIdAndCompanyId(request.Id, request.CompanyId))
                .Returns(supplier.Object);


            // When
            target.UpdateSupplier(request);

            // Then
            _suppliersRepository.Verify(x => x.SaveOrUpdate(supplier.Object));
            supplier.Verify(x => x.Update(request.Name, user));
        }
 public void SetUp()
 {
     _nonEmployeeRepository = new Mock<INonEmployeeRepository>();
     _userRepository = new Mock<IUserForAuditingRepository>();
     _user = new UserForAuditing();
     _log = new Mock<IPeninsulaLog>();
 }
示例#8
0
        public void Given_task_is_reocurring_When_Complete_called_Then_task_is_completed()
        {
            var employee = new Employee { Id = Guid.NewGuid() };
            var user = new User { Id = Guid.NewGuid(), Employee = employee };
            var userForAuditing = new UserForAuditing { Id = Guid.NewGuid() };

            var createDocumentParameterObjects1 = new List<CreateDocumentParameters>
                                                     {
                                                         new CreateDocumentParameters
                                                             {
                                                                 DocumentLibraryId = 726L
                                                             }
                                                     };

            var site = new Site { Id = 5232L };

            var task = ResponsibilityTask.Create(
                "Test Title 1",
                "Test Description 1",
                new DateTime(2050, 10, 01),
                TaskStatus.Outstanding,
                employee,
                userForAuditing,
                createDocumentParameterObjects1,
                new TaskCategory { Id = 4323L },
                (int)TaskReoccurringType.Monthly,
                new DateTime(2051, 10, 01),
                false,
                true,
                true,
                true,
                Guid.NewGuid(),
                site,
                new Responsibility());

            var createDocumentParameterObjects2 = new List<CreateDocumentParameters>
                                                     {
                                                         new CreateDocumentParameters
                                                             {
                                                                 DocumentLibraryId = 2344L
                                                             }
                                                     };

            task.Complete(
                "Completed Comments 1",
                createDocumentParameterObjects2,
                new List<long>(),
                userForAuditing,
                user
                );

            Assert.That(task.TaskStatus, Is.EqualTo(TaskStatus.Completed));
            Assert.That(task.TaskCompletedComments, Is.EqualTo("Completed Comments 1"));
            Assert.That(task.Documents.Count, Is.EqualTo(2));
            Assert.That(task.TaskCompletedBy, Is.EqualTo(userForAuditing));
            Assert.That(task.LastModifiedBy, Is.EqualTo(userForAuditing));
            Assert.That(task.LastModifiedOn.HasValue, Is.True);
            Assert.That(task.FollowingTask, Is.Not.Null);
            Assert.That(task.FollowingTask.TaskCompletionDueDate, Is.EqualTo(new DateTime(2050, 11, 01)));
        }
        public void Given_hazards_Then_should_detach_correctly()
        {
            //Given
            var user = new UserForAuditing();
            var target = GeneralRiskAssessment.Create("", "", default(long), null);

            var hazardDetaching = new Hazard()
                             {
                                 Id = 1
                             };
            var hazardToRemain = new Hazard()
                             {
                                 Id = 2
                             };
            IEnumerable<Hazard> hazards = new[]
                                              {
                                                  hazardDetaching, 
                                                  hazardToRemain,  
                                              };
            target.AttachHazardsToRiskAssessment(hazards, user);
            
            
            //When
            target.DetachHazardsFromRiskAssessment(new List<Hazard> { hazardDetaching }, user);

            //Then
            Assert.That(target.Hazards.Count(x => !x.Deleted), Is.EqualTo(1));
            Assert.That(target.LastModifiedBy, Is.EqualTo(user));
        }
示例#10
0
        public static FireAnswer Create(
            FireRiskAssessmentChecklist fireRiskAssessmentChecklist,
            Question question,
            YesNoNotApplicableEnum? yesNoNotApplicableResponse,
            string additionalInfo,
            UserForAuditing user)
        {
            var fireAnswer = new FireAnswer
                                 {
                                     FireRiskAssessmentChecklist = fireRiskAssessmentChecklist,
                                     Question = question,
                                     YesNoNotApplicableResponse = yesNoNotApplicableResponse,
                                     AdditionalInfo = additionalInfo,
                                     CreatedOn = DateTime.Now,
                                     CreatedBy = user
                                 };

            if (yesNoNotApplicableResponse == YesNoNotApplicableEnum.No)
            {
                var significantFinding = SignificantFinding.Create(fireAnswer, user);
                fireAnswer.SignificantFinding = significantFinding;
            }

            return fireAnswer;
        }
示例#11
0
        public virtual void Update(YesNoNotApplicableEnum? newAnswer, string additionalInfo, UserForAuditing user)
        {
            if (!IsAnswerDifferent(newAnswer, additionalInfo))
                return;

            if (newAnswer != YesNoNotApplicableEnum.No)
            {
                if (SignificantFinding != null)
                {
                    SignificantFinding.MarkForDelete(user);
                }
            }
            else if (newAnswer == YesNoNotApplicableEnum.No)
            {
                if (SignificantFinding == null)
                {
                    SignificantFinding = SignificantFinding.Create(this, user);
                }
                else
                {
                    SignificantFinding.ReinstateFromDelete(user);
                }
            }

            YesNoNotApplicableResponse = newAnswer;
            AdditionalInfo = additionalInfo;
            SetLastModifiedDetails(user);
        }
        public void Given_valid_request_When_MarkRiskAssessorAsDeleted_Then_should_call_correct_methods()
        {
            // Given
            var target = GetTarget();
            var request = new MarkRiskAssessorAsDeletedAndUndeletedRequest()
                              {
                                  CompanyId = 100,
                                  UserId = Guid.NewGuid(),
                                  RiskAssessorId = 400
                              };


            var user = new UserForAuditing();
            _userForAuditingRepository
                .Setup(x => x.GetByIdAndCompanyId(request.UserId, request.CompanyId))
                .Returns(user);

            _riskAssessmentRepository
                .Setup(x => x.DoesAssessmentExistForRiskAssessor(request.RiskAssessorId, request.CompanyId))
                .Returns(false);

            var riskAssessor = new Mock<RiskAssessor>();
            _riskAssessorRepository
                .Setup(x => x.GetByIdAndCompanyId(request.RiskAssessorId, request.CompanyId))
                .Returns(riskAssessor.Object);

            // When
            target.MarkDeleted(request);

            // Then
            _riskAssessmentRepository.VerifyAll();
            riskAssessor.Verify(x => x.MarkForDelete(user));
            _userForAuditingRepository.VerifyAll();
            _riskAssessorRepository.Verify(x => x.SaveOrUpdate(riskAssessor.Object));
        }
        public void Given_valid_request_to_disable_user_Then_should_delete_user()
        {
            //Given
            var target = CreateUserService();

            var actioningUserId = Guid.NewGuid();
            var actioningUser = new UserForAuditing() { Id = actioningUserId };

            var userId = Guid.NewGuid();
            var userToDelete = new Mock<User>() { CallBase = true };
            userToDelete.Setup(x => x.Id).Returns(userId);
            userToDelete.Setup(x => x.AuthenticationTokens).Returns(new List<AuthenticationToken>());

            _userForAuditingRepo
                .Setup(x => x.GetById(actioningUserId))
                .Returns(actioningUser);

            _userRepo
                .Setup(x => x.GetById(userId))
                .Returns(userToDelete.Object);

            //When
            target.DeleteUser(userId, actioningUserId);

            //Then
            Assert.That(userToDelete.Object.Deleted, Is.True);
        }
        public static PersonalRiskAssessment Create(
            string title,
            string reference,
            long clientId,
            UserForAuditing currentUser,
            string location,
            string taskProcessDescription,
            Site site,
            DateTime? assessmentDate,
            RiskAssessor riskAssessor,
            bool IsSensitive
            )
        {
            var riskAssessment = new PersonalRiskAssessment
                                     {
                                         Title = title,
                                         Reference = reference,
                                         AssessmentDate = assessmentDate,
                                         RiskAssessmentSite = site,
                                         RiskAssessor = riskAssessor,
                                         Location = location,
                                         TaskProcessDescription = taskProcessDescription,
                                         CompanyId = clientId,
                                         CreatedBy = currentUser,
                                         CreatedOn = DateTime.Now,
                                         Status = RiskAssessmentStatus.Draft,
                                         Sensitive = IsSensitive
                                     };

            return riskAssessment;
        }
        public void Given_valid_request_When_mark_for_live_Then_calls_the_correct_methods()
        {
            //Given
            var riskAssessmentService = CreateRiskAssessmentService();

            var request = new MarkRiskAssessmentAsLiveRequest()
                              {
                                  CompanyId = 100,
                                  UserId = Guid.NewGuid(),
                                  RiskAssessmentId = 200
                              };

            var user = new UserForAuditing();
            _userRepository
                .Setup(x => x.GetByIdAndCompanyId(request.UserId, request.CompanyId))
                .Returns(user);

            var mockRiskAssessment = new Mock<BusinessSafe.Domain.Entities.HazardousSubstanceRiskAssessment>();
            _riskAssessmentRepository
                .Setup(rr => rr.GetByIdAndCompanyId(request.RiskAssessmentId, request.CompanyId))
                .Returns(mockRiskAssessment.Object);


            //When
            riskAssessmentService.MarkRiskAssessmentAsLive(request);

            //Then
            _riskAssessmentRepository.Verify(x => x.SaveOrUpdate(mockRiskAssessment.Object));
            mockRiskAssessment.Verify(x => x.MarkAsLive(user));
        }
        public void When_reassign_Then_should_set_properties_correctly()
        {
            //Given
            var document = new TaskDocument()
                               {
                                   Description = "Woo hoo",
                                   DocumentLibraryId = 1,
                                   DocumentType = new DocumentType(),
                                   Extension = ".biz",
                                   Filename = "FooBar",
                                   FilesizeByte = 2000
                               };

            var user = new UserForAuditing();
            

            //When
            var result = document.CloneForReoccurring(user);

            //Then
            Assert.That(result.DocumentLibraryId, Is.EqualTo(document.DocumentLibraryId));
            Assert.That(result.Filename, Is.EqualTo(document.Filename));
            Assert.That(result.Extension, Is.EqualTo(document.Extension));
            Assert.That(result.FilesizeByte, Is.EqualTo(document.FilesizeByte));
            Assert.That(result.Description, Is.EqualTo(document.Description));
            Assert.That(result.CreatedBy, Is.EqualTo(user));
            Assert.That(result.DocumentType, Is.EqualTo(document.DocumentType));
            Assert.That(result.CreatedOn.Value.Date, Is.EqualTo(DateTime.Now.Date));
        }
        public void Given_multiple_safety_control_measure_to_add_When_Attach_Then_should_be_added_correctly()
        {
            //Given
            var user = new UserForAuditing();
            var fireRiskAssessment = FireRiskAssessment.Create("title", "reference", 100, new Checklist(), user);

            IEnumerable<FireSafetyControlMeasure> fireSafetControlMeasuresToAttach = new List<FireSafetyControlMeasure>()
                                                                                         {
                                                                                             new FireSafetyControlMeasure()
                                                                                                 {
                                                                                                     Id = 1,
                                                                                                     
                                                                                                 },
                                                                                            new FireSafetyControlMeasure()
                                                                                                 {
                                                                                                     Id = 2,
                                                                                                 }
                                                                                            ,
                                                                                            new FireSafetyControlMeasure()
                                                                                                 {
                                                                                                     Id = 3,
                                                                                                 }
                                                                                         };

            //When
            fireRiskAssessment.AttachFireSafetyControlMeasuresToRiskAssessment(fireSafetControlMeasuresToAttach, user);

            //Then
            Assert.That(fireRiskAssessment.FireSafetyControlMeasures.Count(x => x.FireSafetyControlMeasure.Id == 1), Is.EqualTo(1));
            Assert.That(fireRiskAssessment.FireSafetyControlMeasures.Count(x => x.FireSafetyControlMeasure.Id == 2), Is.EqualTo(1));
            Assert.That(fireRiskAssessment.FireSafetyControlMeasures.Count(x => x.FireSafetyControlMeasure.Id == 3), Is.EqualTo(1));
        }
示例#18
0
        public void Given_a_existing_yes_answer_but_update_no_and_have_a_deleted_significant_finding_When_answer_updated_Then_should_set_properties_as_expected()
        {
            // Given
            var user = new UserForAuditing();
            var fireRiskAssessmentChecklist = new FireRiskAssessmentChecklist();
            var question = new Question();

            var target = FireAnswer.Create(fireRiskAssessmentChecklist, question, YesNoNotApplicableEnum.Yes, "Additional Info", user);
            target.SignificantFinding = new SignificantFinding()
                                            {
                                                Deleted = true
                                            };
            
            // When
            target.Update(YesNoNotApplicableEnum.No, "Additional Info", user);

            // Then
            Assert.That(target.SignificantFinding, Is.Not.Null);
            Assert.That(target.SignificantFinding.Deleted, Is.False);
            Assert.That(target.FireRiskAssessmentChecklist, Is.EqualTo(fireRiskAssessmentChecklist));
            Assert.That(target.YesNoNotApplicableResponse, Is.EqualTo(YesNoNotApplicableEnum.No));
            Assert.That(target.AdditionalInfo, Is.EqualTo("Additional Info"));
            Assert.That(target.LastModifiedOn.Value.ToShortDateString(), Is.EqualTo(DateTime.Now.ToShortDateString()));
            Assert.That(target.LastModifiedBy, Is.EqualTo(user));
        }
        public void Given_all_required_fields_are_available_Then_create_user_method_creates_an_object()
        {
            //Given
            Guid userId = Guid.NewGuid();
            const long companyId = 33749;
            const long siteId = 324234L;
            var role = new Role() { Id = new Guid("BACF7C01-D210-4DBC-942F-15D8456D3B92") };
            var user = new UserForAuditing() { Id = new Guid("B03C83EE-39F2-4F88-B4C4-7C276B1AAD99") };
            var site = new Site() {Id = siteId};
            var employeeContactDetail = new EmployeeContactDetail {Email = "*****@*****.**"};
            var employee = new Employee {Forename = "Gary", Surname = "Green",ContactDetails = new List<EmployeeContactDetail> {employeeContactDetail}};

            //When
            var result = User.CreateUser(userId, companyId, role, site, employee, user);

            //Then
            Assert.That(result.Id, Is.EqualTo(userId));
            Assert.That(result.CompanyId, Is.EqualTo(companyId));
            Assert.That(result.Site.Id, Is.EqualTo(siteId));
            Assert.That(result.Employee, Is.Not.Null);
            Assert.That(result.Employee.Forename, Is.EqualTo("Gary"));
            Assert.That(result.Employee.Surname, Is.EqualTo("Green"));
            Assert.That(result.Employee.ContactDetails, Is.Not.Null);
            Assert.That(result.Employee.ContactDetails.Count, Is.EqualTo(1));
            Assert.That(result.Employee.ContactDetails[0].Email, Is.EqualTo("*****@*****.**"));
        }
示例#20
0
        public void Given_valid_request_to_enable_user_Then_should_call_appropiate_methods()
        {
            //Given
            var target = CreateUSerService();
            var userId = Guid.NewGuid();
            var currentUserId = Guid.NewGuid();
            const int companyId = 100;
            var currentUser = new UserForAuditing();
            var user = new Mock<User>();
            user.Setup(x => x.Deleted).Returns(true);

            _userForAuditingRepo
                .Setup(x => x.GetByIdAndCompanyId(currentUserId, companyId))
                .Returns(currentUser);


            _userForAuditingRepo
                .Setup(x => x.GetById(currentUserId))
                .Returns(currentUser);


            _userRepo
                .Setup(x => x.GetByIdAndCompanyIdIncludeDeleted(userId, companyId))
                .Returns(user.Object);

            //When
            target.ReinstateUser(userId, companyId, currentUserId);

            //Then
            user.Verify(x => x.ReinstateFromDelete(currentUser));
            _userRepo.Verify(x => x.SaveOrUpdate(user.Object));
        }
        public void Given_multiple_sources_of_fuel_to_add_When_Attach_Then_should_be_added_correctly()
        {
            //Given
            var user = new UserForAuditing();
            var fireRiskAssessment = FireRiskAssessment.Create("title", "reference", 100, new Checklist(), user);

            IEnumerable<SourceOfFuel> sourceOfFuels = new List<SourceOfFuel>()
                                                                  {
                                                                      new SourceOfFuel()
                                                                          {
                                                                              Id = 1,
                                                                                                     
                                                                          },
                                                                      new SourceOfFuel()
                                                                          {
                                                                              Id = 2,
                                                                          }
                                                                      ,
                                                                      new SourceOfFuel()
                                                                          {
                                                                              Id = 3,
                                                                          }
                                                                  };

            //When
            fireRiskAssessment.AttachSourceOfFuelsToRiskAssessment(sourceOfFuels, user);

            //Then
            Assert.That(fireRiskAssessment.FireRiskAssessmentSourcesOfFuel.Count(x => x.SourceOfFuel.Id == 1), Is.EqualTo(1));
            Assert.That(fireRiskAssessment.FireRiskAssessmentSourcesOfFuel.Count(x => x.SourceOfFuel.Id == 2), Is.EqualTo(1));
            Assert.That(fireRiskAssessment.FireRiskAssessmentSourcesOfFuel.Count(x => x.SourceOfFuel.Id == 3), Is.EqualTo(1));
        }
        public void Given_valid_request_When_reinstate_Then_calls_the_correct_methods()
        {
            //Given
            var riskAssessmentService = CreateRiskAssessmentService();

            var user = new UserForAuditing();
            _userRepository
                .Setup(x => x.GetByIdAndCompanyId(_userId, CompanyId))
                .Returns(user);

            var mockRiskAssessment = new Mock<GeneralRiskAssessment>();
            _riskAssessmentRepository
                .Setup(rr => rr.GetByIdAndCompanyIdIncludeDeleted(RiskAssessmentId, CompanyId))
                .Returns(mockRiskAssessment.Object);

            //When
            riskAssessmentService.ReinstateRiskAssessmentAsNotDeleted(new ReinstateRiskAssessmentAsDeletedRequest()
                                                                          {
                                                                              CompanyId = CompanyId,
                                                                              RiskAssessmentId = RiskAssessmentId,
                                                                              UserId = _userId
                                                                          }); 

            //Then
            _riskAssessmentRepository.Verify(x => x.SaveOrUpdate(mockRiskAssessment.Object));
            mockRiskAssessment.Verify(x => x.ReinstateRiskAssessmentAsNotDeleted(user));
        }
        public void Given_completed_further_control_measure_task_When_mark_as_delete_Then_task_is_not_deleted()
        {
            // Given
            var user = new UserForAuditing();
            var significantFinding = new SignificantFinding
            {
                FurtherControlMeasureTasks = new List<FireRiskAssessmentFurtherControlMeasureTask>
                                                 {
                                                     new FireRiskAssessmentFurtherControlMeasureTask
                                                         {
                                                             Deleted = false,
                                                             TaskStatus = TaskStatus.Overdue
                                                         }
                                                         ,
                                                    new FireRiskAssessmentFurtherControlMeasureTask
                                                         {
                                                             Deleted = false,
                                                             TaskStatus = TaskStatus.Completed
                                                         }
                                                 }
            };

            // When
            significantFinding.MarkForDelete(user);

            // Then
            Assert.That(significantFinding.FurtherControlMeasureTasks.Count(x => x.Deleted), Is.EqualTo(1));            
        }
        public void When_MarkForDelete_Then_should_call_correct_methods()
        {
            // Given
            var request = new MarkHazardousSubstanceAsDeleteRequest()
                              {
                                  CompanyId = 1,
                                  HazardousSubstanceId = 200,
                                  UserId = Guid.NewGuid()
                              };

            hazardousSubstanceRiskAssessmentRepository
                .Setup(x => x.DoesRiskAssessmentsExistForHazardousSubstance(request.HazardousSubstanceId, request.CompanyId))
                .Returns(false);


            var user = new UserForAuditing();
            userRepository
                .Setup(x => x.GetByIdAndCompanyId(request.UserId, request.CompanyId))
                .Returns(user);

            var hazardousSubstance = new Mock<HazardousSubstance>();
            hazardousSubstanceRepository
                .Setup(x => x.GetByIdAndCompanyId(request.HazardousSubstanceId, request.CompanyId))
                .Returns(hazardousSubstance.Object);

            // When
            target.MarkForDelete(request);

            // Then
            hazardousSubstanceRiskAssessmentRepository.VerifyAll();
            hazardousSubstance.Verify(x => x.MarkForDelete(user));
            hazardousSubstanceRepository.Verify(x => x.SaveOrUpdate(hazardousSubstance.Object));
        }
        public void When_clone_for_risk_assessment_templating_Then_should_have_correct_result()
        {
            //Given
            var user = new UserForAuditing();
            var riskAssessment = new GeneralRiskAssessment();
            var hazard = new Hazard();

            var riskAssessmentHazard = MultiHazardRiskAssessmentHazard.Create(riskAssessment, hazard, user);
            riskAssessmentHazard.UpdateDescription("Test Description", user);

            var controlMeasure1 = new MultiHazardRiskAssessmentControlMeasure();
            var controlMeasure2 = new MultiHazardRiskAssessmentControlMeasure();
            riskAssessmentHazard.AddControlMeasure(controlMeasure1, user);
            riskAssessmentHazard.AddControlMeasure(controlMeasure2, user);


            //When
            var result = riskAssessmentHazard.CloneForRiskAssessmentTemplating(user, riskAssessment);

            //Then
            Assert.That(result.Description, Is.EqualTo(riskAssessmentHazard.Description));
            Assert.That(result.MultiHazardRiskAssessment, Is.EqualTo(riskAssessment));
            Assert.That(result.Hazard, Is.EqualTo(hazard));
            Assert.That(result.CreatedBy, Is.EqualTo(user));
            Assert.That(result.CreatedOn.Value.Date, Is.EqualTo(DateTime.Now.Date));
            Assert.That(result.ControlMeasures.Count, Is.EqualTo(riskAssessmentHazard.ControlMeasures.Count));
        }
        public void Given_employee_is_assignee_then__dont_return__task_due_in_2days()
        {
            //GIVEN

            var employee = new Employee() { Id = Guid.NewGuid(), NotificationType = NotificationType.Daily };
            var furthcontrolmersuretasks = new FireRiskAssessmentFurtherControlMeasureTask() { TaskAssignedTo = employee, TaskStatus = TaskStatus.Outstanding, TaskCompletionDueDate = DateTime.Now.AddDays(2) };
            var significantFinding = new SignificantFinding() { };
            significantFinding.FurtherControlMeasureTasks.Add(furthcontrolmersuretasks);
            furthcontrolmersuretasks.SignificantFinding = significantFinding;
            var riskAssessement = FireRiskAssessment.Create("this is the title", "the ref", 1312, null, new UserForAuditing { Id = Guid.NewGuid() });

            var user = new UserForAuditing();
            var fireRiskAssessmentChecklist = riskAssessement.FireRiskAssessmentChecklists[0];
            var question = new Question();

            var fireAnswer = FireAnswer.Create(fireRiskAssessmentChecklist, question, YesNoNotApplicableEnum.No, "Additional Info", user);
            fireAnswer.SignificantFinding = significantFinding;
            significantFinding.FireAnswer = fireAnswer;

            riskAssessement.FireRiskAssessmentChecklists[0].Answers = new List<FireAnswer>() { fireAnswer };

            _fireRiskAssessments.Add(riskAssessement);

            var target =
                new GetDueFireRiskAssessmentFurtherControlMeasureTasksForEmployeeQuery(
                    _queryableWrapper.Object);

            //WHEN
            var result = target.Execute(employee.Id, null);

            //THEN
            Assert.That(result.Count, Is.EqualTo(0));

        }
        public override void Complete(
            string completedComments,
            IEnumerable<CreateDocumentParameters> createDocumentParameterObjects,
            IEnumerable<long> documentLibraryIdsToRemove,
            UserForAuditing userForAuditing,
            User user,
            DateTimeOffset completedDate)
        {
            //Addition conditions for completeing a FurtherControlMeasureTask.
            if (TaskStatus == TaskStatus.NoLongerRequired)
            {
                throw new AttemptingToCompleteFurtherControlMeasureTaskThatIsNotRequiredException();
            }

            if (!CanUserComplete(user))
            {
                throw new AttemptingToCompleteFurtherControlMeasureTaskThatTheUserDoesNotHavePermissionToAccess(Id);
            }

            base.Complete(
                completedComments,
                createDocumentParameterObjects,
                documentLibraryIdsToRemove,
                userForAuditing,
                user,
                completedDate);
        }
 public void SetUp()
 {
     _userRepository = new Mock<IUserForAuditingRepository>();
     _tasksRepository = new Mock<ITasksRepository>();
     _user = new UserForAuditing();
     _log = new Mock<IPeninsulaLog>();
 }
示例#29
0
        public void When_Update_Then_new_values_set()
        {
            var site = new Site();
            var hasAccessToAllSites = true;
            var doNotSendReviewDueNotification = true;
            var doNotSendTaskOverdueNotifications = true;
            var doNotSendTaskCompletedNotifications = true;
            var user = new UserForAuditing();

            // Given
            var riskAssessor = new RiskAssessor();

            // When
            riskAssessor.Update(
                site,
                hasAccessToAllSites,
                doNotSendReviewDueNotification,
                doNotSendTaskOverdueNotifications,
                doNotSendTaskCompletedNotifications,
                user
                );

            // Then
            Assert.That(riskAssessor.Site == site);
            Assert.That(riskAssessor.HasAccessToAllSites == hasAccessToAllSites);
            Assert.That(riskAssessor.DoNotSendReviewDueNotification == doNotSendReviewDueNotification);
            Assert.That(riskAssessor.DoNotSendTaskOverdueNotifications == doNotSendTaskOverdueNotifications);
            Assert.That(riskAssessor.DoNotSendTaskCompletedNotifications == doNotSendTaskCompletedNotifications);
            Assert.That(riskAssessor.LastModifiedBy == user);
            Assert.That(riskAssessor.LastModifiedOn.Value.ToShortDateString() == DateTime.Today.ToShortDateString());
        }
        public void Setup()
        {
            _accidentRecordRepository = new Mock<IAccidentRecordRepository>();
            _accidentTypeRepository = new Mock<IAccidentTypeRepository>();
            _causeOfAccidentRepository = new Mock<ICauseOfAccidentRepository>();
            _jurisdictionRepository = new Mock<IJurisdictionRepository>();
            _userForAuditingRepository = new Mock<IUserForAuditingRepository>();
            _countriesRepository = new Mock<ICountriesRepository>();
            _employeeRepository = new Mock<IEmployeeRepository>();
            _siteRepository = new Mock<ISiteRepository>();
            _log = new Mock<IPeninsulaLog>();

            _companyId = 1234L;

            _user = new UserForAuditing {Id = Guid.NewGuid(), CompanyId = _companyId};

            _userForAuditingRepository
                .Setup(x => x.GetByIdAndCompanyId(It.IsAny<Guid>(), It.IsAny<long>()))
                .Returns(
                _user);

            _accidentRecord = new Mock<AccidentRecord>();

            _accidentRecordRepository
                .Setup(x => x.GetByIdAndCompanyId(It.IsAny<long>(), It.IsAny<long>()))
                .Returns(_accidentRecord.Object);
        }