coppertone 0.0.1

data/spec/open_spf/Semantics_of_exp_and_other_modifiers_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe 'Semantics of exp and other modifiers' do
+  let(:zonefile) 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(: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)
+  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(result.explanation).to eq('DEFAULT')
+  end
+
+  it 'redirect      = "redirect" "=" domain-spec ' do
+    # A literal application of the grammar causes modifier syntax errors (except for macro syntax) to become unknown-modifier.
+    #
+    #   modifier = explanation | redirect | unknown-modifier
+    #
+    # 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)
+  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(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(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)
+  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)
+  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(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(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(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(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)
+  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(result.explanation).to eq('DEFAULT')
+  end
+
+  it 'explanation      = "exp" "=" domain-spec ' do
+    # A literal application of the grammar causes modifier syntax errors (except for macro syntax) to become unknown-modifier.
+    #
+    #   modifier = explanation | redirect | unknown-modifier
+    #
+    # 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)
+  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)
+  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)
+  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)
+  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)
+  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)
+  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)
+  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(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(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)
+  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)
+  end
+
+end

data/spec/open_spf/Test_cases_from_implementation_bugs_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'Test cases from implementation bugs' do
+  let(:zonefile) 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(: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)
+  end
+
+end

data/spec/qualifier_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Coppertone::Qualifier do
+  context '#find_by_text' do
+    {
+      '+' => Coppertone::Qualifier::PASS,
+      '-' => Coppertone::Qualifier::FAIL,
+      '~' => Coppertone::Qualifier::SOFTFAIL,
+      '?' => Coppertone::Qualifier::NEUTRAL
+    }.each do |k, v|
+      it "should map from #{k} to the correct value" do
+        expect(Coppertone::Qualifier.find_by_text(k)).to eq(v)
+        expect(v.text).to eq(k)
+      end
+    end
+  end
+
+  context '#default_qualifier' do
+    it 'should yield the correct default qualifier' do
+      expect(Coppertone::Qualifier.default_qualifier)
+        .to eq(Coppertone::Qualifier::PASS)
+    end
+  end
+
+  context '#qualifiers' do
+    it 'should have the correct contents' do
+      qualifiers = Coppertone::Qualifier.qualifiers
+      expect(qualifiers.size).to eq(4)
+      expect(qualifiers.include?(Coppertone::Qualifier::PASS)).to be(true)
+      expect(qualifiers.include?(Coppertone::Qualifier::FAIL)).to be(true)
+      expect(qualifiers.include?(Coppertone::Qualifier::SOFTFAIL)).to be(true)
+      expect(qualifiers.include?(Coppertone::Qualifier::NEUTRAL)).to be(true)
+    end
+  end
+
+  context 'result' do
+    {
+      Coppertone::Qualifier::PASS => Coppertone::Result::PASS,
+      Coppertone::Qualifier::FAIL => Coppertone::Result::FAIL,
+      Coppertone::Qualifier::SOFTFAIL => Coppertone::Result::SOFTFAIL,
+      Coppertone::Qualifier::NEUTRAL => Coppertone::Result::NEUTRAL
+    }.each do |k, v|
+      it "should have the correct result code for #{k.text}" do
+        expect(k.result_code).to eq(v)
+      end
+    end
+  end
+
+  it 'should not allow creation of new qualifiers' do
+    expect do
+      Coppertone::Qualifier.new('a', Coppertone::Result::PASS)
+    end.to raise_error(NoMethodError)
+  end
+end

data/spec/record_evaluator_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Coppertone::RecordEvaluator do
+end

data/spec/record_finder_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Coppertone::RecordFinder do
+end

data/spec/record_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Coppertone::Record do
+  context '#record?' do
+    it 'should return a falsey value for nil' do
+      expect(Coppertone::Record.record?(nil)).to be_falsey
+    end
+
+    it 'should return a falsey value for text without the prefix' do
+      expect(Coppertone::Record.record?('not a record')).to be_falsey
+      expect(Coppertone::Record.record?('v=spf ~all')).to be_falsey
+    end
+
+    it 'should return a truthy value for text with the prefix' do
+      expect(Coppertone::Record.record?('v=spf1 ~all')).to be_truthy
+    end
+  end
+
+  context 'parsing' do
+    it 'should return nil for nil' do
+      expect(Coppertone::Record.parse(nil)).to be_nil
+    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
+    end
+
+    it 'parse simple mechanism records' do
+      record = Coppertone::Record.parse('v=spf1 ~all')
+      expect(record).not_to be_nil
+      expect(record.directives.size).to eq(1)
+      directive = record.directives.first
+      expect(directive.qualifier).to eq(Coppertone::Qualifier::SOFTFAIL)
+      expect(directive.mechanism).to eq(Coppertone::Mechanism::All.instance)
+      expect(record.modifiers).to be_empty
+    end
+
+    it 'be case insensitive when parsing the version string' do
+      record = Coppertone::Record.parse('V=sPf1 ~all')
+      expect(record).not_to be_nil
+      expect(record.directives.size).to eq(1)
+      directive = record.directives.first
+      expect(directive.qualifier).to eq(Coppertone::Qualifier::SOFTFAIL)
+      expect(directive.mechanism).to eq(Coppertone::Mechanism::All.instance)
+      expect(record.modifiers).to be_empty
+    end
+
+    it 'should parse more complex records' do
+      record = Coppertone::Record.parse('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
+      expect(directive.qualifier).to eq(Coppertone::Qualifier::PASS)
+      expect(directive.mechanism).to eq(Coppertone::Mechanism::MX.new(nil))
+
+      directive = record.directives.last
+      expect(directive.qualifier).to eq(Coppertone::Qualifier::FAIL)
+      expect(directive.mechanism).to eq(Coppertone::Mechanism::All.instance)
+
+      expect(record.modifiers.length).to eq(1)
+      modifier = record.modifiers.first
+      expect(modifier).to eq(Coppertone::Modifier::Exp.new('explain._spf.%{d}'))
+
+      expect(record.redirect).to be_nil
+      expect(record.exp)
+        .to eq(Coppertone::Modifier::Exp.new('explain._spf.%{d}'))
+    end
+
+    it 'should fail on more records with duplicate modifiers' do
+      bad_records = [
+        'v=spf1 mx -all exp=explain._spf.%{d} exp=other._spf.%{d}',
+        'v=spf1 mx redirect=gmail.com redirect=yahoo.com'
+      ]
+      bad_records.each do |rec|
+        expect do
+          Coppertone::Record.parse(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")
+      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')
+      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')
+      end.to raise_error(Coppertone::RecordParsingError)
+    end
+  end
+end

data/spec/request_context_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+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.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)
+    expect do
+      11.times { ctx.register_dns_lookup_term }
+    end.to raise_error(Coppertone::LimitExceededError)
+    expect do
+      3.times { ctx.register_void_dns_result }
+    end.to raise_error(Coppertone::LimitExceededError)
+  end
+
+  it 'should allow override of these values using options' do
+    dns_client = double
+    options = {
+      dns_client: dns_client,
+      message_locale: 'es',
+      terms_requiring_dns_lookup_limit: 20,
+      void_dns_result_limit: 4,
+      dns_lookups_per_mx_mechanism_limit: 18,
+      dns_lookups_per_ptr_mechanism_limit: 17
+    }
+    ctx = Coppertone::RequestContext.new(options)
+    expect(ctx.dns_client).to eq(dns_client)
+    expect(ctx.message_locale).to eq('es')
+    20.times { ctx.register_dns_lookup_term }
+    expect do
+      ctx.register_dns_lookup_term
+    end.to raise_error(Coppertone::LimitExceededError)
+    4.times { ctx.register_void_dns_result }
+    expect do
+      ctx.register_void_dns_result
+    end.to raise_error(Coppertone::LimitExceededError)
+    expect(ctx.dns_lookups_per_mx_mechanism_limit).to eq(18)
+    expect(ctx.dns_lookups_per_ptr_mechanism_limit).to eq(17)
+  end
+end

data/spec/request_count_limiter_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Coppertone::RequestCountLimiter do
+  let(:counter_description) { SecureRandom.hex(10) }
+
+  it 'should handle the basic case correctly' do
+    limiter = Coppertone::RequestCountLimiter.new(5, counter_description)
+    expect(limiter).to be_limited
+    expect(limiter.increment!).to eq(1)
+    expect(limiter.increment!).to eq(2)
+    expect(limiter.increment!(2)).to eq(4)
+    expect(limiter.increment!).to eq(5)
+    expect(limiter).not_to be_exceeded
+    expect { limiter.increment! }
+      .to raise_error Coppertone::LimitExceededError,
+                      "Maximum #{counter_description} limit of 5 exceeded."
+    expect(limiter).to be_exceeded
+  end
+
+  it 'should not raise an error if no limit is specified' do
+    limiter = Coppertone::RequestCountLimiter.new
+    expect(limiter).not_to be_limited
+    expect(limiter.increment!).to eq(1)
+    expect(limiter.increment!(1000)).to eq(1001)
+    expect(limiter.count).to eq(1001)
+    expect(limiter).not_to be_exceeded
+  end
+end

data/spec/result_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Coppertone::Result do
+end