コード例 #1
0
ファイル: WasteTypeTests.cs プロジェクト: DEFRA/prsd-iws
 public void EwcCodeNull_Throws()
 {
     Assert.Throws <ArgumentNullException>(() => new WasteType(ImportNotificationId,
                                                               "WasteTypeName",
                                                               BaselOecdCode.CreateNotListed(),
                                                               null,
                                                               YCode.CreateNotApplicable(),
                                                               HCode.CreateNotApplicable(),
                                                               UnClass.CreateNotApplicable(),
                                                               ChemicalComposition.Other));
 }
コード例 #2
0
        private HCode CreateHCode(bool notApplicable, IEnumerable <Guid> codeIds)
        {
            if (notApplicable)
            {
                return(HCode.CreateNotApplicable());
            }

            var wasteCodes = Task.Run(() => wasteCodeRepository.GetWasteCodesByIds(codeIds)).Result;

            return(HCode.CreateFor(wasteCodes));
        }
コード例 #3
0
ファイル: WasteTypeTests.cs プロジェクト: DEFRA/prsd-iws
        public void UnClassNotApplicable_NotApplicableTrue()
        {
            var wasteType = new WasteType(ImportNotificationId,
                                          "WasteTypeName",
                                          BaselOecdCode.CreateNotListed(),
                                          EwcCode.CreateFor(new[] { AnyWasteCode(CodeType.Ewc) }),
                                          YCode.CreateNotApplicable(),
                                          HCode.CreateNotApplicable(),
                                          UnClass.CreateNotApplicable(),
                                          ChemicalComposition.Other);

            Assert.True(wasteType.UnClassNotApplicable);
        }
コード例 #4
0
ファイル: WasteTypeTests.cs プロジェクト: DEFRA/prsd-iws
 public void UnsetChemicalComposition_Throws()
 {
     Assert.Throws <ArgumentException>(() => new WasteType(ImportNotificationId,
                                                           "Name",
                                                           BaselOecdCode.CreateNotListed(),
                                                           EwcCode.CreateFor(new[]
     {
         AnyWasteCode(CodeType.Ewc)
     }),
                                                           YCode.CreateNotApplicable(),
                                                           HCode.CreateNotApplicable(),
                                                           UnClass.CreateNotApplicable(),
                                                           default(ChemicalComposition)));
 }
コード例 #5
0
ファイル: WasteTypeTests.cs プロジェクト: DEFRA/prsd-iws
 public void UnClassNull_Throws()
 {
     Assert.Throws <ArgumentNullException>(() => new WasteType(ImportNotificationId,
                                                               "WasteTypeName",
                                                               BaselOecdCode.CreateNotListed(),
                                                               EwcCode.CreateFor(new[]
     {
         AnyWasteCode(CodeType.Ewc)
     }),
                                                               YCode.CreateNotApplicable(),
                                                               HCode.CreateNotApplicable(),
                                                               null,
                                                               ChemicalComposition.Other));
 }
コード例 #6
0
ファイル: WasteTypeTests.cs プロジェクト: DEFRA/prsd-iws
 public void ImportNotificationIdDefaultValue_Throws()
 {
     Assert.Throws <ArgumentException>(() => new WasteType(Guid.Empty,
                                                           "WasteTypeName",
                                                           BaselOecdCode.CreateNotListed(),
                                                           EwcCode.CreateFor(new[]
     {
         AnyWasteCode(CodeType.Ewc)
     }),
                                                           YCode.CreateNotApplicable(),
                                                           HCode.CreateNotApplicable(),
                                                           UnClass.CreateNotApplicable(),
                                                           ChemicalComposition.Other));
 }
コード例 #7
0
ファイル: WasteTypeTests.cs プロジェクト: DEFRA/prsd-iws
        public void UnClassesAreSet()
        {
            var unCode   = AnyWasteCode(CodeType.Un);
            var unCodeId = new Guid("4B50E7AA-0136-444A-9185-FE31BE6CF98E");

            ObjectInstantiator <WasteCode> .SetProperty(x => x.Id, unCodeId, unCode);

            var wasteType = new WasteType(ImportNotificationId,
                                          "WateTypeName",
                                          BaselOecdCode.CreateNotListed(),
                                          EwcCode.CreateFor(new[] { AnyWasteCode(CodeType.Ewc) }),
                                          YCode.CreateNotApplicable(),
                                          HCode.CreateNotApplicable(),
                                          UnClass.CreateFor(new[] { unCode }),
                                          ChemicalComposition.Other);

            Assert.Equal(1, wasteType.WasteCodes.Count(wc => wc.WasteCodeId == unCodeId));
        }
コード例 #8
0
ファイル: WasteTypeTests.cs プロジェクト: DEFRA/prsd-iws
        public void YCodesAreSet()
        {
            var yCode   = AnyWasteCode(CodeType.Y);
            var yCodeId = new Guid("F416BD1D-56E9-45D8-9A4E-7476DF201AB2");

            ObjectInstantiator <WasteCode> .SetProperty(x => x.Id, yCodeId, yCode);

            var wasteType = new WasteType(ImportNotificationId,
                                          "WateTypeName",
                                          BaselOecdCode.CreateNotListed(),
                                          EwcCode.CreateFor(new[] { AnyWasteCode(CodeType.Ewc) }),
                                          YCode.CreateFor(new[] { yCode }),
                                          HCode.CreateNotApplicable(),
                                          UnClass.CreateNotApplicable(),
                                          ChemicalComposition.Other);

            Assert.Equal(1, wasteType.WasteCodes.Count(wc => wc.WasteCodeId == yCodeId));
        }
コード例 #9
0
ファイル: WasteTypeTests.cs プロジェクト: DEFRA/prsd-iws
        public void EwcCodesAreSet()
        {
            var ewcCode   = AnyWasteCode(CodeType.Ewc);
            var ewcCodeId = new Guid("A4DA3323-B6BD-4245-B144-B9E05661BEC6");

            ObjectInstantiator <WasteCode> .SetProperty(x => x.Id, ewcCodeId, ewcCode);

            var wasteType = new WasteType(ImportNotificationId,
                                          "WateTypeName",
                                          BaselOecdCode.CreateNotListed(),
                                          EwcCode.CreateFor(new[] { ewcCode }),
                                          YCode.CreateNotApplicable(),
                                          HCode.CreateNotApplicable(),
                                          UnClass.CreateNotApplicable(),
                                          ChemicalComposition.Other);

            Assert.Equal(1, wasteType.WasteCodes.Count(wc => wc.WasteCodeId == ewcCodeId));
        }
コード例 #10
0
ファイル: WasteTypeTests.cs プロジェクト: DEFRA/prsd-iws
        public void OecdCodeIsSet()
        {
            var oecdCode   = AnyWasteCode(CodeType.Oecd);
            var oecdCodeId = new Guid("A58E7CE8-FA46-4E35-A3ED-26E395678CA0");

            ObjectInstantiator <WasteCode> .SetProperty(x => x.Id, oecdCodeId, oecdCode);

            var wasteType = new WasteType(ImportNotificationId,
                                          "WasteTypeName",
                                          BaselOecdCode.CreateFor(oecdCode),
                                          EwcCode.CreateFor(new[] { AnyWasteCode(CodeType.Ewc) }),
                                          YCode.CreateNotApplicable(),
                                          HCode.CreateNotApplicable(),
                                          UnClass.CreateNotApplicable(),
                                          ChemicalComposition.Other);

            Assert.Equal(1, wasteType.WasteCodes.Count(wc => wc.WasteCodeId == oecdCodeId));
        }
コード例 #11
0
ファイル: WasteTypeTests.cs プロジェクト: DEFRA/prsd-iws
        public void BaselCodeIsSet()
        {
            var baselCode   = AnyWasteCode(CodeType.Basel);
            var baselCodeId = new Guid("72669DEE-1126-47B3-8C45-2395F54C82D8");

            ObjectInstantiator <WasteCode> .SetProperty(x => x.Id, baselCodeId, baselCode);

            var wasteType = new WasteType(ImportNotificationId,
                                          "WasteTypeName",
                                          BaselOecdCode.CreateFor(baselCode),
                                          EwcCode.CreateFor(new[] { AnyWasteCode(CodeType.Ewc) }),
                                          YCode.CreateNotApplicable(),
                                          HCode.CreateNotApplicable(),
                                          UnClass.CreateNotApplicable(),
                                          ChemicalComposition.Other);

            Assert.Equal(1, wasteType.WasteCodes.Count(wc => wc.WasteCodeId == baselCodeId));
        }