public void Initialise()
        {
           this.plugin = new ExcessAndDeductibleDataSetValidationPlugin();
           this.componentMetadata = MockRepository.GenerateStub<IComponentMetadata>();
          // var headerVersionBuilder = new BusinessComponentBuilder<HeaderVersion>().Build();
          // var sdvBuilder = new BusinessComponentBuilder<SectionDetailVersion>().Build();
          // var coverageBuilder = new BusinessComponentBuilder<CoverageVersion>().Build();
            var hdr = new BusinessComponentBuilder<Header>()
                .Add(new BusinessComponentBuilder<HeaderVersion>()
                    .SetProperty(a => a.IsLatestVersion = true))
                .Add(new BusinessComponentBuilder<Section>()
                    .Add(new BusinessComponentBuilder<SectionVersion>()
                        .SetProperty(a => a.IsLatestVersion = true))
                    .Add(new BusinessComponentBuilder<SectionDetail>()
                        .Add(new BusinessComponentBuilder<SectionDetailVersion>()
                            .SetProperty(a => a.IsLatestVersion = true))
                        .Add(new BusinessComponentBuilder<Coverage>()
                            .Add(new BusinessComponentBuilder<CoverageVersion>()
                                .SetProperty(a => a.IsLatestVersion = true))))).Build();

            this.componentMetadata = MockRepository.GenerateStub<IComponentMetadata>();
            var genericDataTypeVersion = new ProductBuilder<GenericDataTypeVersion>(this.componentMetadata).Build();
            genericDataTypeVersion.GenericDataTypeComponent = new GenericDataType { Code = "AND2" };

            this.header = hdr;
            this.headerVersion = this.header.HeaderVersions[0];
            this.headerVersion.CreateGenericDataSet();
            this.sectionDetailVersion = this.header.Sections[0].SectionDetails[0].SectionDetailVersions[0];
            this.sectionDetailVersion.CreateGenericDataSet();
            this.coverageVersion = this.header.Sections[0].SectionDetails[0].Coverages[0].CoverageVersions[0];
            this.coverageVersion.CreateGenericDataSet();

            this.businessTransaction = MockRepository.GenerateStub<IBusinessTransaction>();
            this.businessTransaction.Component = hdr;

            var metadata = MockRepository.GenerateStub<IMetadataQuery>();
            metadata.Stub(a => a.GetGenericDataTypeVersion(0, DateTime.Now)).IgnoreArguments().Return(new GenericDataTypeVersion { GenericDataTypeVersionID = 0 });
            var container = new UnityContainer();
            container.RegisterInstance<IMetadataQuery>(metadata);
            container.RegisterInstance<IComponentMetadata>(this.componentMetadata);
            container.RegisterInstance<IMessageService>(new MockMessagingService());
            ObjectFactory.Instance = new ObjectFactory(container);
        }
        public void Initialize()
        {
            /*
            var container = new UnityContainer();
            var componentMetadata = MockRepository.GenerateStub<IComponentMetadata>();
            container.RegisterInstance<IComponentMetadata>(componentMetadata);

            var product = new ProductBuilder<ProductVersion>(componentMetadata)
                            .Add(new ProductBuilder<ProductClaimDefinition>(componentMetadata))
                         .Build();

            this.productClaimDefinition = product.ProductClaimDefinition;

            ObjectFactory.Instance = new ObjectFactory(container);
             */
            
            var clmHeader = new BusinessComponentBuilder<ClaimHeader>()
                .SetProperty(a => a.ClaimProductVersionID = 1)
                .SetProperty(a => a.ClaimReference = "AXATEST")
                .Build();

            this.claimHeader = clmHeader; // new ClaimHeader() { ClaimProductVersionID = 0, ClaimReference = "AXATEST" };
        }
        public void Initialise()
        {
            var container = new UnityContainer();

            this.RegisterAuthorityChecks(container);

            var claimTransaction = new BusinessComponentBuilder<ClaimTransactionHeader>();

            this.currentUser = CreateUser("CurrenUserIdentity", 1, 10);
            this.targetUser1 = CreateUser("TargetUser1Identity", 2, 10);
            this.targetUser2 = CreateUser("TargetUser2Identity", 3, 0);

            var componentMetadata = MockRepository.GenerateStub<IComponentMetadata>();
            container.RegisterInstance<IComponentMetadata>(componentMetadata);
            var product = new ProductBuilder<ProductVersion>(componentMetadata)
                            .SetProperty(a => a.GradeStructureType = GradeStructureCode) 
                            .Add(new ProductBuilder<ProductClaimDefinition>(componentMetadata)
                                .SetProperty(a => a.IsManualAuthorisationAlwaysAllowedIfNoChecksAreActive = true))
                         .Build();

            this.productClaimDefinition = product.ProductClaimDefinition;

            ObjectFactory.Instance = new ObjectFactory(container);

            var clmHeader = new BusinessComponentBuilder<ClaimHeader>()
                      .Add(new BusinessComponentBuilder<ClaimDetail>()
                      .As(out claimDetailRef)
                       .SetProperty(a => a.PolicyLinkLevel = (short)StaticValues.PolicyLinkLevel.Header)
                       .SetProperty(a => a.ProductClaimDetailID = 1)
                       .SetProperty(a => a.ClaimDetailReference = "Claim Detail Reference"))
                      .Add(new BusinessComponentBuilder<ClaimTransactionHeader>()
                        .SetProperty(a => a.IsInProgress = true)
                        .Add(new BusinessComponentBuilder<ClaimTransactionGroup>()
                            .AddRef(claimDetailRef)
                            .SetProperty(a => a.AdministerClaimMethod = 2)))
                  .Build();

            clmHeader.ClaimHeaderAnalysisCode01 = ClaimConstants.CH_ANALYSISCODE_MOTOR;

            this.claimHeader = clmHeader;
            var claimsEntities = MockRepository.GenerateStub<IClaimsQuery>();
            claimsEntities.Stub(a => a.GetClaimTransactionHeader(0)).IgnoreArguments().Return(this.claimHeader.InProgressClaimTransactionHeaders.Single());
            container.RegisterInstance<IClaimsQuery>(claimsEntities);

            this.gradesforStructure = new List<Grade> { CreateGrade(GradeCode2, 3), CreateGrade(GradeCode1, 1) };
            this.usersForGradeCode1 = new List<User> { this.currentUser, this.targetUser1 };
            this.usersForGradeCode2 = new List<User>();
            this.eventDestinations = new List<IEventDestination> { CreateEventDestination(this.targetUser1.UserIdentity, "1"), CreateEventDestination(this.targetUser1.UserIdentity, "2") };

            this.metadataEntities = MockRepository.GenerateStub<IMetadataQuery>();
            this.metadataEntities.Stub(a => a.GetUserIdByUserIdentity(this.currentUser.UserIdentity)).Return(this.currentUser.UserID);
            this.metadataEntities.Stub(a => a.GetUserGradeCode(this.currentUser.UserID, GradeStructureCode, StaticValues.GradeType.Claims)).Do(new Func<long, string, StaticValues.GradeType, string>((x, y, z) => this.userGradeCode));
            this.metadataEntities.Stub(a => a.GetGradesForGradeStructure(GradeStructureCode)).Return(this.gradesforStructure);
            this.metadataEntities.Stub(a => a.GetUsersByGradeCode(GradeCode1)).Return(this.usersForGradeCode1);
            this.metadataEntities.Stub(a => a.GetUsersByGradeCode(GradeCode2)).Return(this.usersForGradeCode2);
            container.RegisterInstance(this.metadataEntities);

            var taskService = MockRepository.GenerateStub<ITaskService>();
            taskService.Stub(a => a.GetActiveEventDestinations(null, null, DateTime.Now, DateTime.Now)).IgnoreArguments().Return(this.eventDestinations);
            taskService.Stub(a => a.GetFinishedEventDestinationByDateRange(null, null, DateTime.Now, DateTime.Now)).IgnoreArguments().Return(this.eventDestinations);
            container.RegisterInstance(taskService);


            IAXAClaimsQuery claimsQuery = MockRepository.GenerateStub<IAXAClaimsQuery>();
            claimsQuery.Stub(s => s.IsUserOutOfOffice(Arg<long>.Is.Anything, out Arg<string>.Out(String.Empty).Dummy)).Return(false);
            container.RegisterInstance<IAXAClaimsQuery>(claimsQuery);

            this.businessSupportRole = ClaimsBusinessLogicHelper.ResolveMandatoryConfig<string>("BusinessSupportRole");
        }