coppertone 0.0.1

data/spec/macro_string/macro_literal_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Coppertone::MacroString::MacroLiteral do
+  let(:arg) { SecureRandom.hex(10) }
+  let(:macro) { Coppertone::MacroString::MacroLiteral.new(arg) }
+
+  it 'should expand to the argument' do
+    expect(macro.expand(double)).to eq(arg)
+  end
+
+  it 'should reduce to the argument in the macro form' do
+    expect(macro.to_s).to eq(arg)
+  end
+
+  context 'equality' do
+    it 'should treat different MacroLiterals with the same value as equal' do
+      expect(macro == Coppertone::MacroString::MacroLiteral.new(arg))
+        .to eql(true)
+    end
+
+    it 'otherwise should treat different MacroLiterals as unequal' do
+      other_arg = SecureRandom.hex(10)
+      expect(macro == Coppertone::MacroString::MacroLiteral.new(other_arg))
+        .to eql(false)
+    end
+  end
+end

data/spec/macro_string/macro_static_expand_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Coppertone::MacroString::MacroStaticExpand do
+  context '#exists_for?' do
+    %w(%% %_ %-).each do |x|
+      it "should resolve a macro for the key #{x}" do
+        expect(Coppertone::MacroString::MacroStaticExpand.exists_for?(x))
+          .to eq(true)
+      end
+    end
+
+    it 'should return false for invalid keys' do
+      expect(Coppertone::MacroString::MacroStaticExpand.exists_for?('%a'))
+        .to eq(false)
+    end
+  end
+
+  context 'macro_for' do
+    %w(%% %_ %-).each do |x|
+      it "should resolve a macro for the key #{x}" do
+        expect(Coppertone::MacroString::MacroStaticExpand.macro_for(x))
+          .not_to be_nil
+      end
+    end
+
+    it 'should raise an error for invalid keys' do
+      expect do
+        Coppertone::MacroString::MacroStaticExpand.macro_for('%a')
+      end.to raise_error(Coppertone::MacroStringParsingError)
+    end
+  end
+
+  it 'should not allow creation of new macros' do
+    expect do
+      Coppertone::MacroString::MacroStaticExpand.new('a', 'b')
+    end.to raise_error(NoMethodError)
+  end
+
+  context 'percent macro' do
+    let(:macro) { Coppertone::MacroString::MacroStaticExpand::PERCENT_MACRO }
+
+    it 'should return the expected values' do
+      expect(macro.expand(nil)).to eq('%')
+      expect(macro.to_s).to eq('%%')
+    end
+  end
+
+  context 'space macro' do
+    let(:macro) { Coppertone::MacroString::MacroStaticExpand::SPACE_MACRO }
+
+    it 'should return the expected values' do
+      expect(macro.expand(nil)).to eq(' ')
+      expect(macro.to_s).to eq('%_')
+    end
+  end
+
+  context 'url encoded space macro' do
+    let(:macro) do
+      Coppertone::MacroString::MacroStaticExpand::URL_ENCODED_SPACE_MACRO
+    end
+
+    it 'should return the expected values' do
+      expect(macro.expand(nil)).to eq('%20')
+      expect(macro.to_s).to eq('%-')
+    end
+  end
+end

data/spec/macro_string_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Coppertone::MacroString do
+  context 'equality' do
+    it 'should treat different MacroStrings with the same value as equal' do
+      arg = 'abc.%{dr-}.%%.test.com'
+      macro_string = Coppertone::MacroString.new(arg)
+      expect(macro_string == Coppertone::MacroString.new(arg))
+        .to eql(true)
+    end
+
+    it 'should otherwise treat different MacroStrings as unequal' do
+      arg = 'abc.%{dr-}.%%.test.com'
+      macro_string = Coppertone::MacroString.new(arg)
+      other_arg = 'eabc.%{dr-}.%%.test.com'
+      expect(macro_string == Coppertone::MacroString.new(other_arg))
+        .to eql(false)
+    end
+  end
+end

data/spec/mechanism/a_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+
+describe Coppertone::Mechanism::A do
+  context '#new' do
+    it 'should not fail if called with a nil argument' do
+      mech = Coppertone::Mechanism::A.new(nil)
+      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(128)
+    end
+
+    it 'should not fail if called with a blank argument' do
+      mech = Coppertone::Mechanism::A.new('')
+      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(128)
+    end
+
+    it 'should fail if called with an invalid macrostring' do
+      expect do
+        Coppertone::Mechanism::A.new(':abc%:def')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should parse a domain spec' do
+      mech = Coppertone::Mechanism::A.new(':_spf.%{d}.example.com')
+      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(32)
+      expect(mech.ip_v6_cidr_length).to eq(128)
+    end
+
+    it 'should parse a valid IP v4 CIDR length with a domain spec' do
+      mech = Coppertone::Mechanism::A.new(':_spf.%{d}.example.com/28')
+      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(128)
+    end
+
+    it 'should fail if called with an invalid macrostring and IPv4 CIDR' do
+      expect do
+        Coppertone::Mechanism::A.new(':abc%:def/28')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should parse a valid IP v4 CIDR length' 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_v6_cidr_length).to eq(128)
+    end
+
+    it 'should not parse an invalid IP v4 CIDR length' do
+      expect do
+        Coppertone::Mechanism::A.new('/36')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+
+      expect do
+        Coppertone::Mechanism::A.new('/a')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should parse a valid IP v6 CIDR length with a domain spec' do
+      mech = Coppertone::Mechanism::A.new(':_spf.%{d}.example.com//64')
+      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(32)
+      expect(mech.ip_v6_cidr_length).to eq('64')
+    end
+
+    it 'should fail if called with an invalid macrostring and IPv6 CIDR' do
+      expect do
+        Coppertone::Mechanism::A.new(':abc%:def//64')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should parse a valid IP v6 CIDR length' do
+      mech = Coppertone::Mechanism::A.new('//64')
+      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')
+    end
+
+    it 'should not parse an invalid IP v6 CIDR length' do
+      expect do
+        Coppertone::Mechanism::A.new('//133')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+
+      expect do
+        Coppertone::Mechanism::A.new('//a')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should parse a valid dual CIDR length with a domain spec' do
+      mech = Coppertone::Mechanism::A.new(':_spf.%{d}.example.com/28//64')
+      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')
+    end
+
+    it 'should not parse a invalid dual CIDR length with a domain spec' do
+      expect do
+        Coppertone::Mechanism::A.new('_spf.%{d}.example.com/28//133')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+      expect do
+        Coppertone::Mechanism::A.new('_spf.%{d}.example.com/44//64')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with an invalid macrostring and dual CIDR' do
+      expect do
+        Coppertone::Mechanism::A.new('abc%:def/28//64')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+  end
+
+  context '#create' do
+    it 'should fail if called with a nil argument' do
+      mech = Coppertone::Mechanism::A.create(nil)
+      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(128)
+    end
+
+    it 'should fail if called with a blank argument' do
+      mech = Coppertone::Mechanism::A.create('')
+      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(128)
+    end
+
+    it 'should fail if called with an argument invalid macrostring' do
+      expect do
+        Coppertone::Mechanism::A.create('abc%:def')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+  end
+
+  context '#match?' do
+    context 'simple' do
+      let(:mech_domain) { 'gmail.com' }
+      let(:mech_arg) { ":#{mech_domain}" }
+      let(:gmail_dns_client) do
+        dc = double(:dns_client)
+        allow(dc).to receive(:fetch_a_records)
+          .with(mech_domain).and_return([
+            {
+              type: 'A',
+              address: '74.125.239.117'
+            },
+            {
+              type: 'A',
+              address: '74.125.239.118'
+            }
+          ])
+        dc
+      end
+
+      let(:domain) { 'yahoo.com' }
+      let(:matching_context) 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)
+          .to receive(:new).and_return(gmail_dns_client)
+      end
+
+      it 'should match when the IP matches the record' do
+        mech = Coppertone::Mechanism::A.create(mech_arg)
+        expect(mech.match?(matching_context, Coppertone::RequestContext.new))
+          .to eq(true)
+      end
+
+      it 'should not match when the IP does not match the record' do
+        mech = Coppertone::Mechanism::A.create(mech_arg)
+        expect(mech.match?(not_matching_context, Coppertone::RequestContext.new))
+          .to eq(false)
+      end
+    end
+  end
+end

data/spec/mechanism/all_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+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)
+  end
+
+  it 'should not allow creation of new instances' do
+    expect do
+      Coppertone::Mechanism::All.new('')
+    end.to raise_error(NoMethodError)
+  end
+
+  context '#create' do
+    it 'should fail if any arguments are passed that are not blank' do
+      expect do
+        Coppertone::Mechanism::All.create('abcd')
+      end.to raise_error(Coppertone::RecordParsingError)
+    end
+  end
+end

data/spec/mechanism/exists_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Coppertone::Mechanism::Exists do
+  context '#new' do
+    it 'should fail if called with a nil argument' do
+      expect do
+        Coppertone::Mechanism::Exists.new(nil)
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with a blank argument' do
+      expect do
+        Coppertone::Mechanism::Exists.new('')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with an invalid macrostring' do
+      expect do
+        Coppertone::Mechanism::Exists.new(':abc%:def')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+  end
+
+  context '#create' do
+    it 'should fail if called with a nil argument' do
+      expect do
+        Coppertone::Mechanism::Exists.create(nil)
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with a blank argument' do
+      expect do
+        Coppertone::Mechanism::Exists.create('')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with an invalid macrostring' do
+      expect do
+        Coppertone::Mechanism::Exists.create(':abc%:def')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+  end
+
+  context '#match?' do
+    context 'simple' do
+      let(:mech_domain) { 'iexist.com' }
+      let(:mech_arg) { ":#{mech_domain}" }
+      let(:bad_domain) { 'idontexist.com' }
+      let(:bad_arg) { ":#{bad_domain}" }
+      let(:dns_client) do
+        dc = double(:dns_client)
+        allow(dc).to receive(:fetch_a_records)
+          .with(mech_domain).and_return([
+            {
+              type: 'A',
+              address: '74.125.234.117'
+            }
+          ])
+        allow(dc).to receive(:fetch_a_records)
+          .with(bad_domain).and_return([])
+        dc
+      end
+
+      let(:domain) { 'yahoo.com' }
+      let(:matching_context) 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)
+          .to receive(:new).and_return(dns_client)
+      end
+
+      it 'should match when the domain record for the target name exists' do
+        mech = Coppertone::Mechanism::Exists.create(mech_arg)
+        expect(mech.match?(matching_context, Coppertone::RequestContext.new))
+          .to eq(true)
+      end
+
+      it 'should match when the domain record for the target name exists' do
+        mech = Coppertone::Mechanism::Exists.create(bad_arg)
+        expect(mech.match?(matching_context, Coppertone::RequestContext.new))
+          .to eq(false)
+      end
+    end
+  end
+end

data/spec/mechanism/include_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Coppertone::Mechanism::Include do
+  context '#new' do
+    it 'should fail if called with a nil argument' do
+      expect do
+        Coppertone::Mechanism::Include.new(nil)
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with a blank argument' do
+      expect do
+        Coppertone::Mechanism::Include.new('')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with an invalid macrostring' do
+      expect do
+        Coppertone::Mechanism::Include.new('abc%:def')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+  end
+
+  context '#create' do
+    it 'should fail if called with a nil argument' do
+      expect do
+        Coppertone::Mechanism::Include.create(nil)
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with a blank argument' do
+      expect do
+        Coppertone::Mechanism::Include.create('')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with an argument invalid macrostring' do
+      expect do
+        Coppertone::Mechanism::Include.create('abc%:def')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+  end
+end

data/spec/mechanism/ip4_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Coppertone::Mechanism::IP4 do
+  context '#new' do
+    it 'should fail if called with a nil argument' do
+      expect do
+        Coppertone::Mechanism::IP4.new(nil)
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with a blank argument' do
+      expect do
+        Coppertone::Mechanism::IP4.new('')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with an invalid IP' do
+      expect do
+        Coppertone::Mechanism::IP4.new(':not_an_ip')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    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'))
+    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'))
+    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'))
+    end
+  end
+
+  context '#create' do
+    it 'should fail if called with a nil argument' do
+      expect do
+        Coppertone::Mechanism::IP4.create(nil)
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with a blank argument' do
+      expect do
+        Coppertone::Mechanism::IP4.create('')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with an invalid IP' do
+      expect do
+        Coppertone::Mechanism::IP4.create(':not_an_ip')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should not fail if called with an IP v6' do
+      mech = Coppertone::Mechanism::IP4.create(':fe80::202:b3ff:fe1e:8329')
+      expect(mech.ip_network).to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329'))
+    end
+
+    it 'should work if called with an IP4' do
+      mech = Coppertone::Mechanism::IP4.create(':1.2.3.4')
+      expect(mech.ip_network).to eq(IPAddr.new('1.2.3.4'))
+    end
+
+    it 'should work if called with an IP4 with a pfxlen' do
+      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')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+  end
+
+  context '.match' do
+    let(:client_ip) { IPAddr.new('4.5.6.7') }
+
+    let(:macro_context) do
+      mc = double(:macro_context)
+      allow(mc).to receive(:ip_v4).and_return(client_ip)
+      mc
+    end
+
+    let(:ip_v6_macro_context) do
+      mc = double(:macro_context)
+      allow(mc).to receive(:ip_v4).and_return(nil)
+      mc
+    end
+
+    it 'should return true if the client IP is in the network' do
+      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')
+      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')
+      expect(mech.match?(ip_v6_macro_context, double)).to eq(false)
+    end
+  end
+end

data/spec/mechanism/ip6_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe Coppertone::Mechanism::IP6 do
+  context '#new' do
+    it 'should fail if called with a nil argument' do
+      expect do
+        Coppertone::Mechanism::IP6.new(nil)
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with a blank argument' do
+      expect do
+        Coppertone::Mechanism::IP6.new('')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with an invalid IP' do
+      expect do
+        Coppertone::Mechanism::IP6.new('not_an_ip')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should not fail if called with an IP v4' do
+      mech = Coppertone::Mechanism::IP6.new('1.2.3.4')
+      expect(mech.ip_network).to eq(IPAddr.new('1.2.3.4'))
+    end
+
+    it 'should work if called with an IP6' do
+      mech = Coppertone::Mechanism::IP6.new('fe80::202:b3ff:fe1e:8329')
+      expect(mech.ip_network)
+        .to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329'))
+    end
+
+    it 'should work if called with an IP6 with a pfxlen' do
+      mech = Coppertone::Mechanism::IP6.new('fe80::202:b3ff:fe1e:8329/64')
+      expect(mech.ip_network)
+        .to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329/64'))
+    end
+
+    it 'should fail if called with an invalid pfxlen' do
+      expect do
+        Coppertone::Mechanism::IP6.new('fe80::202:b3ff:fe1e:8329/384')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+  end
+
+  context '#create' do
+    it 'should fail if called with a nil argument' do
+      expect do
+        Coppertone::Mechanism::IP6.create(nil)
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with a blank argument' do
+      expect do
+        Coppertone::Mechanism::IP6.create('')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should fail if called with an invalid IP' do
+      expect do
+        Coppertone::Mechanism::IP6.create('not_an_ip')
+      end.to raise_error(Coppertone::InvalidMechanismError)
+    end
+
+    it 'should not fail if called with an IP v4' do
+      mech = Coppertone::Mechanism::IP6.create('1.2.3.4')
+      expect(mech.ip_network).to eq(IPAddr.new('1.2.3.4'))
+    end
+
+    it 'should work if called with an IP6' do
+      mech = Coppertone::Mechanism::IP6.create('fe80::202:b3ff:fe1e:8329')
+      expect(mech.ip_network)
+        .to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329'))
+    end
+
+    it 'should work if called with an IP6 with a pfxlen' do
+      mech = Coppertone::Mechanism::IP6.create('fe80::202:b3ff:fe1e:8329/64')
+      expect(mech.ip_network)
+        .to eq(IPAddr.new('fe80::202:b3ff:fe1e:8329/64'))
+    end
+  end
+
+  context '.match' do
+    let(:client_ip) { IPAddr.new('fe80::202:b3ff:fe1e:8329') }
+
+    let(:macro_context) do
+      mc = double(:macro_context)
+      allow(mc).to receive(:ip_v6).and_return(client_ip)
+      mc
+    end
+
+    it 'should return true if the client IP is in the network' do
+      mech = Coppertone::Mechanism::IP6.create('fe80:0:0:0:202:b3ff:fe1e:8300/120')
+      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::IP6.create('fe80:0:0:0:202:b3ff:fe1e:8300/126')
+      expect(mech.match?(macro_context, double)).to eq(false)
+    end
+  end
+end