coppertone 0.0.1 → 0.0.2

data/lib/coppertone/qualifier.rb

@@ -27,6 +27,14 @@ module Coppertone
       @result_code = result_code
     end
 
+    def default?
+      text == DEFAULT_QUALIFIER_TEXT
+    end
+
+    def to_s
+      text
+    end
+
     PASS = new(DEFAULT_QUALIFIER_TEXT, Result::PASS)
     FAIL = new('-'.freeze, Result::FAIL)
     SOFTFAIL = new('~'.freeze, Result::SOFTFAIL)

data/lib/coppertone/record.rb

@@ -2,51 +2,17 @@ module Coppertone
   # Represents an SPF record.  Includes class level methods for parsing
   # record from a text string.
   class Record
-    VERSION_STR =  'v=spf1'
-    RECORD_REGEXP = /\A#{VERSION_STR}(\s|\z)/i
-    ALLOWED_CHARACTERS = /\A([\x21-\x7e ]+)\z/
-
     attr_reader :text
     def initialize(raw_text)
-      fail RecordParsingError if raw_text.blank?
-      fail RecordParsingError unless self.class.record?(raw_text)
-      fail RecordParsingError unless ALLOWED_CHARACTERS.match(raw_text)
-      @text = raw_text.dup
-      validate_and_parse
+      @terms = Coppertone::RecordTermParser.new(raw_text).terms
+      normalize_terms
     end
 
     def self.record?(record_text)
-      return false if record_text.blank?
-      RECORD_REGEXP.match(record_text.strip) ? true : false
-    end
-
-    def self.parse(text)
-      return nil unless record?(text)
-      new(text)
-    end
-
-    def validate_and_parse
-      text_without_prefix = text[VERSION_STR.length..-1]
-      @term_tokens = text_without_prefix.strip.split(/ /)
-      parse_terms
-    end
-
-    def parse_terms
-      @terms = []
-      @term_tokens.each do |token|
-        term = Term.build_from_token(token)
-        fail RecordParsingError,
-             "Could not parse record with #{text}" unless term
-        @terms << term
-      end
-      normalize_terms
+      Coppertone::RecordTermParser.record?(record_text)
     end
 
     def normalize_terms
-      # Discard any redirects if there is a directive with an
-      # all mechanism present
-      # Section 6.1
-      # TODO: PMG
       find_redirect # Checks for duplicate redirect modifiers
       exp # Checks for duplicate exp modifiers
     end
@@ -55,8 +21,21 @@ module Coppertone
       @directives ||= @terms.select { |t| t.is_a?(Coppertone::Directive) }
     end
 
+    def all_directive
+      @all_directive ||= directives.find(&:all?)
+    end
+
     def include_all?
-      directives.any? { |d| d.mechanism.is_a?(Coppertone::Mechanism::All) }
+      all_directive ? true : false
+    end
+
+    def default_result
+      return Result.neutral unless all_directive
+      Result.from_directive(all_directive)
+    end
+
+    def safe_to_include?
+      include_all?
     end
 
     def modifiers
@@ -68,8 +47,6 @@ module Coppertone
     end
 
     def redirect
-      # Ignore if an 'all' modifier is present
-      return nil if include_all?
       @redirect ||= find_redirect
     end
 
@@ -77,10 +54,25 @@ module Coppertone
       @exp ||= find_modifier(Coppertone::Modifier::Exp)
     end
 
+    KNOWN_MODS =
+      [Coppertone::Modifier::Exp, Coppertone::Modifier::Redirect]
+    def unknown_modifiers
+      @unknown_modifiers ||=
+        modifiers.select { |m| KNOWN_MODS.select { |k| m.is_a?(k) }.empty? }
+    end
+
     def find_modifier(klass)
       arr = modifiers.select { |m| m.is_a?(klass) }
-      fail RecordParsingError if arr.size > 1
+      fail DuplicateModifierError if arr.size > 1
       arr.first
     end
+
+    def self.version_str
+      Coppertone::RecordTermParser::VERSION_STR
+    end
+
+    def to_s
+      "#{self.class.version_str} #{@terms.map(&:to_s).join(' ')}"
+    end
   end
 end

data/lib/coppertone/record_finder.rb

@@ -11,7 +11,9 @@ module Coppertone
       @record ||=
         begin
           validate_txt_records
-          Record.parse(txt_records.first)
+          spf_dns_record = txt_records.first
+          return nil unless spf_dns_record
+          Record.new(spf_dns_record)
         end
     end
 

data/lib/coppertone/record_term_parser.rb

@@ -0,0 +1,30 @@
+module Coppertone
+  class RecordTermParser
+    VERSION_STR =  'v=spf1'
+    RECORD_REGEXP = /\A#{VERSION_STR}(\s|\z)/i
+    ALLOWED_CHARACTERS = /\A([\x21-\x7e ]+)\z/
+
+    def self.record?(text)
+      return false if text.blank?
+      RECORD_REGEXP.match(text.strip) ? true : false
+    end
+
+    attr_reader :terms
+    def initialize(text)
+      fail RecordParsingError unless self.class.record?(text)
+      fail RecordParsingError unless ALLOWED_CHARACTERS.match(text)
+      @terms = term_tokens(text).map { |token| parse_token(token) }
+    end
+
+    def term_tokens(text)
+      text_without_prefix = text[VERSION_STR.length..-1]
+      text_without_prefix.strip.split(/ /).select { |s| !s.blank? }
+    end
+
+    def parse_token(token)
+      term = Term.build_from_token(token)
+      fail RecordParsingError unless term
+      term
+    end
+  end
+end

data/lib/coppertone/request.rb

@@ -17,7 +17,7 @@ module Coppertone
       check_spf_for_mailfrom
       return mailfrom_result if mailfrom_result && !mailfrom_result.none?
 
-      no_matching_record? ? Result.none : Result.new(:neutral)
+      no_matching_record? ? Result.none : Result.neutral
     end
 
     def no_matching_record?
@@ -35,6 +35,8 @@ module Coppertone
     def check_spf_for_context(macro_context, identity)
       record = spf_record(macro_context)
       @result = spf_request(macro_context, record, identity) if record
+    rescue DNSAdapter::Error => e
+      Result.temperror(e.message)
     rescue Coppertone::TemperrorError => e
       Result.temperror(e.message)
     rescue Coppertone::PermerrorError => e

data/lib/coppertone/request_context.rb

@@ -1,5 +1,4 @@
 require 'active_support/core_ext/module/delegation'
-require 'coppertone/dns/resolv_client'
 
 module Coppertone
   # A container for information that should span the lifetime of
@@ -41,7 +40,7 @@ module Coppertone
         elsif Coppertone.config.dns_client_class
           Coppertone.config.dns_client_class.new
         else
-          Coppertone::DNS::ResolvClient.new
+          DNSAdapter::ResolvClient.new
         end
     end
 

data/lib/coppertone/result.rb

@@ -21,8 +21,8 @@ module Coppertone
       @mechanism = mechanism
     end
 
-    def self.from_directive(directive, code)
-      new(code, directive.mechanism)
+    def self.from_directive(directive)
+      new(directive.qualifier.result_code, directive.mechanism)
     end
 
     def self.permerror(message)
@@ -41,6 +41,10 @@ module Coppertone
       Result.new(:none)
     end
 
+    def self.neutral
+      Result.new(:neutral)
+    end
+
     %w(none pass fail softfail neutral temperror permerror).each do |t|
       define_method("#{t}?") do
         self.class.const_get(t.upcase) == send(:code)

data/lib/coppertone/utils/validated_domain_finder.rb

@@ -3,9 +3,11 @@ module Coppertone
     # A class used to find validated domains as defined in
     # section 5.5 of the RFC.
     class ValidatedDomainFinder
-      def initialize(macro_context, request_context)
+      attr_reader :subdomain_only
+      def initialize(macro_context, request_context, subdomain_only = true)
         @mc = macro_context
         @request_context = request_context
+        @subdomain_only = subdomain_only
       end
 
       def find(target_name)
@@ -27,10 +29,10 @@ module Coppertone
 
       def ptr_record_matches?(ip_checker,
                               target_name, ptr_name)
-        is_candidate =
-          DomainUtils.subdomain_or_same?(ptr_name, target_name)
+        is_candidate = !subdomain_only ||
+                       DomainUtils.subdomain_or_same?(ptr_name, target_name)
         is_candidate && ip_checker.check(ptr_name)
-      rescue Coppertone::DNS::Error
+      rescue DNSAdapter::Error
         # If a DNS error occurs when looking up a domain, treat it
         # as a non match
         false

data/lib/coppertone/version.rb

@@ -1,3 +1,3 @@
 module Coppertone  # rubocop:disable Style/Documentation
-  VERSION = '0.0.1'.freeze
+  VERSION = '0.0.2'.freeze
 end

data/lib/coppertone.rb

@@ -27,20 +27,22 @@ module Coppertone
   end
 end
 
+require 'dns_adapter'
 require 'coppertone/version'
 require 'coppertone/utils'
 require 'coppertone/error'
 require 'coppertone/request_count_limiter'
 require 'coppertone/sender_identity'
-require 'coppertone/dns'
 require 'coppertone/ip_address_wrapper'
 require 'coppertone/macro_context'
+require 'coppertone/null_macro_context'
 require 'coppertone/macro_string'
 require 'coppertone/request_context'
 require 'coppertone/domain_spec'
 require 'coppertone/directive'
 require 'coppertone/modifier'
 require 'coppertone/term'
+require 'coppertone/record_term_parser'
 require 'coppertone/record'
 require 'coppertone/record_evaluator'
 require 'coppertone/record_finder'

data/spec/directive_spec.rb

@@ -28,6 +28,19 @@ describe Coppertone::Directive do
     end
   end
 
+  context 'all?' do
+    it 'should be true when the directive is an all' do
+      expect(Coppertone::Directive.matching_term('+all')).to be_all
+      expect(Coppertone::Directive.matching_term('-all')).to be_all
+      expect(Coppertone::Directive.matching_term('~all')).to be_all
+      expect(Coppertone::Directive.matching_term('?all')).to be_all
+    end
+
+    it 'should be false otherwise' do
+      expect(Coppertone::Directive.matching_term('ip4:1.2.3.4')).not_to be_all
+    end
+  end
+
   context '.evaluate' do
     Coppertone::Qualifier.qualifiers.each do |q|
       it "returns a result with the expected code when it matches #{q.text}" do

data/spec/ip_address_wrapper_spec.rb

@@ -22,6 +22,7 @@ describe Coppertone::IPAddressWrapper do
       expect(ipw.c).to eq(ip_as_s)
       expect(ipw.i).to eq(ip_as_s)
       expect(ipw.v).to eq('in-addr')
+      expect(ipw.to_s).to eq(ip_as_s)
     end
 
     it 'should raise an ArgumentError when passed an IP with a prefix' do
@@ -42,6 +43,7 @@ describe Coppertone::IPAddressWrapper do
           'F.E.8.0.0.0.0.0.0.0.0.0.0.0.0.0.0.2.0.2.B.3.F.F.F.E.1.E.8.3.2.9'
         expect(ipw.i).to eq(dotted)
         expect(ipw.v).to eq('ip6')
+        expect(ipw.to_s).to eq(ip_as_s)
       end
     end
 
@@ -55,6 +57,7 @@ describe Coppertone::IPAddressWrapper do
         expect(ipw.c).to eq(ip_v4_as_s)
         expect(ipw.i).to eq(ip_v4_as_s)
         expect(ipw.v).to eq('in-addr')
+        expect(ipw.to_s).to eq(ip_as_s)
       end
     end
 

data/spec/macro_string_spec.rb

@@ -17,4 +17,24 @@ describe Coppertone::MacroString do
         .to eql(false)
     end
   end
+
+  context '#context_dependent?' do
+    it 'should return true when the macro string contains a macro' do
+      strs = ['abc.%{dr-}.%%.test.com', '%{l}.test.com', '%{d}', 'test.%{d}']
+      strs.each do |s|
+        macro_string = Coppertone::MacroString.new(s)
+        expect(macro_string).to be_context_dependent
+        expect(macro_string.to_s).to eq(s)
+      end
+    end
+
+    it 'should return false when the macro string does not contain a macro' do
+      strs = ['abc.%%.test.com', 'test.example.com', '%_', 'test']
+      strs.each do |s|
+        macro_string = Coppertone::MacroString.new(s)
+        expect(macro_string).not_to be_context_dependent
+        expect(macro_string.to_s).to eq(s)
+      end
+    end
+  end
 end

data/spec/mechanism/a_spec.rb

@@ -8,6 +8,7 @@ describe Coppertone::Mechanism::A do
       expect(mech.domain_spec).to be_nil
       expect(mech.ip_v4_cidr_length).to eq(32)
       expect(mech.ip_v6_cidr_length).to eq(128)
+      expect(mech.to_s).to eq('a')
     end
 
     it 'should not fail if called with a blank argument' do
@@ -16,6 +17,7 @@ describe Coppertone::Mechanism::A do
       expect(mech.domain_spec).to be_nil
       expect(mech.ip_v4_cidr_length).to eq(32)
       expect(mech.ip_v6_cidr_length).to eq(128)
+      expect(mech.to_s).to eq('a')
     end
 
     it 'should fail if called with an invalid macrostring' do
@@ -31,6 +33,7 @@ describe Coppertone::Mechanism::A do
         .to eq(Coppertone::DomainSpec.new('_spf.%{d}.example.com'))
       expect(mech.ip_v4_cidr_length).to eq(32)
       expect(mech.ip_v6_cidr_length).to eq(128)
+      expect(mech.to_s).to eq('a:_spf.%{d}.example.com')
     end
 
     it 'should parse a valid IP v4 CIDR length with a domain spec' do
@@ -38,8 +41,9 @@ describe Coppertone::Mechanism::A do
       expect(mech).not_to be_nil
       expect(mech.domain_spec)
         .to eq(Coppertone::DomainSpec.new('_spf.%{d}.example.com'))
-      expect(mech.ip_v4_cidr_length).to eq('28')
+      expect(mech.ip_v4_cidr_length).to eq(28)
       expect(mech.ip_v6_cidr_length).to eq(128)
+      expect(mech.to_s).to eq('a:_spf.%{d}.example.com/28')
     end
 
     it 'should fail if called with an invalid macrostring and IPv4 CIDR' do
@@ -52,8 +56,9 @@ describe Coppertone::Mechanism::A do
       mech = Coppertone::Mechanism::A.new('/28')
       expect(mech).not_to be_nil
       expect(mech.domain_spec).to be_nil
-      expect(mech.ip_v4_cidr_length).to eq('28')
+      expect(mech.ip_v4_cidr_length).to eq(28)
       expect(mech.ip_v6_cidr_length).to eq(128)
+      expect(mech.to_s).to eq('a/28')
     end
 
     it 'should not parse an invalid IP v4 CIDR length' do
@@ -72,7 +77,8 @@ describe Coppertone::Mechanism::A do
       expect(mech.domain_spec)
         .to eq(Coppertone::DomainSpec.new('_spf.%{d}.example.com'))
       expect(mech.ip_v4_cidr_length).to eq(32)
-      expect(mech.ip_v6_cidr_length).to eq('64')
+      expect(mech.ip_v6_cidr_length).to eq(64)
+      expect(mech.to_s).to eq('a:_spf.%{d}.example.com//64')
     end
 
     it 'should fail if called with an invalid macrostring and IPv6 CIDR' do
@@ -86,7 +92,8 @@ describe Coppertone::Mechanism::A do
       expect(mech).not_to be_nil
       expect(mech.domain_spec).to be_nil
       expect(mech.ip_v4_cidr_length).to eq(32)
-      expect(mech.ip_v6_cidr_length).to eq('64')
+      expect(mech.ip_v6_cidr_length).to eq(64)
+      expect(mech.to_s).to eq('a//64')
     end
 
     it 'should not parse an invalid IP v6 CIDR length' do
@@ -104,8 +111,9 @@ describe Coppertone::Mechanism::A do
       expect(mech).not_to be_nil
       expect(mech.domain_spec)
         .to eq(Coppertone::DomainSpec.new('_spf.%{d}.example.com'))
-      expect(mech.ip_v4_cidr_length).to eq('28')
-      expect(mech.ip_v6_cidr_length).to eq('64')
+      expect(mech.ip_v4_cidr_length).to eq(28)
+      expect(mech.ip_v6_cidr_length).to eq(64)
+      expect(mech.to_s).to eq('a:_spf.%{d}.example.com/28//64')
     end
 
     it 'should not parse a invalid dual CIDR length with a domain spec' do
@@ -178,7 +186,7 @@ describe Coppertone::Mechanism::A do
       end
 
       before do
-        allow(Coppertone::DNS::ResolvClient)
+        allow(DNSAdapter::ResolvClient)
           .to receive(:new).and_return(gmail_dns_client)
       end
 
@@ -195,4 +203,11 @@ describe Coppertone::Mechanism::A do
       end
     end
   end
+
+  context 'dns_lookup_term?' do
+    it 'should be true' do
+      expect(Coppertone::Mechanism::A).to be_dns_lookup_term
+      expect(Coppertone::Mechanism::A.new('//64')).to be_dns_lookup_term
+    end
+  end
 end

data/spec/mechanism/all_spec.rb

@@ -4,6 +4,7 @@ describe Coppertone::Mechanism::All do
   subject { Coppertone::Mechanism::All.instance }
   it 'should always return true regardless of argument' do
     expect(subject.match?(double, double)).to eq(true)
+    expect(subject.to_s).to eq('all')
   end
 
   it 'should not allow creation of new instances' do
@@ -19,4 +20,11 @@ describe Coppertone::Mechanism::All do
       end.to raise_error(Coppertone::RecordParsingError)
     end
   end
+
+  context 'dns_lookup_term?' do
+    it 'should be false' do
+      expect(Coppertone::Mechanism::All).not_to be_dns_lookup_term
+      expect(Coppertone::Mechanism::All.instance).not_to be_dns_lookup_term
+    end
+  end
 end

data/spec/mechanism/exists_spec.rb

@@ -19,6 +19,11 @@ describe Coppertone::Mechanism::Exists do
         Coppertone::Mechanism::Exists.new(':abc%:def')
       end.to raise_error(Coppertone::InvalidMechanismError)
     end
+
+    it 'should succeed if called with a valid macrostring' do
+      mech = Coppertone::Mechanism::Exists.new(':%{d}.example.com')
+      expect(mech.to_s).to eq('exists:%{d}.example.com')
+    end
   end
 
   context '#create' do
@@ -66,12 +71,8 @@ describe Coppertone::Mechanism::Exists do
         Coppertone::MacroContext.new(domain, '74.125.239.118', 'bob@gmail.com')
       end
 
-      let(:not_matching_context) do
-        Coppertone::MacroContext.new(domain, '74.125.249.118', 'bob@gmail.com')
-      end
-
       before do
-        allow(Coppertone::DNS::ResolvClient)
+        allow(DNSAdapter::ResolvClient)
           .to receive(:new).and_return(dns_client)
       end
 
@@ -81,11 +82,18 @@ describe Coppertone::Mechanism::Exists do
           .to eq(true)
       end
 
-      it 'should match when the domain record for the target name exists' do
+      it 'should not match when the domain record for the target name does not exist' do
         mech = Coppertone::Mechanism::Exists.create(bad_arg)
         expect(mech.match?(matching_context, Coppertone::RequestContext.new))
           .to eq(false)
       end
     end
   end
+
+  context 'dns_lookup_term?' do
+    it 'should be true' do
+      expect(Coppertone::Mechanism::Exists).to be_dns_lookup_term
+      expect(Coppertone::Mechanism::Exists.new(':example.com')).to be_dns_lookup_term
+    end
+  end
 end

data/spec/mechanism/include_spec.rb

@@ -16,9 +16,14 @@ describe Coppertone::Mechanism::Include do
 
     it 'should fail if called with an invalid macrostring' do
       expect do
-        Coppertone::Mechanism::Include.new('abc%:def')
+        Coppertone::Mechanism::Include.new(':abc%:def')
       end.to raise_error(Coppertone::InvalidMechanismError)
     end
+
+    it 'creates a mechanism if called with a valid macrostring' do
+      mech = Coppertone::Mechanism::Include.new(':_spf.example.com')
+      expect(mech.to_s).to eq('include:_spf.example.com')
+    end
   end
 
   context '#create' do
@@ -40,4 +45,11 @@ describe Coppertone::Mechanism::Include do
       end.to raise_error(Coppertone::InvalidMechanismError)
     end
   end
+
+  context 'dns_lookup_term?' do
+    it 'should be true' do
+      expect(Coppertone::Mechanism::Include).to be_dns_lookup_term
+      expect(Coppertone::Mechanism::Include.new(':example.com')).to be_dns_lookup_term
+    end
+  end
 end

data/spec/mechanism/ip4_spec.rb

@@ -23,16 +23,19 @@ describe Coppertone::Mechanism::IP4 do
     it 'should not fail if called with an IP v6' do
       mech = Coppertone::Mechanism::IP4.new(':fe80::202:b3ff:fe1e:8329')
       expect(mech.ip_network).to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329'))
+      expect(mech.to_s).to eq('ip4:fe80::202:b3ff:fe1e:8329')
     end
 
     it 'should work if called with an IP4' do
       mech = Coppertone::Mechanism::IP4.new(':1.2.3.4')
       expect(mech.ip_network).to eq(IPAddr.new('1.2.3.4'))
+      expect(mech.to_s).to eq('ip4:1.2.3.4')
     end
 
     it 'should work if called with an IP4 with a pfxlen' do
       mech = Coppertone::Mechanism::IP4.new(':1.2.3.4/4')
       expect(mech.ip_network).to eq(IPAddr.new('1.2.3.4/4'))
+      expect(mech.to_s).to eq('ip4:1.2.3.4/4')
     end
   end
 
@@ -66,13 +69,13 @@ describe Coppertone::Mechanism::IP4 do
     end
 
     it 'should work if called with an IP4 with a pfxlen' do
-      mech = Coppertone::Mechanism::IP4.create('1.2.3.4/4')
+      mech = Coppertone::Mechanism::IP4.create(':1.2.3.4/4')
       expect(mech.ip_network).to eq(IPAddr.new('1.2.3.4/4'))
     end
 
     it 'should fail if called with an invalid pfxlen' do
       expect do
-        Coppertone::Mechanism::IP4.new('1.2.3.4/127')
+        Coppertone::Mechanism::IP4.new(':1.2.3.4/127')
       end.to raise_error(Coppertone::InvalidMechanismError)
     end
   end
@@ -93,18 +96,25 @@ describe Coppertone::Mechanism::IP4 do
     end
 
     it 'should return true if the client IP is in the network' do
-      mech = Coppertone::Mechanism::IP4.create('4.5.6.0/29')
+      mech = Coppertone::Mechanism::IP4.create(':4.5.6.0/29')
       expect(mech.match?(macro_context, double)).to eq(true)
     end
 
     it 'should return false if the client IP is not in the network' do
-      mech = Coppertone::Mechanism::IP4.create('4.5.6.0/30')
+      mech = Coppertone::Mechanism::IP4.create(':4.5.6.0/30')
       expect(mech.match?(macro_context, double)).to eq(false)
     end
 
     it 'should return false if the client IP is v6 only' do
-      mech = Coppertone::Mechanism::IP4.create('4.5.6.0/29')
+      mech = Coppertone::Mechanism::IP4.create(':4.5.6.0/29')
       expect(mech.match?(ip_v6_macro_context, double)).to eq(false)
     end
   end
+
+  context 'dns_lookup_term?' do
+    it 'should be false' do
+      expect(Coppertone::Mechanism::IP4).not_to be_dns_lookup_term
+      expect(Coppertone::Mechanism::IP4.create(':4.5.6.7')).not_to be_dns_lookup_term
+    end
+  end
 end