coppertone 0.0.1 → 0.0.2

data/spec/open_spf/Processing_limits_spec.rb

@@ -5,68 +5,68 @@ describe 'Processing limits' do
     { 'mail.example.com' => [{ 'A' => '1.2.3.4' }], 'e1.example.com' => [{ 'TXT' => 'v=spf1 ip4:1.1.1.1 redirect=e1.example.com' }, { 'A' => '1.2.3.6' }], 'e2.example.com' => [{ 'TXT' => 'v=spf1 include:e3.example.com' }, { 'A' => '1.2.3.7' }], 'e3.example.com' => [{ 'TXT' => 'v=spf1 include:e2.example.com' }, { 'A' => '1.2.3.8' }], 'e4.example.com' => [{ 'TXT' => 'v=spf1 mx' }, { 'MX' => [0, 'mail.example.com'] }, { 'MX' => [1, 'mail.example.com'] }, { 'MX' => [2, 'mail.example.com'] }, { 'MX' => [3, 'mail.example.com'] }, { 'MX' => [4, 'mail.example.com'] }, { 'MX' => [5, 'mail.example.com'] }, { 'MX' => [6, 'mail.example.com'] }, { 'MX' => [7, 'mail.example.com'] }, { 'MX' => [8, 'mail.example.com'] }, { 'MX' => [9, 'mail.example.com'] }, { 'MX' => [10, 'e4.example.com'] }, { 'A' => '1.2.3.5' }], 'e5.example.com' => [{ 'TXT' => 'v=spf1 ptr' }, { 'A' => '1.2.3.5' }], '5.3.2.1.in-addr.arpa' => [{ 'PTR' => 'e1.example.com.' }, { 'PTR' => 'e2.example.com.' }, { 'PTR' => 'e3.example.com.' }, { 'PTR' => 'e4.example.com.' }, { 'PTR' => 'example.com.' }, { 'PTR' => 'e6.example.com.' }, { 'PTR' => 'e7.example.com.' }, { 'PTR' => 'e8.example.com.' }, { 'PTR' => 'e9.example.com.' }, { 'PTR' => 'e10.example.com.' }, { 'PTR' => 'e5.example.com.' }], 'e6.example.com' => [{ 'TXT' => 'v=spf1 a mx a mx a mx a mx a ptr ip4:1.2.3.4 -all' }, { 'A' => '1.2.3.8' }, { 'MX' => [10, 'e6.example.com'] }], 'e7.example.com' => [{ 'TXT' => 'v=spf1 a mx a mx a mx a mx a ptr a ip4:1.2.3.4 -all' }, { 'A' => '1.2.3.20' }], 'e8.example.com' => [{ 'TXT' => 'v=spf1 a include:inc.example.com ip4:1.2.3.4 mx -all' }, { 'A' => '1.2.3.4' }], 'inc.example.com' => [{ 'TXT' => 'v=spf1 a a a a a a a a' }, { 'A' => '1.2.3.10' }], 'e9.example.com' => [{ 'TXT' => 'v=spf1 a include:inc.example.com a ip4:1.2.3.4 -all' }, { 'A' => '1.2.3.21' }], 'e10.example.com' => [{ 'TXT' => 'v=spf1 a -all' }, { 'A' => '1.2.3.1' }, { 'A' => '1.2.3.2' }, { 'A' => '1.2.3.3' }, { 'A' => '1.2.3.4' }, { 'A' => '1.2.3.5' }, { 'A' => '1.2.3.6' }, { 'A' => '1.2.3.7' }, { 'A' => '1.2.3.8' }, { 'A' => '1.2.3.9' }, { 'A' => '1.2.3.10' }, { 'A' => '1.2.3.11' }, { 'A' => '1.2.3.12' }], 'e11.example.com' => [{ 'TXT' => 'v=spf1 a:err.example.com a:err1.example.com a:err2.example.com ?all' }], 'e12.example.com' => [{ 'TXT' => 'v=spf1 a:err.example.com a:err1.example.com ?all' }] }
   end
 
-  let(:dns_client) { Coppertone::DNS::MockClient.new(zonefile) }
+  let(:dns_client) { DNSAdapter::MockClient.new(zonefile) }
   let(:options) { { dns_client: dns_client } }
 
   it 'SPF implementations MUST limit the number of mechanisms and modifiers that do DNS lookups to at most 10 per SPF check.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e1.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'SPF implementations MUST limit the number of mechanisms and modifiers that do DNS lookups to at most 10 per SPF check.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e2.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'there MUST be a limit of no more than 10 MX looked up and checked.' do
     # The required result for this test was the subject of much controversy with RFC4408.  For RFC7208 the ambiguity was resolved in favor of producing a permerror result.
     result = Coppertone::SpfService.authenticate_email('1.2.3.5', 'foo@e4.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'there MUST be a limit of no more than 10 PTR looked up and checked.' do
     # The result of this test cannot be permerror not only because the RFC does not specify it, but because the sender has no control over the PTR records of spammers. The preferred result reflects evaluating the 10 allowed PTR records in the order returned by the test data. If testing with live DNS, the PTR order may be random, and a pass result would still be compliant.  The SPF result is effectively randomized.
     result = Coppertone::SpfService.authenticate_email('1.2.3.5', 'foo@e5.example.com', 'mail.example.com', options)
-    expect(%i(neutral pass)).to include(result.code)
+    expect([:neutral, :pass]).to include(result.code)
   end
 
   it 'unlike MX, PTR, there is no RR limit for A' do
     # There seems to be a tendency for developers to want to limit A RRs in addition to MX and PTR.  These are IPs, not usable for 3rd party DoS attacks, and hence need no low limit.
     result = Coppertone::SpfService.authenticate_email('1.2.3.12', 'foo@e10.example.com', 'mail.example.com', options)
-    expect(%i(pass)).to include(result.code)
+    expect([:pass]).to include(result.code)
   end
 
   it 'SPF implementations MUST limit the number of mechanisms and modifiers that do DNS lookups to at most 10 per SPF check.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e6.example.com', 'mail.example.com', options)
-    expect(%i(pass)).to include(result.code)
+    expect([:pass]).to include(result.code)
   end
 
   it 'SPF implementations MUST limit the number of mechanisms and modifiers that do DNS lookups to at most 10 per SPF check.' do
     # We do not check whether an implementation counts mechanisms before or after evaluation.  The RFC is not clear on this.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e7.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'SPF implementations MUST limit the number of mechanisms and modifiers that do DNS lookups to at most 10 per SPF check.' do
     # The part of the RFC that talks about MAY parse the entire record first (4.6) is specific to syntax errors.  In RFC7208, processing limits are part of syntax checking (4.6).
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e8.example.com', 'mail.example.com', options)
-    expect(%i(pass)).to include(result.code)
+    expect([:pass]).to include(result.code)
   end
 
   it 'SPF implementations MUST limit the number of mechanisms and modifiers that do DNS lookups to at most 10 per SPF check.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e9.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'SPF implementations SHOULD limit "void lookups" to two.  An  implementation MAY choose to make such a limit configurable. In this case, a default of two is RECOMMENDED.' do
     # This is a new check in RFC7208, but it\'s been implemented in Mail::SPF for years with no issues.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e12.example.com', 'mail.example.com', options)
-    expect(%i(neutral)).to include(result.code)
+    expect([:neutral]).to include(result.code)
   end
 
   it 'SPF implementations SHOULD limit "void lookups" to two.  An implementation MAY choose to make such a limit configurable. In this case, a default of two is RECOMMENDED.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e11.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
 end

data/spec/open_spf/Record_evaluation_spec.rb

@@ -5,71 +5,71 @@ describe 'Record evaluation' do
     { 'mail.example.com' => [{ 'A' => '1.2.3.4' }], 't1.example.com' => [{ 'TXT' => 'v=spf1 ip4:1.2.3.4 -all moo' }], 't2.example.com' => [{ 'TXT' => 'v=spf1 moo.cow-far_out=man:dog/cat ip4:1.2.3.4 -all' }], 't3.example.com' => [{ 'TXT' => 'v=spf1 moo.cow/far_out=man:dog/cat ip4:1.2.3.4 -all' }], 't4.example.com' => [{ 'TXT' => 'v=spf1 moo.cow:far_out=man:dog/cat ip4:1.2.3.4 -all' }], 't5.example.com' => [{ 'TXT' => 'v=spf1 redirect=t5.example.com ~all' }], 't6.example.com' => [{ 'TXT' => 'v=spf1 ip4:1.2.3.4 redirect=t2.example.com' }], 't7.example.com' => [{ 'TXT' => 'v=spf1 ip4:1.2.3.4' }], 't8.example.com' => [{ 'TXT' => 'v=spf1 ip4:1.2.3.4 redirect:t2.example.com' }], 't9.example.com' => [{ 'TXT' => 'v=spf1 a:foo-bar -all' }], 't10.example.com' => [{ 'TXT' => 'v=spf1 a:mail.example...com -all' }], 't11.example.com' => [{ 'TXT' => 'v=spf1 a:a123456789012345678901234567890123456789012345678901234567890123.example.com -all' }], 't12.example.com' => [{ 'TXT' => 'v=spf1 a:%{H}.bar -all' }] }
   end
 
-  let(:dns_client) { Coppertone::DNS::MockClient.new(zonefile) }
+  let(:dns_client) { DNSAdapter::MockClient.new(zonefile) }
   let(:options) { { dns_client: dns_client } }
 
   it 'Any syntax errors anywhere in the record MUST be detected.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@t1.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'name = ALPHA *( ALPHA / DIGIT / "-" / "_" / "." )' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@t2.example.com', 'mail.example.com', options)
-    expect(%i(pass)).to include(result.code)
+    expect([:pass]).to include(result.code)
   end
 
   it '= character immediately after the name and before any ":" or "/"' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@t3.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it '= character immediately after the name and before any ":" or "/"' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@t4.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'The "redirect" modifier has an effect after all the mechanisms.' do
     # The redirect in this example would violate processing limits, except that it is never used because of the all mechanism.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@t5.example.com', 'mail.example.com', options)
-    expect(%i(softfail)).to include(result.code)
+    expect([:softfail]).to include(result.code)
   end
 
   it 'The "redirect" modifier has an effect after all the mechanisms.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.5', 'foo@t6.example.com', 'mail.example.com', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
   end
 
   it 'Default result is neutral.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.5', 'foo@t7.example.com', 'mail.example.com', options)
-    expect(%i(neutral)).to include(result.code)
+    expect([:neutral]).to include(result.code)
   end
 
   it 'Invalid mechanism.  Redirect is a modifier.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@t8.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'Domain-spec must end in macro-expand or valid toplabel.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@t9.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'target-name that is a valid domain-spec per RFC 4408 and RFC 7208 but an invalid domain name per RFC 1035 (empty label) should be treated as non-existent.' do
     # An empty domain label, i.e. two successive dots, in a mechanism target-name is valid domain-spec syntax (perhaps formed from a macro expansion), even though a DNS query cannot be composed from it.  The spec being unclear about it, this could either be considered a syntax error, or, by analogy to 4.3/1 and 5/10/3, the mechanism could be treated as a no-match.  RFC 7208 failed to agree on which result to use, and declares the situation undefined.  The preferred test result is therefore a matter of opinion.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@t10.example.com', 'mail.example.com', options)
-    expect(%i(fail permerror)).to include(result.code)
+    expect([:fail, :permerror]).to include(result.code)
   end
 
   it 'target-name that is a valid domain-spec per RFC 4408 and RFC 7208 but an invalid domain name per RFC 1035 (long label) must be treated as non-existent.' do
     # A domain label longer than 63 characters in a mechanism target-name is valid domain-spec syntax (perhaps formed from a macro expansion), even though a DNS query cannot be composed from it.  The spec being unclear about it, this could either be considered a syntax error, or, by analogy to 4.3/1 and 5/10/3, the mechanism could be treated as a no-match.  RFC 7208 failed to agree on which result to use, and declares the situation undefined.  The preferred test result is therefore a matter of opinion.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@t11.example.com', 'mail.example.com', options)
-    expect(%i(fail permerror)).to include(result.code)
+    expect([:fail, :permerror]).to include(result.code)
   end
 
   it 'target-name that is a valid domain-spec per RFC 4408 and RFC 7208 but an invalid domain name per RFC 1035 (long label) must be treated as non-existent.' do
     # A domain label longer than 63 characters that results from macro expansion in a mechanism target-name is valid domain-spec syntax (and is not even subject to syntax checking after macro expansion), even though a DNS query cannot be composed from it.  The spec being unclear about it, this could either be considered a syntax error, or, by analogy to 4.3/1 and 5/10/3, the mechanism could be treated as a no-match.  RFC 7208 failed to agree on which result to use, and declares the situation undefined.  The preferred test result is therefore a matter of opinion.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@t12.example.com', '%%%%%%%%%%%%%%%%%%%%%%', options)
-    expect(%i(fail permerror)).to include(result.code)
+    expect([:fail, :permerror]).to include(result.code)
   end
 
 end

data/spec/open_spf/Record_lookup_spec.rb

@@ -5,44 +5,44 @@ describe 'Record lookup' do
     { 'both.example.net' => [{ 'TXT' => 'v=spf1 -all' }, { 'SPF' => 'v=spf1 -all' }], 'txtonly.example.net' => [{ 'TXT' => 'v=spf1 -all' }], 'spfonly.example.net' => [{ 'SPF' => 'v=spf1 -all' }, { 'TXT' => 'NONE' }], 'spftimeout.example.net' => [{ 'TXT' => 'v=spf1 -all' }, 'TIMEOUT'], 'txttimeout.example.net' => [{ 'SPF' => 'v=spf1 -all' }, { 'TXT' => 'NONE' }, 'TIMEOUT'], 'nospftxttimeout.example.net' => [{ 'SPF' => 'v=spf3 !a:yahoo.com -all' }, { 'TXT' => 'NONE' }, 'TIMEOUT'], 'alltimeout.example.net' => ['TIMEOUT'] }
   end
 
-  let(:dns_client) { Coppertone::DNS::MockClient.new(zonefile) }
+  let(:dns_client) { DNSAdapter::MockClient.new(zonefile) }
   let(:options) { { dns_client: dns_client } }
 
   it 'both' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@both.example.net', 'mail.example.net', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
   end
 
   it 'Result is none if checking SPF records only (which you should not be doing).' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@txtonly.example.net', 'mail.example.net', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
   end
 
   it 'Result is none if checking TXT records only.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@spfonly.example.net', 'mail.example.net', options)
-    expect(%i(none)).to include(result.code)
+    expect([:none]).to include(result.code)
   end
 
   it 'TXT record present, but SPF lookup times out. Result is temperror if checking SPF records only.  Fortunately, we dont do type SPF anymore.' do
     # This actually happens for a popular braindead DNS server.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@spftimeout.example.net', 'mail.example.net', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
   end
 
   it 'SPF record present, but TXT lookup times out. If only TXT records are checked, result is temperror.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@txttimeout.example.net', 'mail.example.net', options)
-    expect(%i(temperror)).to include(result.code)
+    expect([:temperror]).to include(result.code)
   end
 
   it 'No SPF record present, and TXT lookup times out. If only TXT records are checked, result is temperror.' do
     # Because TXT records is where v=spf1 records will likely be, returning temperror will try again later.  A timeout due to a braindead server is unlikely in the case of TXT, as opposed to the newer SPF RR.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@nospftxttimeout.example.net', 'mail.example.net', options)
-    expect(%i(temperror)).to include(result.code)
+    expect([:temperror]).to include(result.code)
   end
 
   it 'Both TXT and SPF queries time out' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@alltimeout.example.net', 'mail.example.net', options)
-    expect(%i(temperror)).to include(result.code)
+    expect([:temperror]).to include(result.code)
   end
 
 end

data/spec/open_spf/Selecting_records_spec.rb

@@ -5,57 +5,57 @@ describe 'Selecting records' do
     { 'example3.com' => [{ 'TXT' => 'v=spf10' }, { 'TXT' => 'v=spf1 mx' }, { 'MX' => [0, 'mail.example1.com'] }], 'example1.com' => [{ 'TXT' => 'v=spf1' }], 'example2.com' => [{ 'TXT' => ['v=spf1', 'mx'] }], 'mail.example1.com' => [{ 'A' => '1.2.3.4' }], 'example4.com' => [{ 'SPF' => 'v=spf1 +all' }, { 'TXT' => 'v=spf1 -all' }], 'example5.com' => [{ 'SPF' => 'v=spf1 +all' }, { 'TXT' => 'v=spf1 -all' }, { 'TXT' => 'v=spf1 +all' }], 'example6.com' => [{ 'TXT' => 'v=spf1 -all' }, { 'TXT' => 'V=sPf1 +all' }], 'example7.com' => [{ 'TXT' => 'v=spf1 -all' }, { 'TXT' => 'v=spf1 -all' }], 'example8.com' => [{ 'SPF' => 'V=spf1 -all' }, { 'SPF' => 'v=spf1 -all' }, { 'TXT' => 'v=spf1 +all' }], 'example9.com' => [{ 'TXT' => 'v=SpF1 ~all' }] }
   end
 
-  let(:dns_client) { Coppertone::DNS::MockClient.new(zonefile) }
+  let(:dns_client) { DNSAdapter::MockClient.new(zonefile) }
   let(:options) { { dns_client: dns_client } }
 
   it 'Version must be terminated by space or end of record.  TXT pieces are joined without intervening spaces.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@example2.com', 'mail.example1.com', options)
-    expect(%i(none)).to include(result.code)
+    expect([:none]).to include(result.code)
   end
 
   it 'Empty SPF record.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@example1.com', 'mail1.example1.com', options)
-    expect(%i(neutral)).to include(result.code)
+    expect([:neutral]).to include(result.code)
   end
 
   it 'nospace2' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@example3.com', 'mail.example1.com', options)
-    expect(%i(pass)).to include(result.code)
+    expect([:pass]).to include(result.code)
   end
 
   it 'SPF records no longer used.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@example4.com', 'mail.example1.com', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
   end
 
   it 'Implementations should give permerror/unknown because of the conflicting TXT records.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@example5.com', 'mail.example1.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'Multiple records is a permerror, v=spf1 is case insensitive' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@example6.com', 'mail.example1.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'Multiple records is a permerror, even when they are identical. However, this situation cannot be reliably reproduced with live DNS since cache and resolvers are allowed to combine identical records.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@example7.com', 'mail.example1.com', options)
-    expect(%i(permerror fail)).to include(result.code)
+    expect([:permerror, :fail]).to include(result.code)
   end
 
   it 'Ignoring SPF-type records will give pass because there is a (single) TXT record.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@example8.com', 'mail.example1.com', options)
-    expect(%i(pass)).to include(result.code)
+    expect([:pass]).to include(result.code)
   end
 
   it 'nospf' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@mail.example1.com', 'mail.example1.com', options)
-    expect(%i(none)).to include(result.code)
+    expect([:none]).to include(result.code)
   end
 
   it 'v=spf1 is case insensitive' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@example9.com', 'mail.example1.com', options)
-    expect(%i(softfail)).to include(result.code)
+    expect([:softfail]).to include(result.code)
   end
 
 end

data/spec/open_spf/Semantics_of_exp_and_other_modifiers_spec.rb

@@ -1,3 +1,5 @@
+# -- encoding : utf-8 --
+
 require 'spec_helper'
 
 describe 'Semantics of exp and other modifiers' do
@@ -5,17 +7,17 @@ describe 'Semantics of exp and other modifiers' do
     { 'mail.example.com' => [{ 'A' => '1.2.3.4' }], 'e1.example.com' => [{ 'TXT' => 'v=spf1 exp=exp1.example.com redirect=e2.example.com' }], 'e2.example.com' => [{ 'TXT' => 'v=spf1 -all' }], 'e3.example.com' => [{ 'TXT' => 'v=spf1 exp=exp1.example.com redirect=e4.example.com' }], 'e4.example.com' => [{ 'TXT' => 'v=spf1 -all exp=exp2.example.com' }], 'exp1.example.com' => [{ 'TXT' => 'No-see-um' }], 'exp2.example.com' => [{ 'TXT' => 'See me.' }], 'exp3.example.com' => [{ 'TXT' => 'Correct!' }], 'exp4.example.com' => [{ 'TXT' => '%{l} in implementation' }], 'e5.example.com' => [{ 'TXT' => 'v=spf1 1up=foo' }], 'e6.example.com' => [{ 'TXT' => 'v=spf1 =all' }], 'e7.example.com' => [{ 'TXT' => 'v=spf1 include:e3.example.com -all exp=exp3.example.com' }], 'e8.example.com' => [{ 'TXT' => 'v=spf1 -all exp=exp4.example.com' }], 'e9.example.com' => [{ 'TXT' => 'v=spf1 -all foo=%abc' }], 'e10.example.com' => [{ 'TXT' => 'v=spf1 redirect=erehwon.example.com' }], 'e11.example.com' => [{ 'TXT' => 'v=spf1 -all exp=e11msg.example.com' }], 'e11msg.example.com' => [{ 'TXT' => 'Answer a fool according to his folly.' }, { 'TXT' => 'Do not answer a fool according to his folly.' }], 'e12.example.com' => [{ 'TXT' => 'v=spf1 exp= -all' }], 'e13.example.com' => [{ 'TXT' => 'v=spf1 exp=e13msg.example.com -all' }], 'e13msg.example.com' => [{ 'TXT' => 'The %{x}-files.' }], 'e14.example.com' => [{ 'TXT' => 'v=spf1 exp=e13msg.example.com -all exp=e11msg.example.com' }], 'e15.example.com' => [{ 'TXT' => 'v=spf1 redirect=e12.example.com -all redirect=e12.example.com' }], 'e16.example.com' => [{ 'TXT' => 'v=spf1 exp=-all' }], 'e17.example.com' => [{ 'TXT' => 'v=spf1 redirect=-all ?all' }], 'e18.example.com' => [{ 'TXT' => 'v=spf1 ?all redirect=' }], 'e19.example.com' => [{ 'TXT' => 'v=spf1 default=pass' }], 'e20.example.com' => [{ 'TXT' => 'v=spf1 default=+' }], 'e21.example.com' => [{ 'TXT' => 'v=spf1 exp=e21msg.example.com -all' }], 'e21msg.example.com' => ['TIMEOUT'], 'e22.example.com' => [{ 'TXT' => 'v=spf1 exp=mail.example.com -all' }], 'nonascii.example.com' => [{ 'TXT' => 'v=spf1 exp=badexp.example.com -all' }], 'badexp.example.com' => [{ 'TXT' => 'Explanation' }], 'tworecs.example.com' => [{ 'TXT' => 'v=spf1 exp=twoexp.example.com -all' }], 'twoexp.example.com' => [{ 'TXT' => 'one' }, { 'TXT' => 'two' }], 'e23.example.com' => [{ 'TXT' => 'v=spf1 a:erehwon.example.com a:foobar.com exp=nxdomain.com -all' }], 'e24.example.com' => [{ 'TXT' => 'v=spf1 redirect=testimplicit.example.com' }, { 'A' => '192.0.2.1' }], 'testimplicit.example.com' => [{ 'TXT' => 'v=spf1 a -all' }, { 'A' => '192.0.2.2' }] }
   end
 
-  let(:dns_client) { Coppertone::DNS::MockClient.new(zonefile) }
+  let(:dns_client) { DNSAdapter::MockClient.new(zonefile) }
   let(:options) { { dns_client: dns_client } }
 
   it 'If no SPF record is found, or if the target-name is malformed, the result is a "PermError" rather than "None".' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e10.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'when executing "redirect", exp= from the original domain MUST NOT be used.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e1.example.com', 'mail.example.com', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
     expect(result.explanation).to eq('DEFAULT')
   end
 
@@ -26,71 +28,71 @@ describe 'Semantics of exp and other modifiers' do
     #
     # However, it is generally agreed, with precedent in other RFCs, that unknown-modifier should not be "greedy", and should not match known modifier names.  There should have been explicit prose to this effect, and some has been proposed as an erratum.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e17.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'when executing "include", exp= from the target domain MUST NOT be used.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e7.example.com', 'mail.example.com', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
     expect(result.explanation).to eq('Correct!')
   end
 
   it 'when executing "redirect", exp= from the original domain MUST NOT be used.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e3.example.com', 'mail.example.com', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
     expect(result.explanation).to eq('See me.')
   end
 
   it 'unknown-modifier = name "=" macro-string name             = ALPHA *( ALPHA / DIGIT / "-" / "_" / "." ) ' do
     # Unknown modifier name must begin with alpha.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e5.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'name             = ALPHA *( ALPHA / DIGIT / "-" / "_" / "." ) ' do
     # Unknown modifier name must not be empty.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e6.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'An implementation that uses a legal expansion as a sentinel.  We cannot check them all, but we can check this one.' do
     # Spaces are allowed in local-part.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'Macro Error@e8.example.com', 'mail.example.com', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
     expect(result.explanation).to eq('Macro Error in implementation')
   end
 
   it 'Ignore exp if multiple TXT records. ' do
     # If domain-spec is empty, or there are any DNS processing errors (any RCODE other than 0), or if no records are returned, or if more than one record is returned, or if there are syntax errors in the explanation string, then proceed as if no exp modifier was given.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e11.example.com', 'mail.example.com', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
     expect(result.explanation).to eq('DEFAULT')
   end
 
   it 'Ignore exp if no TXT records. ' do
     # If domain-spec is empty, or there are any DNS processing errors (any RCODE other than 0), or if no records are returned, or if more than one record is returned, or if there are syntax errors in the explanation string, then proceed as if no exp modifier was given.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e22.example.com', 'mail.example.com', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
     expect(result.explanation).to eq('DEFAULT')
   end
 
   it 'Ignore exp if DNS error. ' do
     # If domain-spec is empty, or there are any DNS processing errors (any RCODE other than 0), or if no records are returned, or if more than one record is returned, or if there are syntax errors in the explanation string, then proceed as if no exp modifier was given.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e21.example.com', 'mail.example.com', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
     expect(result.explanation).to eq('DEFAULT')
   end
 
   it 'PermError if exp= domain-spec is empty. ' do
     # Section 6.2/4 says, "If domain-spec is empty, or there are any DNS processing errors (any RCODE other than 0), or if no records are returned, or if more than one record is returned, or if there are syntax errors in the explanation string, then proceed as if no exp modifier was given."  However, "if domain-spec is empty" conflicts with the grammar given for the exp modifier.  This was reported as an erratum, and the solution chosen was to report explicit "exp=" as PermError, but ignore problems due to macro expansion, DNS, or invalid explanation string.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e12.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'Ignore exp if the explanation string has a syntax error. ' do
     # If domain-spec is empty, or there are any DNS processing errors (any RCODE other than 0), or if no records are returned, or if more than one record is returned, or if there are syntax errors in the explanation string, then proceed as if no exp modifier was given.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e13.example.com', 'mail.example.com', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
     expect(result.explanation).to eq('DEFAULT')
   end
 
@@ -101,67 +103,67 @@ describe 'Semantics of exp and other modifiers' do
     #
     # However, it is generally agreed, with precedent in other RFCs, that unknown-modifier should not be "greedy", and should not match known modifier names.  There should have been explicit prose to this effect, and some has been proposed as an erratum.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e16.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'exp= appears twice. ' do
     # These two modifiers (exp,redirect) MUST NOT appear in a record more than once each. If they do, then check_host() exits with a result of "PermError".
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e14.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'redirect = "redirect" "=" domain-spec ' do
     # Unlike for exp, there is no instruction to override the permerror for an empty domain-spec (which is invalid syntax).
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e18.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'redirect= appears twice. ' do
     # These two modifiers (exp,redirect) MUST NOT appear in a record more than once each. If they do, then check_host() exits with a result of "PermError".
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e15.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'unknown-modifier = name "=" macro-string ' do
     # Unknown modifiers must have valid macro syntax.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e9.example.com', 'mail.example.com', options)
-    expect(%i(permerror)).to include(result.code)
+    expect([:permerror]).to include(result.code)
   end
 
   it 'Unknown modifiers do not modify the RFC SPF result. ' do
     # Some implementations may have a leftover default= modifier from earlier drafts.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e19.example.com', 'mail.example.com', options)
-    expect(%i(neutral)).to include(result.code)
+    expect([:neutral]).to include(result.code)
   end
 
   it 'Unknown modifiers do not modify the RFC SPF result. ' do
     # Some implementations may have a leftover default= modifier from earlier drafts.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e20.example.com', 'mail.example.com', options)
-    expect(%i(neutral)).to include(result.code)
+    expect([:neutral]).to include(result.code)
   end
 
   it 'SPF explanation text is restricted to 7-bit ascii.' do
     # Checking a possibly different code path for non-ascii chars.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foobar@nonascii.example.com', 'hosed', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
     expect(result.explanation).to eq('DEFAULT')
   end
 
   it 'Must ignore exp= if DNS returns more than one TXT record.' do
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foobar@tworecs.example.com', 'hosed', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
     expect(result.explanation).to eq('DEFAULT')
   end
 
   it 'exp=nxdomain.tld ' do
     # Non-existent exp= domains MUST NOT count against the void lookup limit. Implementations should lookup any exp record at most once after computing the result.
     result = Coppertone::SpfService.authenticate_email('1.2.3.4', 'foo@e23.example.com', 'mail.example.com', options)
-    expect(%i(fail)).to include(result.code)
+    expect([:fail]).to include(result.code)
   end
 
   it 'redirect changes implicit domain ' do
     result = Coppertone::SpfService.authenticate_email('192.0.2.2', 'bar@e24.example.com', 'e24.example.com', options)
-    expect(%i(pass)).to include(result.code)
+    expect([:pass]).to include(result.code)
   end
 
 end

data/spec/open_spf/Test_cases_from_implementation_bugs_spec.rb

@@ -5,13 +5,13 @@ describe 'Test cases from implementation bugs' do
     { 'example.org' => [{ 'TXT' => 'v=spf1 mx redirect=_spf.example.com' }, { 'MX' => [10, 'smtp.example.org'] }, { 'MX' => [10, 'smtp1.example.com'] }], 'smtp.example.org' => [{ 'A' => '198.51.100.2' }, { 'AAAA' => '2001:db8:ff0:100::3' }], 'smtp1.example.com' => [{ 'A' => '192.0.2.26' }, { 'AAAA' => '2001:db8:ff0:200::2' }], '2.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.0.0.F.F.0.8.B.D.0.1.0.0.2.ip6.arpa' => [{ 'PTR' => 'smtp6-v.fe.example.org' }], 'smtp6-v.fe.example.org' => [{ 'AAAA' => '2001:db8:ff0:100::2' }], '_spf.example.com' => [{ 'TXT' => 'v=spf1 ptr:fe.example.org ptr:sgp.example.com exp=_expspf.example.org -all' }], '_expspf.example.org' => [{ 'TXT' => 'Sender domain not allowed from this host. Please see http://www.openspf.org/Why?s=mfrom&id=%{S}&ip=%{C}&r=%{R}' }] }
   end
 
-  let(:dns_client) { Coppertone::DNS::MockClient.new(zonefile) }
+  let(:dns_client) { DNSAdapter::MockClient.new(zonefile) }
   let(:options) { { dns_client: dns_client } }
 
   it 'Bytes vs str bug from pyspf.' do
     # Pyspf failed with strict=2 only.  Other implementations may ignore the strict parameter.
     result = Coppertone::SpfService.authenticate_email('2001:db8:ff0:100::2', 'test@example.org', 'example.org', options)
-    expect(%i(pass)).to include(result.code)
+    expect([:pass]).to include(result.code)
   end
 
 end

data/spec/record_spec.rb

@@ -16,18 +16,24 @@ describe Coppertone::Record do
     end
   end
 
-  context 'parsing' do
-    it 'should return nil for nil' do
-      expect(Coppertone::Record.parse(nil)).to be_nil
+  context 'creation' do
+    it 'should raise an error for nil' do
+      expect do
+        Coppertone::Record.new(nil)
+      end.to raise_error(Coppertone::RecordParsingError)
     end
 
-    it 'should return a nil for text without the prefix' do
-      expect(Coppertone::Record.parse('not a record')).to be_nil
-      expect(Coppertone::Record.parse('v=spf ~all')).to be_nil
+    it 'should raise an error for text without the prefix' do
+      expect do
+        Coppertone::Record.new('not a record')
+      end.to raise_error(Coppertone::RecordParsingError)
+      expect do
+        Coppertone::Record.new('v=spf ~all')
+      end.to raise_error(Coppertone::RecordParsingError)
     end
 
     it 'parse simple mechanism records' do
-      record = Coppertone::Record.parse('v=spf1 ~all')
+      record = Coppertone::Record.new('v=spf1 ~all')
       expect(record).not_to be_nil
       expect(record.directives.size).to eq(1)
       directive = record.directives.first
@@ -37,7 +43,7 @@ describe Coppertone::Record do
     end
 
     it 'be case insensitive when parsing the version string' do
-      record = Coppertone::Record.parse('V=sPf1 ~all')
+      record = Coppertone::Record.new('V=sPf1 ~all')
       expect(record).not_to be_nil
       expect(record.directives.size).to eq(1)
       directive = record.directives.first
@@ -47,7 +53,7 @@ describe Coppertone::Record do
     end
 
     it 'should parse more complex records' do
-      record = Coppertone::Record.parse('v=spf1 mx -all exp=explain._spf.%{d}')
+      record = Coppertone::Record.new('v=spf1 mx -all exp=explain._spf.%{d}')
       expect(record).not_to be_nil
       expect(record.directives.size).to eq(2)
       directive = record.directives.first
@@ -74,27 +80,42 @@ describe Coppertone::Record do
       ]
       bad_records.each do |rec|
         expect do
-          Coppertone::Record.parse(rec)
+          Coppertone::Record.new(rec)
         end.to raise_error(Coppertone::RecordParsingError)
       end
     end
 
     it 'should fail when mechanisms are separated by ctrl characters' do
       expect do
-        Coppertone::Record.parse("v=spf1 a:ctrl.example.com\x0dptr -all")
+        Coppertone::Record.new("v=spf1 a:ctrl.example.com\x0dptr -all")
       end.to raise_error(Coppertone::RecordParsingError)
     end
 
     it 'should fail when it contains spurious terms' do
       expect do
-        Coppertone::Record.parse('v=spf1 ip4:1.2.3.4 -all moo')
+        Coppertone::Record.new('v=spf1 ip4:1.2.3.4 -all moo')
       end.to raise_error(Coppertone::RecordParsingError)
     end
 
     it 'should fail the domain-spec is not syntactically valid' do
       expect do
-        Coppertone::Record.parse('v=spf1 a:foo-bar')
+        Coppertone::Record.new('v=spf1 a:foo-bar')
       end.to raise_error(Coppertone::RecordParsingError)
     end
   end
+
+  context '#unknown_modifiers' do
+    it 'should return a non-empty array when there are unknown modifiers' do
+      expect(Coppertone::Record.new('v=spf1 moose=www.example.com').unknown_modifiers.size).to eq(1)
+      expect(Coppertone::Record.new('v=spf1 moose=www.example.com squirrel=xxx').unknown_modifiers.size).to eq(2)
+      expect(Coppertone::Record.new('v=spf1 moose=www.example.com moose=xxx').unknown_modifiers.size).to eq(2)
+    end
+
+    it 'should return an empty array when there are no unknown modifiers' do
+      expect(Coppertone::Record.new('v=spf1 ~all').unknown_modifiers).to be_empty
+      expect(Coppertone::Record.new('v=spf1 ip4:1.2.3.4 a:test.example.com -all').unknown_modifiers).to be_empty
+      expect(Coppertone::Record.new('v=spf1 mx -all exp=explain._spf.%{d}').unknown_modifiers).to be_empty
+      expect(Coppertone::Record.new('v=spf1 mx -all redirect=explain._spf.%{d}').unknown_modifiers).to be_empty
+    end
+  end
 end

data/spec/request_context_spec.rb

@@ -4,7 +4,7 @@ describe Coppertone::RequestContext do
   it 'should have reasonable values by default' do
     ctx = Coppertone::RequestContext.new
     expect(ctx.dns_client).to_not be_nil
-    expect(ctx.dns_client.class).to eq(Coppertone::DNS::ResolvClient)
+    expect(ctx.dns_client.class).to eq(DNSAdapter::ResolvClient)
     expect(ctx.message_locale).to eq('en')
     expect(ctx.dns_lookups_per_mx_mechanism_limit).to eq(10)
     expect(ctx.dns_lookups_per_ptr_mechanism_limit).to eq(10)