public async void TestCreateAgreement_WithLimitsClause()
        {
            // Arrange
            var service  = CreateService();
            var enrollee = new EnrolleeFactory().Generate();

            enrollee.Submissions = new[]
            {
                new Submission
                {
                    AgreementType = AgreementType.OboTOA,
                    CreatedDate   = DateTimeOffset.Now,
                }
            };
            var noteText = "oh dear";

            enrollee.AccessAgreementNote = new AccessAgreementNote {
                Note = noteText
            };
            TestDb.Has(enrollee);

            // Act
            await service.CreateEnrolleeAgreementAsync(enrollee.Id);

            // Assert
            AssertAgreementGeneration(enrollee, expectedLimitsClauseText: noteText);
        }
        public async void TestCreateAgreement(AgreementType determinedType)
        {
            // Arrange
            var service  = CreateService();
            var enrollee = new EnrolleeFactory().Generate();

            enrollee.Submissions = new[]
            {
                new Submission
                {
                    AgreementType = determinedType,
                    CreatedDate   = DateTimeOffset.Now,
                }
            };
            enrollee.AccessAgreementNote = null;
            TestDb.Has(enrollee);

            var expectedAgreementId = TestDb.AgreementVersions
                                      .Where(a => a.AgreementType == determinedType)
                                      .OrderByDescending(a => a.EffectiveDate)
                                      .Select(a => a.Id)
                                      .First();

            // Act
            await service.CreateEnrolleeAgreementAsync(enrollee.Id);

            // Assert
            AssertAgreementGeneration(enrollee, expectedAgreementId);
        }
        public async void TestCreateAgreement_RegulatedUser(CareSettingType careSetting)
        {
            // Arrange
            var service  = CreateService();
            var enrollee = new EnrolleeFactory().Generate();

            enrollee.EnrolleeCareSettings.Single().CareSettingCode = (int)careSetting;
            enrollee.Certifications      = new CertificationFactory(enrollee).Generate(1, "default,licence.regulated");
            enrollee.AccessAgreementNote = null;
            TestDb.Has(enrollee);
            TestDb.Entry(enrollee.Certifications.Single()).Reference(c => c.License).Load();

            int expectedAgreementId = 0;

            switch (careSetting)
            {
            case CareSettingType.CommunityPractice:
                expectedAgreementId = TestDb.AgreementVersions.GetNewestIdOfType <RegulatedUserAgreement>();
                break;

            case CareSettingType.CommunityPharmacy:
                expectedAgreementId = TestDb.AgreementVersions.GetNewestIdOfType <CommunityPharmacistAgreement>();
                break;
            }

            // Act
            await service.CreateEnrolleeAgreementAsync(enrollee.Id);

            // Assert
            AssertAgreementGeneration(enrollee, expectedAgreementId);
        }
Exemplo n.º 4
0
        public async void TestCertificationRule(OperationMode[] apiModes, bool expected, StatusReasonType[] expectedReasons)
        {
            Enrollee enrollee = new EnrolleeFactory().Generate();

            UpdateCertifications(enrollee, apiModes.Length);
            var rule = new PharmanetValidationRule(new CollegeLicenceClientMock(enrollee, apiModes));

            Assert.Equal(expected, await rule.ProcessRule(enrollee));
            AssertReasons(enrollee.CurrentStatus.EnrolmentStatusReasons, expectedReasons);
        }
Exemplo n.º 5
0
        public async void TestAddressRule(bool physInBc, bool?mailInBc, bool expected)
        {
            Enrollee enrollee = new EnrolleeFactory().Generate();

            UpdateAddresses(enrollee, physInBc, mailInBc);
            var rule = new AddressRule();

            Assert.Equal(expected, await rule.ProcessRule(enrollee));
            if (expected)
            {
                AssertReasons(enrollee.CurrentStatus.EnrolmentStatusReasons);
            }
            else
            {
                AssertReasons(enrollee.CurrentStatus.EnrolmentStatusReasons, StatusReasonType.Address);
            }
        }
Exemplo n.º 6
0
        public async void TestSelfDeclarationRule(SelfDeclarationFlag declaration, bool expected)
        {
            Enrollee enrollee = new EnrolleeFactory().Generate();

            UpdateSelfDeclaration(enrollee, declaration);
            var rule = new SelfDeclarationRule();

            Assert.Equal(expected, await rule.ProcessRule(enrollee));
            if (expected)
            {
                AssertReasons(enrollee.CurrentStatus.EnrolmentStatusReasons);
            }
            else
            {
                AssertReasons(enrollee.CurrentStatus.EnrolmentStatusReasons, StatusReasonType.SelfDeclaration);
            }
        }
Exemplo n.º 7
0
        // TODO Get Licence loaded onto Certificate
        // [InlineData(1, false, true)]
        // [InlineData(1, true, false)]
        public async void TestLicenceClassRule(int licenseCount, bool isManual, bool expected)
        {
            Enrollee enrollee = new EnrolleeFactory().Generate();

            UpdateCertifications(enrollee, licenseCount, isManual);

            var rule = new LicenceClassRule();

            Assert.Equal(expected, await rule.ProcessRule(enrollee));
            if (expected)
            {
                AssertReasons(enrollee.CurrentStatus.EnrolmentStatusReasons);
            }
            else
            {
                AssertReasons(enrollee.CurrentStatus.EnrolmentStatusReasons, StatusReasonType.LicenceClass);
            }
        }
Exemplo n.º 8
0
        public async void TestPumpProviderRule(bool isProvider, bool isPumpProvider, bool expected)
        {
            Enrollee enrollee = new EnrolleeFactory().Generate();

            UpdateDeviceProvider(enrollee, isProvider, isPumpProvider);

            var rule = new DeviceProviderRule();

            Assert.Equal(expected, await rule.ProcessRule(enrollee));
            if (expected)
            {
                AssertReasons(enrollee.CurrentStatus.EnrolmentStatusReasons);
            }
            else
            {
                AssertReasons(enrollee.CurrentStatus.EnrolmentStatusReasons, StatusReasonType.PumpProvider);
            }
        }
        public async void TestCreateAgreement_WithLimitsClause()
        {
            // Arrange
            var service  = CreateService();
            var enrollee = new EnrolleeFactory().Generate();
            var noteText = "oh dear";

            enrollee.AccessAgreementNote = new AccessAgreementNote {
                Note = noteText
            };
            TestDb.Has(enrollee);

            // Act
            await service.CreateEnrolleeAgreementAsync(enrollee.Id);

            // Assert
            AssertAgreementGeneration(enrollee, expectedLimitsClauseText: noteText);
        }
        public async void TestCreateAgreement_Obo(CareSettingType careSetting)
        {
            // Arrange
            var service  = CreateService();
            var enrollee = new EnrolleeFactory().Generate();

            enrollee.EnrolleeCareSettings.Single().CareSettingCode = (int)careSetting;
            enrollee.Certifications.Clear();
            enrollee.AccessAgreementNote = null;
            TestDb.Has(enrollee);

            var expectedAgreementId = TestDb.AgreementVersions.GetNewestIdOfType <OboAgreement>();

            // Act
            await service.CreateEnrolleeAgreementAsync(enrollee.Id);

            // Assert
            AssertAgreementGeneration(enrollee, expectedAgreementId);
        }
        public async void TestCreateAgreement_LicencedObo(CareSettingType careSetting)
        {
            // Arrange
            var service  = CreateService();
            var enrollee = new EnrolleeFactory().Generate();

            enrollee.EnrolleeCareSettings.Single().CareSettingCode = (int)careSetting;
            enrollee.Certifications      = new CertificationFactory(enrollee).Generate(1, "default,licence.nonRegulated");
            enrollee.AccessAgreementNote = null;
            TestDb.Has(enrollee);
            TestDb.Entry(enrollee.Certifications.Single()).Reference(c => c.License).Load();

            var expectedAgreementId = TestDb.AgreementVersions.GetNewestIdOfType <OboAgreement>();

            // Act
            await service.CreateEnrolleeAgreementAsync(enrollee.Id);

            // Assert
            AssertAgreementGeneration(enrollee, expectedAgreementId);
        }
        public async void TestCreateAgreement_ThrowsWhenNull()
        {
            // Arrange
            var service  = CreateService();
            var enrollee = new EnrolleeFactory().Generate();

            enrollee.Submissions = new[]
            {
                new Submission
                {
                    AgreementType = null,
                    CreatedDate   = DateTimeOffset.Now,
                }
            };
            enrollee.AccessAgreementNote = null;
            TestDb.Has(enrollee);

            // Act
            // Assert
            await Assert.ThrowsAsync <InvalidOperationException>(() => service.CreateEnrolleeAgreementAsync(enrollee.Id));
        }