public void Test(string value, bool mandatory, int errorCount)
        {
            DomainSpec domainSpec = _parser.Parse(value, mandatory);

            Assert.That(domainSpec.Domain, Is.EqualTo(value));
            Assert.That(domainSpec.ErrorCount, Is.EqualTo(errorCount));
        }
Exemple #2
0
        public DomainSpec Parse(string domainSpecString, bool mandatory)
        {
            DomainSpec domainSpec = new DomainSpec(domainSpecString);

            if (string.IsNullOrEmpty(domainSpecString))
            {
                if (mandatory)
                {
                    string message  = string.Format(SpfParserResource.NoValueErrorMessage, "domain");
                    string markdown = string.Format(SpfParserMarkdownResource.NoValueErrorMessage, "domain");
                    Guid   id       = Guid.Parse("5E60D21F-A543-4263-9525-FE6E2E330E52");

                    domainSpec.AddError(new Error(id, ErrorType.Error, message, markdown));
                }
            }
            else if (!_domainRegex.IsMatch(domainSpecString) && !_macroRegex.IsMatch(domainSpecString))
            {
                string message  = string.Format(SpfParserResource.InvalidValueErrorMessage, "domain or macro", domainSpecString);
                string markdown = string.Format(SpfParserMarkdownResource.InvalidValueErrorMessage, "domain or macro", domainSpecString);
                Guid   id       = Guid.Parse("38A767C4-B795-4B57-8779-5D535B4347BB");

                domainSpec.AddError(new Error(id, ErrorType.Error, message, markdown));
            }

            return(domainSpec);
        }
Exemple #3
0
        public DomainSpec Parse(string domainSpecString, bool mandatory)
        {
            DomainSpec domainSpec = new DomainSpec(domainSpecString);

            if (string.IsNullOrEmpty(domainSpecString))
            {
                if (mandatory)
                {
                    string errorMessgae = string.Format(SpfParserResource.NoValueErrorMessage, "domain");
                    domainSpec.AddError(new Error(ErrorType.Error, errorMessgae));
                }
            }
            else if (!_domainRegex.IsMatch(domainSpecString) && !_macroRegex.IsMatch(domainSpecString))
            {
                string errorMessage = string.Format(SpfParserResource.InvalidValueErrorMessage, "domain or macro", domainSpecString);
                domainSpec.AddError(new Error(ErrorType.Error, errorMessage));
            }

            return(domainSpec);
        }
        public Term Parse(string mechanism, Qualifier qualifier, string arguments, Func <string, Qualifier, DomainSpec, DualCidrBlock, Term> termFactory)
        {
            string domainSpecString = string.Empty;
            string ip4CidrString    = string.Empty;
            string ip6CidrString    = string.Empty;

            if (!string.IsNullOrEmpty(arguments))
            {
                Match match = _regex.Match(arguments);
                if (match.Success)
                {
                    domainSpecString = match.Groups["domain_spec"].Value;
                    ip4CidrString    = match.Groups["ip4_cidr"].Value;
                    ip6CidrString    = match.Groups["ip6_cidr"].Value;
                }
            }

            DomainSpec    domainSpec     = _domainSpecParser.Parse(domainSpecString, false);
            DualCidrBlock dualCiderBlock = _dualCidrBlockParser.Parse(ip4CidrString, ip6CidrString);

            return(termFactory(mechanism, qualifier, domainSpec, dualCiderBlock));
        }
        //"ptr" [ ":" domain-spec]
        public Term Parse(string mechanism, Qualifier qualifier, string arguments)
        {
            DomainSpec domainSpec = _domainSpecParser.Parse(arguments, false);

            return(new Ptr(mechanism, qualifier, domainSpec));
        }
        public Term Parse(string modifier, string arguments)
        {
            DomainSpec domainSpec = _domainSpecParser.Parse(arguments, true);

            return(new Redirect(modifier, domainSpec));
        }
        public Term Parse(string modifier, string arguments)
        {
            DomainSpec domainSpec = _domainSpecParser.Parse(arguments, true);

            return(new Explanation(modifier, domainSpec));
        }
        //"include" ":" domain-spec
        public Term Parse(string mechanism, Qualifier qualifier, string arguments)
        {
            DomainSpec domainSpec = _domainSpecParser.Parse(arguments, true);

            return new Include(mechanism, qualifier, domainSpec);
        }