reps_client 0.0.1

data/spec/reps_client/configuration_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe RepsClient::Configuration do
+  let(:test_module) do
+    module TestModule
+      extend RepsClient::Configuration
+    end
+  end
+
+  subject { test_module }
+
+  let(:endpoint) { 'http://configured.endpoint.com' }
+  let(:username) { 'configured user' }
+  let(:password) { 'configured password' }
+  let(:namespace) { 'http://configured.namespace.com' }
+  let(:enterprise_key) { 'my_enterprise_key' }
+
+  after { test_module.reset }
+
+  it { should respond_to(:configure) }
+
+  context 'with default configuration' do
+    its(:endpoint) { should == RepsClient::DEFAULT_ENDPOINT }
+    its(:namespace) { should == RepsClient::DEFAULT_NAMESPACE }
+    its(:username) { should_not be }
+    its(:password) { should_not be }
+    its(:enterprise_key) { should_not be }
+  end
+
+  describe '.configure' do
+    subject { test_module.configure(&config_block) }
+
+    context 'with full configuration' do
+      let(:config_block) do
+        lambda do |config|
+          config.endpoint = endpoint
+          config.username = username
+          config.password = password
+          config.namespace = namespace
+          config.enterprise_key = enterprise_key
+        end
+      end
+
+      it { should == test_module }
+
+      its(:endpoint) { should == endpoint }
+      its(:username) { should == username }
+      its(:password) { should == password }
+      its(:namespace) { should == namespace }
+      its(:enterprise_key) { should == enterprise_key }
+    end
+
+    context 'with partial configuration' do
+      let(:config_block) do
+        lambda do |config|
+          config.username = username
+          config.password = password
+          config.enterprise_key = enterprise_key
+        end
+      end
+
+      it { should == test_module }
+
+      its(:endpoint) { should == RepsClient::DEFAULT_ENDPOINT }
+      its(:namespace) { should == RepsClient::DEFAULT_NAMESPACE }
+      its(:username) { should == username }
+      its(:password) { should == password }
+      its(:enterprise_key) { should == enterprise_key }
+    end
+  end
+
+  it { should respond_to(:reset) }
+
+  describe '.reset' do
+    before do
+      test_module.configure do |config|
+        config.endpoint = endpoint
+        config.username = username
+        config.password = password
+        config.namespace = namespace
+        config.enterprise_key = enterprise_key
+      end
+    end
+
+    subject { test_module.reset }
+
+    it 'should change the endpoint to the default value' do
+      expect { subject }.to change { test_module.endpoint }.from(endpoint).to(RepsClient::DEFAULT_ENDPOINT)
+    end
+
+    it 'should change the namespace to the default value' do
+      expect { subject }.to change { test_module.namespace }.from(namespace).to(RepsClient::DEFAULT_NAMESPACE)
+    end
+
+    it 'should clear the username' do
+      expect { subject }.to change { test_module.username }.from(username).to(nil)
+    end
+
+    it 'should clear the password' do
+      expect { subject }.to change { test_module.password }.from(password).to(nil)
+    end
+
+    it 'should clear the enterprise key' do
+      expect { subject }.to change { test_module.enterprise_key }.from(enterprise_key).to(nil)
+    end
+  end
+
+  describe '.options' do
+    before do
+      test_module.configure do |config|
+        config.endpoint = endpoint
+        config.username = username
+        config.password = password
+        config.namespace = namespace
+        config.enterprise_key = enterprise_key
+      end
+    end
+
+    subject { test_module.options }
+
+    it { should have_key(:endpoint) }
+    its([:endpoint]) { should == endpoint }
+    it { should have_key(:namespace) }
+    its([:namespace]) { should == namespace }
+    it { should have_key(:username) }
+    its([:username]) { should == username }
+    it { should have_key(:password) }
+    its([:password]) { should == password }
+    it { should have_key(:enterprise_key) }
+    its([:enterprise_key]) { should == enterprise_key }
+  end
+end

data/spec/reps_client/errors_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe RepsClient::ServiceError do
+  subject { error }
+  let(:error) { RepsClient::ServiceError.new(message, code) }
+  let(:code) { 'my code' }
+  let(:message) { 'my message' }
+
+  context 'default initialization' do
+    let(:error) { RepsClient::ServiceError.new }
+
+    its(:code) { should be_nil }
+    its(:message) { should == error.class.name }
+  end
+
+  context 'with message' do
+    let(:error) { RepsClient::ServiceError.new(message) }
+
+    its(:code) { should be_nil }
+    its(:message) { should == message }
+  end
+
+  context 'full initialization' do
+    its(:code) { should == code }
+    its(:message) { should == message }
+  end
+
+  describe ".translate_fault" do
+    subject { RepsClient::ServiceError.translate_fault(fault) }
+    let(:fault) { Savon::SOAP::Fault.new(response) }
+    let(:response) { mock(:body => Savon::Spec::Fixture[:faults, fault_type]) }
+
+    context 'with an invalid enterprise key fault' do
+      let(:fault_type) { :invalid_enterprise_key_fault }
+
+      it { should be_a RepsClient::InvalidEnterpriseKeyError }
+      its(:code) { should == fault.to_hash[:fault][:faultcode] }
+      its(:message) { should == fault.to_hash[:fault][:faultstring] }
+    end
+
+    context 'with a soap client fault' do
+      let(:fault_type) { :client_fault }
+
+      it { should be_a RepsClient::ServiceError }
+      it { should_not be_a RepsClient::InvalidEnterpriseKeyError }
+      its(:code) { should == fault.to_hash[:fault][:faultcode] }
+      its(:message) { should == fault.to_hash[:fault][:faultstring] }
+    end
+  end
+end
+
+describe RepsClient::InvalidEnterpriseKeyError do
+  subject { RepsClient::InvalidEnterpriseKeyError.new }
+
+  it { should be_a_kind_of RepsClient::ServiceError }
+end

data/spec/reps_client/lead_spec.rb

@@ -0,0 +1,906 @@
+require 'spec_helper'
+
+describe RepsClient::Contact do
+  subject { contact }
+
+  let(:contact) { RepsClient::Contact.new(attributes) }
+
+  let(:prefix) { 'Dr.' }
+  let(:first_name) { 'Alice' }
+  let(:middle_name) { 'Amelia' }
+  let(:last_name) { 'Apple' }
+  let(:suffix) { 'M.D.' }
+  let(:address1) { '555 NW Park Ave' }
+  let(:address2) { 'Suite A' }
+  let(:city) { 'Portland' }
+  let(:state) { 'OR' }
+  let(:zip_code) { '97209' }
+  let(:country) { 'USA' }
+  let(:phone) { '5035555555' }
+  let(:phone_extension) { 'x555' }
+  let(:email) { 'dr.alice@appleaday.com' }
+  let(:relationship_to_prospect_id) { 42 }
+  let(:include_in_mailings) { true }
+  let(:include_in_emailings) { true }
+  let(:source_id) { 11235 }
+
+  context 'with minimal initialization' do
+    let(:attributes) do
+      {:source_id => source_id,
+       :first_name => first_name,
+       :last_name => last_name}
+    end
+
+    its(:prefix) { should be_nil }
+    its(:first_name) { should == first_name }
+    its(:middle_name) { should be_nil }
+    its(:last_name) { should == last_name }
+    its(:suffix) { should be_nil }
+    its(:address1) { should be_nil }
+    its(:address2) { should be_nil }
+    its(:city) { should be_nil }
+    its(:state) { should be_nil }
+    its(:zip_code) { should be_nil }
+    its(:country) { should be_nil }
+    its(:phone) { should be_nil }
+    its(:phone_extension) { should be_nil }
+    its(:email) { should be_nil }
+    its(:relationship_to_prospect_id) { should be_nil }
+    its(:include_in_mailings) { should == false }
+    its(:include_in_emailings) { should == false }
+    its(:source_id)  { should == source_id }
+
+    context 'with email' do
+      before { attributes[:email] = email }
+
+      its(:email) { should == email }
+      it { should be_valid }
+      it { should have_contact_method }
+
+      describe '#validate!' do
+        subject { contact.validate! }
+
+        it 'should not raise an error' do
+          expect { subject }.to_not raise_error
+        end
+      end
+
+      describe "#to_soap_hash" do
+        subject { contact.to_soap_hash }
+
+        it { should_not have_key('Prefix') }
+        its(['FirstName']) { should == first_name }
+        it { should_not have_key('MiddleName') }
+        its(['LastName']) { should == last_name }
+        it { should_not have_key('Suffix') }
+        it { should_not have_key('Address1') }
+        it { should_not have_key('Address2') }
+        it { should_not have_key('City') }
+        it { should_not have_key('State') }
+        it { should_not have_key('ZipCode') }
+        it { should_not have_key('Country') }
+        it { should_not have_key('Phone') }
+        it { should_not have_key('PhoneExtension') }
+        its(['Email']) { should == email }
+        it { should_not have_key('RelationshipToProspectId') }
+        its(['IncludeInMailings']) { should == false }
+        its(['IncludeInEmailings']) { should == false }
+        its(['SourceIDY']) { should == source_id }
+        its([:order!]) { should == ['FirstName','LastName','Email','IncludeInMailings','IncludeInEmailings','SourceIDY'] }
+      end
+
+    end
+
+    context 'with phone' do
+      before { attributes[:phone] = phone }
+
+      its(:phone) { should == phone }
+      it { should be_valid }
+      it { should have_contact_method }
+
+      describe '#validate!' do
+        subject { contact.validate! }
+
+        it 'should not raise an error' do
+          expect { subject }.to_not raise_error
+        end
+      end
+    end
+
+    context 'with mailing address' do
+      before do 
+        attributes.merge!(:address1 => address1, 
+                         :city => city, 
+                         :state => state, 
+                         :zip_code => zip_code)
+      end
+
+      its(:address1) { should == address1 }
+      its(:city) { should == city }
+      its(:state) { should == state }
+      its(:zip_code) { should == zip_code }
+
+      it { should be_valid }
+      it { should have_contact_method }
+
+      describe '#validate!' do
+        subject { contact.validate! }
+
+        it 'should not raise an error' do
+          expect { subject }.to_not raise_error
+        end
+      end
+
+      context 'when there is no street address' do
+        let(:address1) { nil }
+
+        its(:address1) { should be_nil }
+        it { should_not be_valid }
+        it_should_behave_like 'a contact attribute validator', :address1
+        it { should_not have_contact_method }
+
+        describe '#validate!' do
+          subject { contact.validate! }
+
+          it 'should raise an error' do
+            expect { subject }.to raise_error(ArgumentError)
+          end
+        end
+      end
+
+      context 'when there is no city' do
+        let(:city) { nil }
+
+        its(:city) { should be_nil }
+        it { should_not be_valid }
+        it_should_behave_like 'a contact attribute validator', :city
+        it { should_not have_contact_method }
+
+        describe '#validate!' do
+          subject { contact.validate! }
+
+          it 'should raise an error' do
+            expect { subject }.to raise_error(ArgumentError)
+          end
+        end
+      end
+
+      context 'when there is no state' do
+        let(:state) { nil }
+
+        its(:state) { should be_nil }
+        it { should_not be_valid }
+        it_should_behave_like 'a contact attribute validator', :state
+        it { should_not have_contact_method }
+
+        describe '#validate!' do
+          subject { contact.validate! }
+
+          it 'should raise an error' do
+            expect { subject }.to raise_error(ArgumentError)
+          end
+        end
+      end
+
+      context 'when there is no zip code' do
+        let(:zip_code) { nil }
+
+        its(:zip_code) { should be_nil }
+        it { should_not be_valid }
+        it_should_behave_like 'a contact attribute validator', :zip_code
+        it { should_not have_contact_method }
+
+        describe '#validate!' do
+          subject { contact.validate! }
+
+          it 'should raise an error' do
+            expect { subject }.to raise_error(ArgumentError)
+          end
+        end
+      end
+    end
+
+    context 'without any method of contact' do
+      it { should_not be_valid }
+      it { should_not have_contact_method }
+
+      describe "#validate!" do
+        subject { contact.validate! }
+
+        it 'should raise an error' do
+          expect { subject }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#validate' do
+        subject { contact.validate }
+
+        it { should have(6).error_mappings }
+
+        it { should have_key(:email) }
+
+        describe 'the errors on email' do
+         subject { contact.validate[:email] }
+
+         it { should have(1).error }
+         its(:first) { should be_an ArgumentError }
+        end
+
+        it { should have_key(:phone) }
+
+        describe 'the errors on phone' do
+          subject { contact.validate[:phone] }
+
+          it { should have(1).error }
+          its(:first) { should be_an ArgumentError }
+        end
+
+        it { should have_key(:address1) }
+
+        describe 'the errors on address1' do
+          subject { contact.validate[:address1] }
+
+          it { should have(1).error }
+          its(:first) { should be_an ArgumentError }
+        end
+
+        it { should have_key(:city) }
+
+        describe 'the errors on city' do
+          subject { contact.validate[:city] }
+
+          it { should have(1).error }
+          its(:first) { should be_an ArgumentError }
+        end
+
+        it { should have_key(:state) }
+
+        describe 'the errors on state' do
+          subject { contact.validate[:state] }
+
+          it { should have(1).error }
+          its(:first) { should be_an ArgumentError }
+        end
+
+        it { should have_key(:zip_code) }
+
+        describe 'the errors on zip_code' do
+          subject { contact.validate[:zip_code] }
+
+          it { should have(1).error }
+          its(:first) { should be_an ArgumentError }
+        end
+      end
+    end
+  end
+
+
+  context 'when fully initialized' do
+    let(:attributes) do
+      {:prefix => " #{prefix} ",
+       :first_name => " #{first_name} ",
+       :middle_name => " #{middle_name} ",
+       :last_name => " #{last_name} ",
+       :suffix => " #{suffix} ",
+       :address1 => " #{address1} ",
+       :address2 => " #{address2} ",
+       :city => " #{city} ",
+       :state => " #{state} ",
+       :zip_code => " #{zip_code} ",
+       :country => " #{country} ",
+       :phone => " #{phone} ",
+       :phone_extension => " #{phone_extension} ",
+       :email => " #{email} ",
+       :relationship_to_prospect_id => " #{relationship_to_prospect_id} ",
+       :include_in_mailings => include_in_mailings,
+       :include_in_emailings => include_in_emailings,
+       :source_id => source_id}
+    end
+
+    its(:prefix) { should == prefix }
+
+    context 'when prefix is too long' do
+      let(:prefix) { 'a' * 31 }
+      it_should_behave_like 'a contact attribute validator', :prefix
+    end
+
+    its(:first_name) { should == first_name }
+
+    context 'without a first name' do
+      before { attributes[:first_name] = nil }
+
+      it 'should raise an ArgumentError' do
+        expect { subject }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when first name is too long' do
+      let(:first_name) { 'a' * 35 }
+      it_should_behave_like 'a contact attribute validator', :first_name
+    end
+
+    its(:middle_name) { should == middle_name }
+
+    context 'when middle name is too long' do
+      let(:middle_name) { 'a' * 31 }
+      it_should_behave_like 'a contact attribute validator', :middle_name
+    end
+
+    its(:last_name) { should == last_name }
+
+    context 'without a last name' do
+      before { attributes[:last_name] = nil }
+
+      it 'should raise an ArgumentError' do
+        expect { subject }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when last name is too long' do
+      let(:last_name) { 'a' * 31 }
+      it_should_behave_like 'a contact attribute validator', :last_name
+    end
+
+    its(:suffix) { should == suffix }
+
+    context 'when suffix is too long' do
+      let(:suffix) { 'a' * 31 }
+      it_should_behave_like 'a contact attribute validator', :suffix
+    end
+
+    its(:address1) { should == address1 }
+
+    context 'when address1 is too long' do
+      let(:address1) { 'a' * 101 }
+      it_should_behave_like 'a contact attribute validator', :address1
+    end
+
+    its(:address2) { should == address2 }
+
+    context 'when address2 is too long' do
+      let(:address2) { 'a' * 101 }
+      it_should_behave_like 'a contact attribute validator', :address2
+    end
+
+    its(:city) { should == city }
+
+    context 'when city is too long' do
+      let(:city) { 'a' * 51 }
+      it_should_behave_like 'a contact attribute validator', :city
+    end
+
+    its(:state) { should == state }
+
+    context 'when state is too long' do
+      let(:state) { 'Ore' }
+      it_should_behave_like 'a contact attribute validator', :state
+    end
+
+    its(:zip_code) { should == zip_code }
+
+    context 'when zip_code is too long' do
+      let(:zip_code) { '9' * 11 }
+      it_should_behave_like 'a contact attribute validator', :zip_code
+    end
+
+    its(:country) { should == country }
+    its(:phone) { should == phone }
+
+    context 'when phone is too long' do
+      let(:phone) { '5' * 21 }
+      it_should_behave_like 'a contact attribute validator', :phone
+    end
+
+    its(:phone_extension) { should == phone_extension }
+
+    context 'when phone_extension is too long' do
+      let(:phone_extension) { '5' * 6 }
+      it_should_behave_like 'a contact attribute validator', :phone_extension
+    end
+
+    its(:email) { should == email }
+
+    context 'when email is too long' do
+      let(:email) { "#{'a' * 50}@#{'b' * 50}" }
+      it_should_behave_like 'a contact attribute validator', :email
+    end
+
+    its(:relationship_to_prospect_id) { should == relationship_to_prospect_id }
+
+    its(:include_in_mailings) { should == include_in_mailings }
+
+    context 'when include_in_mailings is not true or false' do
+      let(:include_in_mailings) { 'foo' }
+
+      its(:include_in_mailings) { should be_true }
+      it { should be_valid }
+    end
+
+    context 'when include_in_mailings is nil' do
+      let(:include_in_mailings) { nil }
+
+      its(:include_in_mailings) { should be_false }
+      it { should be_valid }
+    end
+
+    its(:include_in_emailings) { should == include_in_emailings }
+
+    context 'when include_in_emailings is not true or false' do
+      let(:include_in_emailings) { 'foo' }
+
+      its(:include_in_emailings) { should be_true }
+      it { should be_valid }
+    end
+
+    context 'when include_in_emailings is nil' do
+      let(:include_in_emailings) { nil }
+
+      its(:include_in_emailings) { should be_false }
+      it { should be_valid }
+    end
+
+    its(:source_id) { should == source_id }
+     
+    context 'when source id is a string representing an integer' do
+      let(:source_id) { '99' }
+
+      its(:source_id) { should == 99 }
+      it { should be_valid }
+    end
+
+    context 'when source id is not an integer' do
+      let(:source_id) { 'foo' }
+
+      its(:source_id) { should == source_id }
+      it_should_behave_like 'a contact attribute validator', :source_id
+    end
+
+    context 'when source id is nil' do
+      let(:source_id) { nil }
+
+      it 'should raise an error upon initialization' do
+        expect { subject }.to raise_error ArgumentError
+      end
+    end
+
+    it { should be_valid }
+    it { should have_contact_method }
+
+    describe "#validate!" do
+      subject { contact.validate! }
+
+      it 'should not raise any errors' do
+        expect { subject }.to_not raise_error
+      end
+    end
+
+    describe "#to_soap_hash" do
+      subject { contact.to_soap_hash }
+
+      its(['Prefix']) { should == prefix }
+      its(['FirstName']) { should == first_name }
+      its(['MiddleName']) { should == middle_name }
+      its(['LastName']) { should == last_name }
+      its(['Suffix']) { should == suffix }
+      its(['Address1']) { should == address1 }
+      its(['Address2']) { should == address2 }
+      its(['City']) { should == city }
+      its(['State']) { should == state }
+      its(['ZipCode']) { should == zip_code }
+      its(['Country']) { should == country }
+      its(['Phone']) { should == phone }
+      its(['PhoneExtension']) { should == phone_extension }
+      its(['Email']) { should == email }
+      its(['RelationshipToProspectId']) { should == relationship_to_prospect_id }
+      its(['IncludeInMailings']) { should == include_in_mailings }
+      its(['IncludeInEmailings']) { should == include_in_emailings }
+      its(['SourceIDY']) { should == source_id }
+      its([:order!]) { should == ['Prefix','FirstName','MiddleName','LastName','Suffix','Address1','Address2','City','State','ZipCode','Country','Phone','PhoneExtension','Email','RelationshipToProspectId','IncludeInMailings','IncludeInEmailings','SourceIDY'] }
+    end
+  end
+end
+
+describe RepsClient::Prospect do
+  subject { prospect }
+
+  let(:prefix) { 'Mr.' }
+  let(:first_name) { 'Fred' }
+  let(:middle_name) { 'McFeely' }
+  let(:last_name) { 'Rogers' }
+  let(:suffix) { 'Jr.' }
+  let(:nickname) { 'Neighbor' }
+  let(:address1) { '123 Anywhere Ln' }
+  let(:address2) { 'Unit 42' }
+  let(:city) { 'Land of Make Believe' }
+  let(:state) { 'CA' }
+  let(:zip_code) { '90210' }
+  let(:country) { 'USA' }
+  let(:phone) { '(123) 456-7890' }
+  let(:phone_extension) { '123' }
+  let(:email) { 'fred@theneighborhood.org' }
+  let(:notes) { 'Dad is suffering from advanced dementia characterized by a preoccupation with trolleys.' }
+  let(:include_in_mailings) { true }
+  let(:include_in_emailings) { true }
+
+  context 'when initialized with defaults' do
+    let(:prospect) { RepsClient::Prospect.new }
+
+    its(:prefix) { should be_nil }
+    its(:first_name) { should be_nil }
+    its(:middle_name) { should be_nil }
+    its(:last_name) { should be_nil }
+    its(:suffix) { should be_nil }
+    its(:nickname) { should be_nil }
+    its(:address1) { should be_nil }
+    its(:address2) { should be_nil }
+    its(:city) { should be_nil }
+    its(:state) { should be_nil }
+    its(:zip_code) { should be_nil }
+    its(:country) { should be_nil }
+    its(:phone) { should be_nil }
+    its(:phone_extension) { should be_nil }
+    its(:email) { should be_nil }
+    its(:notes) { should be_nil }
+    its(:include_in_mailings) { should == false }
+    its(:include_in_emailings) { should  == false }
+
+    it { should be_valid }
+
+    describe "#to_soap_hash" do
+      subject { prospect.to_soap_hash }
+
+      it { should_not have_key('Prefix') }
+      it { should_not have_key('FirstName') }
+      it { should_not have_key('MiddleName') }
+      it { should_not have_key('LastName') }
+      it { should_not have_key('Suffix') }
+      it { should_not have_key('Nickname') }
+      it { should_not have_key('Address1') }
+      it { should_not have_key('Address2') }
+      it { should_not have_key('City') }
+      it { should_not have_key('State') }
+      it { should_not have_key('ZipCode') }
+      it { should_not have_key('Country') }
+      it { should_not have_key('Phone') }
+      it { should_not have_key('PhoneExtension') }
+      it { should_not have_key('Email') }
+      it { should_not have_key('Notes') }
+      its(['IncludeInMailings']) { should == false }
+      its(['IncludeInEmailings']) { should == false }
+      its([:order!]) { should == ['IncludeInMailings','IncludeInEmailings'] }
+    end
+  end
+
+  context 'when fully initialized' do
+    let(:prospect) { RepsClient::Prospect.new(attributes) }
+    let(:attributes) do
+      {:prefix => "   #{prefix}  ",
+       :first_name => " #{first_name}",
+       :middle_name => "#{middle_name} ",
+       :last_name => "\t#{last_name}",
+       :suffix => " #{suffix}  ",
+       :nickname => "#{nickname}    ",
+       :address1 => "#{address1}\n",
+       :address2 => "#{address2}\t\n",
+       :city => "  #{city} ",
+       :state => " #{state} ",
+       :zip_code => " #{zip_code}    ",
+       :country => "#{country} ",
+       :phone => "#{phone} ",
+       :phone_extension => " #{phone_extension} ",
+       :email => "#{email} ",
+       :notes => "#{notes}\n",
+       :include_in_mailings => include_in_mailings,
+       :include_in_emailings => include_in_emailings}
+    end
+
+    its(:prefix) { should == prefix }
+
+    context 'when prefix is too long' do
+      let(:prefix) { 'a' * 31 }
+      it_should_behave_like 'a prospect attribute validator', :prefix
+    end
+
+    its(:first_name) { should == first_name }
+
+    context 'when first name is too long' do
+      let(:first_name) { 'a' * 31 }
+      it_should_behave_like 'a prospect attribute validator', :first_name
+    end
+
+    its(:middle_name) { should == middle_name }
+
+    context 'when middle name is too long' do
+      let(:middle_name) { 'a' * 31 }
+      it_should_behave_like 'a prospect attribute validator', :middle_name
+    end
+
+    its(:last_name) { should == last_name }
+
+    context 'when last name is too long' do
+      let(:last_name) { 'a' * 31 }
+      it_should_behave_like 'a prospect attribute validator', :last_name
+    end
+
+    its(:suffix) { should == suffix }
+
+    context 'when suffix is too long' do
+      let(:suffix) { 'a' * 31 }
+      it_should_behave_like 'a prospect attribute validator', :suffix
+    end
+
+    its(:nickname) { should == nickname }
+    
+    context 'when nickname is too long' do
+      let(:nickname) { 'a' * 31 }
+      it_should_behave_like 'a prospect attribute validator', :nickname
+    end
+
+    its(:address1) { should == address1 }
+
+    context 'when address1 is too long' do
+      let(:address1) { 'a' * 101 }
+      it_should_behave_like 'a prospect attribute validator', :address1
+    end
+
+    its(:address2) { should == address2 }
+
+    context 'when address2 is too long' do
+      let(:address2) { 'a' * 101 }
+      it_should_behave_like 'a prospect attribute validator', :address2
+    end
+
+    its(:city) { should == city }
+
+    context 'when city is too long' do
+      let(:city) { 'a' * 51 }
+      it_should_behave_like 'a prospect attribute validator', :city
+    end
+
+    its(:state) { should == state }
+
+    context 'when state is too long' do
+      let(:state) { 'Washington' }
+      it_should_behave_like 'a prospect attribute validator', :state
+    end
+
+    its(:zip_code) { should == zip_code }
+
+    context 'when zip_code is too long' do
+      let(:zip_code) { '1' * 11 }
+      it_should_behave_like 'a prospect attribute validator', :zip_code
+    end
+
+    its(:phone) { should == phone }
+
+    context 'when phone is too long' do
+      let(:phone) { '5' * 21 }
+      it_should_behave_like 'a prospect attribute validator', :phone
+    end
+
+    its(:phone_extension) { should == phone_extension }
+
+    context 'when phone extension is too long' do
+      let(:phone_extension) { 'a' * 6 }
+      it_should_behave_like 'a prospect attribute validator', :phone_extension
+    end
+
+    its(:email) { should == email }
+
+    context 'when email is too long' do
+      let(:email) { 'a' * 101 }
+      it_should_behave_like 'a prospect attribute validator', :email
+    end
+
+    its(:notes) { should == notes }
+
+    its(:include_in_mailings) { should == include_in_mailings }
+
+    context 'when include_in_mailings is a non-boolean' do
+      let(:include_in_mailings) { 'foo' }
+      its(:include_in_mailings) { should be_true }
+      it { should be_valid }
+    end
+
+    context 'when include_in_mailings is nil' do
+      let(:include_in_mailings) { nil }
+      its(:include_in_mailings) { should be_false }
+      it { should be_valid }
+    end
+
+    its(:include_in_emailings) { should == include_in_emailings }
+
+    context 'when include_in_emailings is a non-boolean' do
+      let(:include_in_emailings) { 'false' }
+      its(:include_in_emailings) { should be_true }
+      it { should be_valid }
+    end
+
+    context 'when include_in_emailings is nil' do
+      let(:include_in_emailings) { nil }
+      its(:include_in_emailings) { should be_false }
+      it { should be_valid }
+    end
+
+    it { should be_valid }
+
+    describe "#to_soap_hash" do
+      subject { prospect.to_soap_hash }
+
+      its(['Prefix']) { should == prefix }
+      its(['FirstName']) { should == first_name }
+      its(['MiddleName']) { should == middle_name }
+      its(['LastName']) { should == last_name }
+      its(['Suffix']) { should == suffix }
+      its(['Nickname']) { should == nickname }
+      its(['Address1']) { should == address1 }
+      its(['Address2']) { should == address2 }
+      its(['City']) { should == city }
+      its(['State']) { should == state }
+      its(['ZipCode']) { should == zip_code }
+      its(['Country']) { should == country }
+      its(['Phone']) { should == phone }
+      its(['PhoneExtension']) { should == phone_extension }
+      its(['Email']) { should == email }
+      its(['Notes']) { should == notes }
+      its(['IncludeInMailings']) { should == include_in_mailings }
+      its(['IncludeInEmailings']) { should == include_in_emailings }
+      its([:order!]) { should == ['Prefix','FirstName','MiddleName','LastName','Suffix','Nickname','Address1','Address2','City','State','ZipCode','Country','Phone','PhoneExtension','Email','Notes','IncludeInMailings','IncludeInEmailings'] }
+    end
+  end
+end
+
+describe 'lead methods mixin' do
+  let(:test_object) { RepsClient::Client.new(:enterprise_key => enterprise_key) }
+  let(:enterprise_key) { 'foo' }
+
+  describe "#save_lead" do
+    subject { save_lead }
+
+    let(:save_lead) { test_object.save_lead(community_id, contact, prospect) }
+
+    let(:community_id) { 42 }
+
+    let(:contact) { RepsClient::Contact.new(contact_attributes) }
+    let(:contact_attributes) do
+      {:first_name => contact_first_name,
+       :last_name => contact_last_name,
+       :source_id => contact_source_id,
+       :phone => contact_phone}
+    end
+    let(:contact_first_name) { 'Sam' }
+    let(:contact_last_name) { 'Stark' }
+    let(:contact_source_id) { 42 }
+    let(:contact_phone) { '555-555-5555' }
+
+    let(:prospect) { nil }
+
+    before { savon.stubs('SaveLead').returns(nil) }
+
+    context 'without a community id' do
+      let(:community_id) { nil }
+
+      it 'should raise an ArgumentError without calling the remote service' do
+        savon.expects('SaveLead').never
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with a non-integer community id' do
+      let(:community_id) { 'foo' }
+
+      it 'should raise an ArgumentError without calling the remote service' do
+        savon.expects('SaveLead').never
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'without a contact' do
+      let(:contact) { nil }
+
+      it 'should raise an ArgumentError without calling the remote service' do
+        savon.expects('SaveLead').never
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when contact is invalid' do
+      let(:contact_attributes) { Hash.new }
+
+      it 'should raise an ArgumentError without calling the remote service' do
+        savon.expects('SaveLead').never
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when contact is valid' do
+      context 'without a prospect' do
+        let(:save_lead) { test_object.save_lead(community_id, contact) }
+
+        it 'should not raise an ArgumentError' do
+          expect { subject }.to_not raise_error
+        end
+
+        it 'should call the remote service with the correct enterprise key' do
+          savon.expects('SaveLead').with(has_entry(:enterprise_key => enterprise_key)).returns(nil)
+          subject
+        end
+
+        it 'should call the remote service with the correct community id' do
+          savon.expects('SaveLead').with(has_entry(:community_id => community_id)).returns(nil)
+          subject
+        end
+
+        it 'should call the remote service with the correct contact parameters' do
+          savon.expects('SaveLead').with(has_entry(:new_contact => contact.to_soap_hash)).returns(nil)
+          subject
+        end
+
+        it 'should call the remote service with the correct parameter order' do
+          savon.expects('SaveLead').with(has_entry(:order! => [:enterprise_key,:community_id,:new_contact])).returns(nil)
+          subject
+        end
+
+        it_should_behave_like 'a fault handler', 'SaveLead'
+
+        # TODO: assert result
+      end
+
+      context 'with a prospect' do
+        let(:prospect) { RepsClient::Prospect.new(prospect_attributes) }
+
+        context 'when prospect is invalid' do
+          let(:prospect_attributes) { {:first_name => 'a' * 200} }
+
+          it 'should raise an ArgumentError without calling the remote service' do
+            savon.expects('SaveLead').never
+            expect { subject }.to raise_error(ArgumentError)
+          end
+        end
+
+        context 'when prospect is valid' do
+          let(:prospect_attributes) do
+            {:first_name => 'Tara',
+             :last_name => 'Thompson',
+             :notes => 'requests a brochure'}
+          end
+
+          before { contact.relationship_to_prospect_id = 99 }
+
+          it 'should not raise an ArgumentError' do
+            expect { subject }.to_not raise_error
+          end
+
+          it 'should call the remote service with the correct enterprise key' do
+            savon.expects('SaveLead').with(has_entry(:enterprise_key => enterprise_key)).returns(nil)
+            subject
+          end
+
+          it 'should call the remote service with the correct community id' do
+            savon.expects('SaveLead').with(has_entry(:community_id => community_id)).returns(nil)
+            subject
+          end
+
+          it 'should call the remote service with the correct contact parameters' do
+            savon.expects('SaveLead').with(has_entry(:new_contact => contact.to_soap_hash)).returns(nil)
+            subject
+          end
+
+          it 'should call the remote service with the correct prospect parameters' do
+            savon.expects('SaveLead').with(has_entry(:new_prospect => prospect.to_soap_hash)).returns(nil)
+            subject
+          end
+
+          it 'should call the remote service with the correct parameter order' do
+            savon.expects('SaveLead').with(has_entry(:order! => [:enterprise_key,:community_id,:new_contact,:new_prospect])).returns(nil)
+            subject
+          end
+
+          it_should_behave_like 'a fault handler', 'SaveLead'
+
+          # TODO: assert result
+        end
+      end
+    end
+  end
+end