coppertone 0.0.1

data/lib/coppertone.rb

@@ -0,0 +1,48 @@
+require 'active_support/core_ext/object/blank'
+
+# A library for evaluating, creating, and analyzing SPF records
+module Coppertone
+  class << self
+    def config
+      @config ||= OpenStruct.new(defaults)
+    end
+
+    def defaults
+      {
+        hostname: nil,
+        message_locale: 'en',
+        terms_requiring_dns_lookup_limit: 10,
+        dns_lookups_per_mx_mechanism_limit: 10,
+        dns_lookups_per_ptr_mechanism_limit: 10,
+        void_dns_result_limit: 2,
+        dns_client_class: nil,
+        default_explanation: 'DEFAULT'
+      }
+    end
+
+    # Used for testing.
+    def reset_config
+      @config = nil
+    end
+  end
+end
+
+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/macro_string'
+require 'coppertone/request_context'
+require 'coppertone/domain_spec'
+require 'coppertone/directive'
+require 'coppertone/modifier'
+require 'coppertone/term'
+require 'coppertone/record'
+require 'coppertone/record_evaluator'
+require 'coppertone/record_finder'
+require 'coppertone/request'
+require 'coppertone/spf_service'

data/lib/resolv/dns/resource/in/spf.rb

@@ -0,0 +1,15 @@
+require 'resolv'
+
+class Resolv
+  class DNS
+    class Resource
+      module IN
+        # DNS record type for SPF records
+        class SPF < Resolv::DNS::Resource::IN::TXT
+          # resolv.rb doesn't define an SPF resource type.
+          TypeValue = 99 # rubocop:disable Style/ConstantName
+        end
+      end
+    end
+  end
+end

data/spec/directive_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Coppertone::Directive do
+  context '#matching_term' do
+    it "returns nil if the term contains a '='" do
+      expect(Coppertone::Directive.matching_term('all')).not_to be_nil
+      expect(Coppertone::Directive.matching_term('all=')).to be_nil
+      expect(Coppertone::Directive.matching_term('all=783')).to be_nil
+    end
+
+    it 'returns nil if the term is not a known directive' do
+      expect(Coppertone::Directive.matching_term('unknown')).to be_nil
+      expect(Coppertone::Directive.matching_term('~unknown')).to be_nil
+    end
+
+    it 'returns nil if the term is not a known qualifier' do
+      expect(Coppertone::Directive.matching_term('+all')).not_to be_nil
+      expect(Coppertone::Directive.matching_term('!all')).to be_nil
+    end
+
+    it 'passes attributes' do
+      directive = Coppertone::Directive.matching_term('-ip4:192.1.1.1')
+      expect(directive).not_to be_nil
+      expect(directive.qualifier).to eq(Coppertone::Qualifier::FAIL)
+      mechanism = directive.mechanism
+      expect(mechanism).not_to be_nil
+      expect(mechanism).to eq(Coppertone::Mechanism::IP4.new('192.1.1.1'))
+    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
+        directive = Coppertone::Directive.matching_term("#{q.text}all")
+        result = directive.evaluate(nil, nil)
+        expect(result).not_to be_nil
+        expect(result.code).to eq(q.result_code)
+      end
+    end
+  end
+end

data/spec/dns/resolv_client_spec.rb

@@ -0,0 +1,307 @@
+require 'spec_helper'
+
+describe Coppertone::DNS::ResolvClient do
+  subject { Coppertone::DNS::ResolvClient.new }
+  let(:mock_resolver) { double(:resolver) }
+
+  context '#fetch_a_records' do
+    let(:first_a_addr) { Resolv::IPv4.new([127, 0, 0, 1].pack('CCCC')) }
+    let(:first_a_record) { Resolv::DNS::Resource::IN::A.new(first_a_addr) }
+    let(:second_a_addr) { Resolv::IPv4.new([192, 168, 8, 14].pack('CCCC')) }
+    let(:second_a_record) { Resolv::DNS::Resource::IN::A.new(second_a_addr) }
+    let(:record_list) { [first_a_record, second_a_record] }
+    let(:domain) { 'example.com' }
+    let(:domain_with_trailing) { "#{domain}." }
+
+    it 'should map the Resolv classes to a set of hashes' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::A).and_return(record_list)
+      results = subject.fetch_a_records(domain)
+      expect(results.size).to eq(record_list.length)
+      expect(results.map { |x| x[:type] })
+        .to eq(record_list.length.times.map { 'A' })
+      expect(results.map { |x| x[:address] })
+        .to eq(record_list.map(&:address).map(&:to_s))
+    end
+
+    it 'should map when the domain has a trailing dot' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::A).and_return(record_list)
+      results = subject.fetch_a_records(domain_with_trailing)
+      expect(results.size).to eq(record_list.length)
+      expect(results.map { |x| x[:type] })
+        .to eq(record_list.length.times.map { 'A' })
+      expect(results.map { |x| x[:address] })
+        .to eq(record_list.map(&:address).map(&:to_s))
+    end
+
+    it 'should map the Resolv errors to Coppertone errors' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::A)
+        .and_raise(Resolv::ResolvError)
+      expect do
+        subject.fetch_a_records(domain_with_trailing)
+      end.to raise_error(Coppertone::DNS::Error)
+    end
+
+    it 'should map the Resolv timeout errors to Coppertone errors' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::A)
+        .and_raise(Resolv::ResolvTimeout)
+      expect do
+        subject.fetch_a_records(domain_with_trailing)
+      end.to raise_error(Coppertone::DNS::TimeoutError)
+    end
+  end
+
+  context '#fetch_aaaa_records' do
+    let(:first_aaaa_addr) do
+      Resolv::IPv6.create('FE80:10:1:1:202:B3FF:FE1E:8329')
+    end
+    let(:first_aaaa_record) do
+      Resolv::DNS::Resource::IN::AAAA.new(first_aaaa_addr)
+    end
+    let(:second_aaaa_addr) do
+      Resolv::IPv6.create('AB61:10:111:891:4202:B3FF:FE1E:7329')
+    end
+    let(:second_aaaa_record) do
+      Resolv::DNS::Resource::IN::AAAA.new(second_aaaa_addr)
+    end
+    let(:record_list) { [first_aaaa_record, second_aaaa_record] }
+    let(:domain) { 'example.com' }
+    let(:domain_with_trailing) { "#{domain}." }
+
+    it 'should map the Resolv classes to a set of hashes' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::AAAA).and_return(record_list)
+      results = subject.fetch_aaaa_records(domain)
+      expect(results.size).to eq(record_list.length)
+      expect(results.map { |x| x[:type] })
+        .to eq(record_list.length.times.map { 'AAAA' })
+      expect(results.map { |x| x[:address] })
+        .to eq(record_list.map(&:address).map(&:to_s))
+    end
+
+    it 'should map when the domain has a trailing dot' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::AAAA).and_return(record_list)
+      results = subject.fetch_aaaa_records(domain_with_trailing)
+      expect(results.size).to eq(record_list.length)
+      expect(results.map { |x| x[:type] })
+        .to eq(record_list.length.times.map { 'AAAA' })
+      expect(results.map { |x| x[:address] })
+        .to eq(record_list.map(&:address).map(&:to_s))
+    end
+
+    it 'should map the Resolv errors to Coppertone errors' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::AAAA)
+        .and_raise(Resolv::ResolvError)
+      expect { subject.fetch_aaaa_records(domain_with_trailing) }
+        .to raise_error(Coppertone::DNS::Error)
+    end
+
+    it 'should map the Resolv timeout errors to Coppertone errors' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::AAAA)
+        .and_raise(Resolv::ResolvTimeout)
+      expect { subject.fetch_aaaa_records(domain_with_trailing) }
+        .to raise_error(Coppertone::DNS::TimeoutError)
+    end
+  end
+
+  context '#fetch_mx_records' do
+    let(:first_mx_name) do
+      Resolv::DNS::Name.create('alt1.aspmx.l.google.com.')
+    end
+    let(:first_mx_record) do
+      Resolv::DNS::Resource::IN::MX.new(20, first_mx_name)
+    end
+    let(:second_mx_name) do
+      Resolv::DNS::Name.create('aspmx.l.google.com')
+    end
+    let(:second_mx_record) do
+      Resolv::DNS::Resource::IN::MX.new(10, second_mx_name)
+    end
+    let(:record_list) { [first_mx_record, second_mx_record] }
+    let(:domain) { 'example.com' }
+    let(:domain_with_trailing) { "#{domain}." }
+
+    it 'should map the Resolv classes to a set of hashes' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::MX).and_return(record_list)
+      results = subject.fetch_mx_records(domain)
+      expect(results.size).to eq(record_list.length)
+      expect(results.map { |x| x[:type] })
+        .to eq(record_list.length.times.map { 'MX' })
+      expect(results.map { |x| x[:exchange] })
+        .to eq(record_list.map(&:exchange).map(&:to_s))
+    end
+
+    it 'should map when the domain has a trailing dot' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::MX).and_return(record_list)
+      results = subject.fetch_mx_records(domain_with_trailing)
+      expect(results.size).to eq(record_list.length)
+      expect(results.map { |x| x[:type] })
+        .to eq(record_list.length.times.map { 'MX' })
+      expect(results.map { |x| x[:exchange] })
+        .to eq(record_list.map(&:exchange).map(&:to_s))
+    end
+
+    it 'should map the Resolv errors to Coppertone errors' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::MX).and_raise(Resolv::ResolvError)
+      expect { subject.fetch_mx_records(domain_with_trailing) }
+        .to raise_error(Coppertone::DNS::Error)
+    end
+
+    it 'should map the Resolv timeout errors to Coppertone errors' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::MX)
+        .and_raise(Resolv::ResolvTimeout)
+      expect { subject.fetch_mx_records(domain_with_trailing) }
+        .to raise_error(Coppertone::DNS::TimeoutError)
+    end
+  end
+
+  context '#fetch_txt_records' do
+    let(:first_txt_string) { SecureRandom.hex(10) }
+    let(:first_txt_record) do
+      Resolv::DNS::Resource::IN::TXT.new(first_txt_string)
+    end
+    let(:second_txt_string) { SecureRandom.hex(10) }
+    let(:second_txt_string_array) do
+      [SecureRandom.hex(10), SecureRandom.hex(10)]
+    end
+    let(:second_txt_record) do
+      Resolv::DNS::Resource::IN::TXT.new(second_txt_string,
+                                         second_txt_string_array)
+    end
+    let(:record_list) { [first_txt_record, second_txt_record] }
+    let(:domain) { 'example.com' }
+    let(:domain_with_trailing) { "#{domain}." }
+
+    it 'should map the Resolv classes to a set of hashes' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+                               .with(domain, Resolv::DNS::Resource::IN::TXT)
+                               .and_return(record_list)
+      results = subject.fetch_txt_records(domain)
+      expect(results.size).to eq(record_list.length)
+      expect(results.map { |x| x[:type] })
+        .to eq(record_list.length.times.map { 'TXT' })
+      expect(results.map { |x| x[:text] }).to eq(
+        [first_txt_string,
+         ([second_txt_string] + second_txt_string_array).join('')])
+    end
+
+    it 'should map when the domain has a trailing dot' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+                               .with(domain, Resolv::DNS::Resource::IN::TXT)
+                               .and_return(record_list)
+      results = subject.fetch_txt_records(domain_with_trailing)
+      expect(results.size).to eq(record_list.length)
+      expect(results.map { |x| x[:type] })
+        .to eq(record_list.length.times.map { 'TXT' })
+      expect(results.map { |x| x[:text] }).to eq(
+        [first_txt_string,
+         ([second_txt_string] + second_txt_string_array).join('')])
+    end
+
+    it 'should map the Resolv errors to Coppertone errors' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::TXT)
+        .and_raise(Resolv::ResolvError)
+      expect { subject.fetch_txt_records(domain_with_trailing) }
+        .to raise_error(Coppertone::DNS::Error)
+    end
+
+    it 'should map the Resolv timeout errors to Coppertone errors' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::TXT)
+        .and_raise(Resolv::ResolvTimeout)
+      expect { subject.fetch_txt_records(domain_with_trailing) }
+        .to raise_error(Coppertone::DNS::TimeoutError)
+    end
+  end
+
+  context '#fetch_spf_records' do
+    let(:first_spf_string) { SecureRandom.hex(10) }
+    let(:first_spf_record) do
+      Resolv::DNS::Resource::IN::TXT.new(first_spf_string)
+    end
+    let(:second_spf_string) { SecureRandom.hex(10) }
+    let(:second_spf_string_array) do
+      [SecureRandom.hex(10), SecureRandom.hex(10)]
+    end
+    let(:second_spf_record) do
+      Resolv::DNS::Resource::IN::SPF.new(second_spf_string,
+                                         second_spf_string_array)
+    end
+    let(:record_list) { [first_spf_record, second_spf_record] }
+    let(:domain) { 'example.com' }
+    let(:domain_with_trailing) { "#{domain}." }
+
+    it 'should map the Resolv classes to a set of hashes' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+                               .with(domain, Resolv::DNS::Resource::IN::SPF)
+                               .and_return(record_list)
+      results = subject.fetch_spf_records(domain)
+      expect(results.size).to eq(record_list.length)
+      expect(results.map { |x| x[:type] })
+        .to eq(record_list.length.times.map { 'SPF' })
+      expect(results.map { |x| x[:text] }).to eq(
+        [first_spf_string,
+         ([second_spf_string] + second_spf_string_array).join('')])
+    end
+
+    it 'should map when the domain has a trailing dot' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+                               .with(domain, Resolv::DNS::Resource::IN::SPF)
+                               .and_return(record_list)
+      results = subject.fetch_spf_records(domain_with_trailing)
+      expect(results.size).to eq(record_list.length)
+      expect(results.map { |x| x[:type] })
+        .to eq(record_list.length.times.map { 'SPF' })
+      expect(results.map { |x| x[:text] }).to eq(
+        [first_spf_string,
+         ([second_spf_string] + second_spf_string_array).join('')])
+    end
+
+    it 'should map the Resolv errors to Coppertone errors' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::SPF)
+        .and_raise(Resolv::ResolvError)
+      expect { subject.fetch_spf_records(domain_with_trailing) }
+        .to raise_error(Coppertone::DNS::Error)
+    end
+
+    it 'should map the Resolv timeout errors to Coppertone errors' do
+      expect(Resolv::DNS).to receive(:new).and_return(mock_resolver)
+      expect(mock_resolver).to receive(:getresources)
+        .with(domain, Resolv::DNS::Resource::IN::SPF)
+        .and_raise(Resolv::ResolvTimeout)
+      expect { subject.fetch_spf_records(domain_with_trailing) }
+        .to raise_error(Coppertone::DNS::TimeoutError)
+    end
+  end
+end

data/spec/domain_spec_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Coppertone::DomainSpec do
+  it 'raises no exception for a normal string' do
+    expect(Coppertone::DomainSpec.new('gmail.com')).not_to be_nil
+  end
+
+  it 'raises no exception for a macro with allowed terms' do
+    expect(Coppertone::DomainSpec.new('%{s}%{l}%{o}%{d}%{i}%{v}'))
+      .not_to be_nil
+    expect(Coppertone::DomainSpec.new('%{S}%{L}%{O}%{D}%{I}%{V}'))
+      .not_to be_nil
+  end
+
+  it 'raises no exception for a macro with reverse' do
+    expect(Coppertone::DomainSpec.new('%{sr}%{lr}%{or}%{dr}%{ir}%{vr}'))
+      .not_to be_nil
+    expect(Coppertone::DomainSpec.new('%{Sr}%{Lr}%{Or}%{Dr}%{Ir}%{Vr}'))
+      .not_to be_nil
+  end
+
+  it 'raises an error when the macro string is malformed' do
+    expect do
+      Coppertone::DomainSpec.new('%&')
+    end.to raise_error(Coppertone::DomainSpecParsingError)
+  end
+
+  it 'raises an error when the macro string contains forbidden macros' do
+    %w(c r t).each do |m|
+      expect do
+        Coppertone::DomainSpec.new("%{#{m}}")
+      end.to raise_error(Coppertone::DomainSpecParsingError)
+    end
+  end
+end

data/spec/ip_address_wrapper_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Coppertone::IPAddressWrapper do
+  it 'should raise an ArgumentError when passed a nil arg' do
+    expect do
+      Coppertone::IPAddressWrapper.new(nil)
+    end.to raise_error(ArgumentError)
+  end
+
+  it 'should raise an ArgumentError when passed an invalid arg' do
+    expect do
+      Coppertone::IPAddressWrapper.new('invalid')
+    end.to raise_error(ArgumentError)
+  end
+
+  context 'ipv4' do
+    it 'should yield expected values' do
+      ip_as_s = '1.2.3.4'
+      ipw = Coppertone::IPAddressWrapper.new(ip_as_s)
+      expect(ipw.ip_v4).to eq(IPAddr.new(ip_as_s))
+      expect(ipw.ip_v6).to be_nil
+      expect(ipw.c).to eq(ip_as_s)
+      expect(ipw.i).to eq(ip_as_s)
+      expect(ipw.v).to eq('in-addr')
+    end
+
+    it 'should raise an ArgumentError when passed an IP with a prefix' do
+      expect do
+        Coppertone::IPAddressWrapper.new('1.2.3.4/24')
+      end.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'ipv6' do
+    context 'when the address is not IP4 mapped' do
+      it 'should yield expected values' do
+        ip_as_s = 'FE80:0000:0000:0000:0202:B3FF:FE1E:8329'
+        ipw = Coppertone::IPAddressWrapper.new(ip_as_s)
+        expect(ipw.ip_v6).to eq(IPAddr.new(ip_as_s))
+        expect(ipw.ip_v4).to be_nil
+        dotted =
+          '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')
+      end
+    end
+
+    context 'when the address is IP4 mapped' do
+      it 'should treat it as an IP4 address' do
+        ip_v4_as_s = '1.2.3.4'
+        ip_as_s = "::ffff:#{ip_v4_as_s}"
+        ipw = Coppertone::IPAddressWrapper.new(ip_as_s)
+        expect(ipw.ip_v6).to be_nil
+        expect(ipw.ip_v4).to eq(IPAddr.new(ip_v4_as_s))
+        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')
+      end
+    end
+
+    it 'should raise an ArgumentError when passed an IP with a prefix' do
+      expect do
+        Coppertone::IPAddressWrapper.new('1.2.3.4/96')
+      end.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/macro_context_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Coppertone::MacroContext do
+  let(:domain) { 'yahoo.com' }
+  let(:sender) { 'test em!?axt@gmail.com' }
+  let(:ip_v4) { '1.2.3.4' }
+  let(:ip_v6) { 'fe80::202:b3ff:fe1e:8329' }
+
+  let(:machine_hostname) { 'mta.receiver-1.xyz.com' }
+
+  before do
+    allow(Coppertone::Utils::HostUtils)
+      .to receive(:hostname).and_return(machine_hostname)
+  end
+
+  context 'ip_v4' do
+    it 'should map as expected' do
+      mc = Coppertone::MacroContext.new(domain, ip_v4, sender)
+      expect(mc.s).to eq(sender)
+      expect(mc.l).to eq('test em!?axt')
+      expect(mc.o).to eq('gmail.com')
+      expect(mc.d).to eq(domain)
+      expect(mc.i).to eq(ip_v4)
+      expect(mc.v).to eq('in-addr')
+      # TODO: PMG - Add support for 'p'
+      expect(mc.c).to eq(ip_v4)
+      before = Time.now.to_i
+      t = mc.t
+      after = Time.now.to_i
+      expect(t >= before).to eq(true)
+      expect(t <= after).to eq(true)
+      expect(mc.r).to eq(machine_hostname)
+
+      expect(mc.S).to eq('test%20em!%3Faxt%40gmail.com')
+      expect(mc.L).to eq('test%20em!%3Faxt')
+      expect(mc.O).to eq('gmail.com')
+      expect(mc.D).to eq(domain)
+      expect(mc.I).to eq(ip_v4)
+      expect(mc.V).to eq('in-addr')
+    end
+  end
+
+  context 'ip_v6' do
+    it 'should map as expected' do
+      mc = Coppertone::MacroContext.new(domain, ip_v6, sender)
+      expect(mc.s).to eq(sender)
+      expect(mc.l).to eq('test em!?axt')
+      expect(mc.o).to eq('gmail.com')
+      expect(mc.d).to eq(domain)
+      dip = '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(mc.i).to eq(dip)
+      expect(mc.v).to eq('ip6')
+      # TODO: PMG - Add support for 'p'
+      expect(mc.c).to eq(ip_v6)
+      before = Time.now.to_i
+      t = mc.t
+      after = Time.now.to_i
+      expect(t >= before).to eq(true)
+      expect(t <= after).to eq(true)
+
+      expect(mc.S).to eq('test%20em!%3Faxt%40gmail.com')
+      expect(mc.L).to eq('test%20em!%3Faxt')
+      expect(mc.O).to eq('gmail.com')
+      expect(mc.D).to eq(domain)
+      expect(mc.I).to eq(dip)
+      expect(mc.V).to eq('ip6')
+    end
+  end
+end

data/spec/macro_string/macro_expand_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Coppertone::MacroString::MacroExpand do
+  context 'equality' do
+    it 'should treat different MacroExpands with the same value as equal' do
+      arg = 'dr-'
+      macro = Coppertone::MacroString::MacroExpand.new(arg)
+      expect(macro == Coppertone::MacroString::MacroExpand.new(arg))
+        .to eql(true)
+    end
+
+    it 'should otherwise treat different MacroExpands as unequal' do
+      arg = 'dr-'
+      macro = Coppertone::MacroString::MacroExpand.new(arg)
+      other_arg = 'r3+'
+      expect(macro == Coppertone::MacroString::MacroExpand.new(other_arg))
+        .to eql(false)
+    end
+  end
+
+  context 'expand' do
+    let(:domain) { 'yahoo.com' }
+    let(:sender) { 'admin-user@gmail.com' }
+    let(:ip_v4) { '1.2.3.4' }
+    let(:ip_v6) { 'fe80::202:b3ff:fe1e:8329' }
+
+    context 'ip_v4' do
+      let(:context) { Coppertone::MacroContext.new(domain, ip_v4, sender) }
+      it 'should expand as expected' do
+        expect(Coppertone::MacroString::MacroExpand.new('d').expand(context))
+          .to eq('yahoo.com')
+        expect(Coppertone::MacroString::MacroExpand.new('d1').expand(context))
+          .to eq('com')
+        expect(Coppertone::MacroString::MacroExpand.new('dr').expand(context))
+          .to eq('com.yahoo')
+        expect(Coppertone::MacroString::MacroExpand.new('d1r').expand(context))
+          .to eq('yahoo')
+
+        expect(Coppertone::MacroString::MacroExpand.new('o').expand(context))
+          .to eq('gmail.com')
+        expect(Coppertone::MacroString::MacroExpand.new('o1').expand(context))
+          .to eq('com')
+        expect(Coppertone::MacroString::MacroExpand.new('or').expand(context))
+          .to eq('com.gmail')
+        expect(Coppertone::MacroString::MacroExpand.new('o1r').expand(context))
+          .to eq('gmail')
+
+        expect(Coppertone::MacroString::MacroExpand.new('l').expand(context))
+          .to eq('admin-user')
+        expect(Coppertone::MacroString::MacroExpand.new('l1').expand(context))
+          .to eq('admin-user')
+        expect(Coppertone::MacroString::MacroExpand.new('l1-').expand(context))
+          .to eq('user')
+        expect(Coppertone::MacroString::MacroExpand.new('lr').expand(context))
+          .to eq('admin-user')
+        expect(Coppertone::MacroString::MacroExpand.new('lr-').expand(context))
+          .to eq('user.admin')
+        expect(Coppertone::MacroString::MacroExpand.new('l1r-').expand(context))
+          .to eq('admin')
+
+        expect(Coppertone::MacroString::MacroExpand.new('i').expand(context))
+          .to eq('1.2.3.4')
+        expect(Coppertone::MacroString::MacroExpand.new('i2').expand(context))
+          .to eq('3.4')
+        expect(Coppertone::MacroString::MacroExpand.new('i6').expand(context))
+          .to eq('1.2.3.4')
+        expect(Coppertone::MacroString::MacroExpand.new('ir').expand(context))
+          .to eq('4.3.2.1')
+        expect(Coppertone::MacroString::MacroExpand.new('i2r').expand(context))
+          .to eq('2.1')
+        expect(Coppertone::MacroString::MacroExpand.new('i6r').expand(context))
+          .to eq('4.3.2.1')
+
+        expect(Coppertone::MacroString::MacroExpand.new('v').expand(context))
+          .to eq('in-addr')
+      end
+    end
+  end
+end