Пример #1
0
        public void WithExcludedCountries()
        {
            OrthogonalRestrictionsFilter result = new OrthogonalRestrictionsFilterBuilder()
                                                  .WithExcludedCountries(new List <string> {
                "CO2"
            })
                                                  .Build();

            Assert.AreEqual("CO2", result.CountryRestriction.CountryCodes.Single());
            Assert.AreEqual("BLACKLIST", result.CountryRestriction.Inclusion);
            Assert.IsNull(result.TypeRestriction);
        }
Пример #2
0
        public void WithExcludedDocumentTypes()
        {
            OrthogonalRestrictionsFilter result = new OrthogonalRestrictionsFilterBuilder()
                                                  .WithExcludedDocumentTypes(new List <string> {
                "CO4"
            })
                                                  .Build();

            Assert.AreEqual("ORTHOGONAL_RESTRICTIONS", result.Type);
            Assert.AreEqual("CO4", result.TypeRestriction.DocumentTypes.Single());
            Assert.AreEqual("BLACKLIST", result.TypeRestriction.Inclusion);
            Assert.IsNull(result.CountryRestriction);
        }
Пример #3
0
        public void WithIncludedCountries()
        {
            OrthogonalRestrictionsFilter result = new OrthogonalRestrictionsFilterBuilder()
                                                  .WithIncludedCountries(new List <string> {
                "CO1"
            })
                                                  .Build();

            Assert.AreEqual("ORTHOGONAL_RESTRICTIONS", result.Type);
            Assert.AreEqual("CO1", result.CountryRestriction.CountryCodes.Single());
            Assert.AreEqual("WHITELIST", result.CountryRestriction.Inclusion);
            Assert.IsNull(result.TypeRestriction);
        }
        public void ShouldBuildWithCorrectFilterValue()
        {
            var filter = new OrthogonalRestrictionsFilterBuilder()
                         .WithIncludedCountries(new List <string> {
                "GBR", "FRA"
            })
                         .WithIncludedDocumentTypes(new List <string> {
                "PASSPORT", "STATE_ID"
            })
                         .Build();

            IssuingAuthoritySubCheck check =
                new IssuingAuthoritySubCheckBuilder()
                .WithFilter(filter)
                .Build();

            Assert.AreEqual(filter, check.Filter);
        }
        public void ShouldBuildWithIssuingAuthoritySubCheck()
        {
            var filter = new OrthogonalRestrictionsFilterBuilder()
                         .WithExcludedCountries(new List <string> {
                "GBR", "FRA"
            })
                         .WithExcludedDocumentTypes(new List <string> {
                "PASSPORT", "STATE_ID"
            })
                         .Build();

            RequestedDocumentAuthenticityCheck check =
                new RequestedDocumentAuthenticityCheckBuilder()
                .WithIssuingAuthoritySubCheck(filter)
                .Build();

            Assert.IsTrue(check.Config.IssuingAuthoritySubCheck.Requested);
            Assert.IsNotNull(check.Config.IssuingAuthoritySubCheck.Filter);
            Assert.AreEqual(filter, check.Config.IssuingAuthoritySubCheck.Filter);
        }