balanced 0.8.2 → 1.0.beta1

data/spec/balanced/resources/callback_spec.rb

@@ -1,36 +1,35 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Balanced::Callback, :vcr do
   before do
     api_key = Balanced::ApiKey.new.save
     Balanced.configure api_key.secret
-
     @marketplace = Balanced::Marketplace.new.save
   end
 
-  describe "create", :vcr do
+  describe 'create', :vcr do
     before do
-      @callback = @marketplace.create_callback(
-          :url => "http://www.example.com/balanced_callback"
-      )
+      @callback = Balanced::Callback.new(
+          :url => 'http://www.example.com/balanced_callback'
+      ).save
     end
 
     context 'check url' do
-      subject { @callback.url}
-      it { should eql "http://www.example.com/balanced_callback" }
+      subject { @callback.url }
+      it { should eql 'http://www.example.com/balanced_callback' }
     end
 
   end
 
-  describe "delete", :vcr do
+  describe 'delete', :vcr do
     before do
-      @callback = @marketplace.create_callback(
-          :url => "http://www.example.com/balanced_callback"
-      )
+      @callback = Balanced::Callback.new(
+          :url => 'http://www.example.com/balanced_callback'
+      ).save
     end
 
     context 'delete' do
-      it "should delete without an error" do
+      it 'should delete without an error' do
         @callback.destroy
       end
     end

data/spec/balanced/resources/card_hold_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Balanced::CardHold, :vcr => true, :skip => true do
+
+  before(:all) do
+    api_key = Balanced::ApiKey.new.save
+    Balanced.configure api_key.secret
+    @marketplace = Balanced::Marketplace.new.save
+    @card = Balanced::Card.new(
+        :number => '5105105105105100',
+        :expiration_month => '12',
+        :expiration_year => '2015'
+    ).save
+  end
+
+  describe '#create', :vcr do
+
+    subject do
+      @card_hold = Balanced::CardHold.new(
+          :href => @card.holds.href,
+          :amount => 100,
+          :currency => 'USD',
+          :appears_on_statement_as => 'My Market.Place-13',
+          :description => 'I be holding',
+          :meta => {
+              :campaign_id => SecureRandom.hex
+          }
+      ).save
+    end
+
+    it { should_not be_nil }
+    its(:href) { should_not be nil }
+    its(:description) { should eq('I be holding') }
+    its(:appears_on_statement_as) { should eq('BAL*My Market.Place-13') }
+    its(:amount) { should == 100 }
+    its(:meta) {
+      should_not be_nil
+      should be_instance_of Hash
+    }
+    its(:currency) { should == 'USD' }
+    its(:expires_at) { should_not be_nil }
+
+    its(:debits) { should be_instance_of Balanced::Pager }
+    its(:debit) { should be_nil }
+
+    context '#card' do
+      its('card.href') { should eql(@card.href) }
+    end
+
+  end
+
+  describe '#capture', :vcr do
+    before do
+      @card_hold = Balanced::CardHold.new(
+          :href => @card.holds.href,
+          :amount => 100,
+          :currency => 'USD',
+          :appears_on_statement_as => 'My Market.Place-13',
+          :description => 'I be holding',
+          :meta => {
+              :campaign_id => SecureRandom.hex
+          }
+      ).save
+    end
+
+    context 'with no arguments - should just create a debit' do
+      subject { @card_hold.capture }
+      it { should be_instance_of Balanced::Debit }
+      its(:amount) { should eql @card_hold.amount }
+      its(:appears_on_statement_as) { should eql @card_hold.appears_on_statement_as }
+    end
+
+    it "should update the card hold's debit" do
+      @card_hold.debit.should be_nil
+      debit = @card_hold.capture
+      @card_hold.debit.should_not be_nil
+      @card_hold.debit.href.should eql(debit.href)
+    end
+
+    it 'should fail when captured twice' do
+      @card_hold.debit.should be_nil
+      @card_hold.capture
+      lambda { @card_hold.capture }.should raise_error(Balanced::Conflict)
+    end
+  end
+
+  describe '#destroy', :vcr do
+    before(:all) do
+      @hold = @card.hold(:amount => 100)
+      @hold_href = @hold.href
+    end
+
+    it 'should implicitly void the hold since it no longer exists' do
+      @hold.destroy
+    end
+
+    it 'should return a 404 when trying to access it again' do
+      lambda { Balanced::CardHold.find(@hold_href) }.should raise_error(Balanced::NotFound)
+    end
+
+  end
+
+end

data/spec/balanced/resources/card_spec.rb

@@ -1,36 +1,110 @@
 require 'spec_helper'
 
-describe Balanced::Card, '#debit', :vcr => true, :marketplace => true do
-  it 'raises an exception with an unassociated card' do
-    card = Balanced::Card.new
-    expect {
-      card.debit
-    }.to raise_error(Balanced::UnassociatedCardError)
-  end
-end
+describe Balanced::Card, :vcr do
 
-describe Balanced::Card, '#hold', :vcr => true, :marketplace => true do
-  it 'raises an exception with an unassociated card' do
-    card = Balanced::Card.new
-    expect {
-      card.hold
-    }.to raise_error(Balanced::UnassociatedCardError)
+  before do
+    api_key = Balanced::ApiKey.new.save
+    Balanced.configure api_key.secret
+    @marketplace = Balanced::Marketplace.new.save
+    @card = Balanced::Card.new(
+        :number => '5105105105105100',
+        :expiration_month => '12',
+        :expiration_year => '2020',
+        :cvv => '123'
+    ).save
   end
-end
 
-describe Balanced::Card, '#debit', :vcr => true, :marketplace => true do
-  it 'debits the card if an account is set' do
-    # tokenize card
-    card = Balanced::Card.new(
-      :card_number =>      '4111111111111111',
-      :expiration_year =>  '2016',
-      :expiration_month => '12')
-    card.save
+  describe 'card', :vcr do
+    it 'should be a Balanced::Card' do
+      @card.should be_instance_of Balanced::Card
+    end
+
+    describe 'attributes', :vcr do
+      subject { @card }
+      its(:href) { should match "/cards/#{@card.id}" }
+      its(:number) { should end_with '5100' }
+      its(:expiration_month) { should eql 12 }
+      its(:expiration_year) { should eql 2020 }
+      its(:cvv) { should eql 'xxx' }
+      its(:cvv_match) { should eql 'yes' }
+      its(:cvv_result) { should eql 'Match' }
+    end
+
+    describe 'creating a one-time debit', :vcr => {:record => :new_episodes} do
+      subject do
+        @card.debit(
+            :amount => 100,
+            :appears_on_statement_as => 'A lolipop',
+            :description => 'My first debit!'
+        )
+      end
+      it { should_not be_nil }
+      it { should be_instance_of Balanced::Debit }
+
+      its(:href) { should_not be_nil }
+      its(:amount) { should eql 100 }
+      its(:appears_on_statement_as) { should eql 'BAL*A lolipop' }
+      its(:description) { should eql 'My first debit!' }
+      its(:status) { should eql 'succeeded' }
+    end
+
+    describe 'creating a one-time hold', :vcr => true, :skip => true do
+      subject do
+        @card.hold(
+            :amount => 100,
+            :appears_on_statement_as => 'HOLD.UP',
+            :description => 'HeldForEver'
+        )
+      end
+      it { should_not be_nil }
+      it { should be_instance_of Balanced::CardHold }
+
+      its(:href) { should_not be_nil }
+      its(:amount) { should eql 100 }
+      its(:description) { should eql 'HeldForEver' }
+      its(:appears_on_statement_as) { should eql 'BAL*HOLD.UP' }
+    end
 
-    # associate card to account
-    Balanced::Account.new(:email_address => 'user@example.com', :name => 'John Doe', :card_uri => card.uri).save
+    describe '#debits', :vcr do
+      subject do
+        @card.debits
+      end
+      its(:href) { should eq("/cards/#{@card.id}/debits") }
+      it 'should be a page' do
+        should be_instance_of Balanced::Pager
+      end
+    end
+
+    describe '#holds', :vcr => true, :skip => true do
+      subject do
+        @card.holds
+      end
+
+      its(:href) { should eq("/cards/#{@card.id}/card_holds") }
+
+      it 'should be a page' do
+        should be_instance_of Balanced::Pager
+      end
+    end
+
+    describe '#customer', :vcr do
+
+      it 'should default to nil' do
+        @card.customer.should be_nil
+      end
+
+      context 'after associating to a customer' do
+        before do
+          @customer = Balanced::Customer.new.save
+          @card.associate_to_customer(@customer)
+          @card.reload
+        end
+        subject { @card }
+        its(:customer) { should_not be_nil }
+      end
+
+    end
 
-    card = Balanced::Card.find(card.uri)
-    card.debit(:amount => 10000).should be_instance_of Balanced::Debit
   end
+
 end

data/spec/balanced/resources/credit_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Balanced::Credit, :vcr do
   before do
@@ -6,30 +6,26 @@ describe Balanced::Credit, :vcr do
     Balanced.configure api_key.secret
     @marketplace = Balanced::Marketplace.new.save
     card = Balanced::Card.new(
-      :card_number      => "5105105105105100",
-      :expiration_month => "12",
-      :expiration_year  => "2015"
+        :number => '5105105105105100',
+        :expiration_month => '12',
+        :expiration_year => '2015'
     ).save
 
     # An initial balance for the marketplace
-    @buyer = @marketplace.create_buyer(
-        :email_address => 'buyer@example.org',
-        :card_uri => card.uri
-    )
-    @buyer.debit :amount => 10000000
+    card.debit(:amount => 1000000)
   end
 
-  describe "#create", :vcr do
+  describe '#create', :vcr do
     before do
       @credit = Balanced::Credit.new(
-        :amount => 5000,
-        :description => "A sweet ride",
-        :bank_account => {
-          :account_number => "0987654321",
-          :bank_code => "321174851",
-          :name => "Timmy T. McTimmerson",
-          :type => "savings"
-        }
+          :amount => 5000,
+          :description => 'A sweet ride',
+          :destination => {
+              :routing_number => '321174851',
+              :account_number => '0987654321',
+              :name => 'Timmy T. McTimmerson',
+              :type => 'checking'
+          }
       ).save
     end
 
@@ -38,37 +34,75 @@ describe Balanced::Credit, :vcr do
       it { should == 5000 }
     end
 
-    describe 'account', :vcr do
-      subject { @credit.account }
+    describe 'customer', :vcr do
+      subject { @credit.customer }
       it { should be_nil }
     end
 
-    describe 'bank_account', :vcr do
-      subject { @credit.bank_account }
-      its([:account_number]) { should end_with '4321' }
-    end
   end
 
-  describe "#reverse", :vcr do
+  describe '#reverse', :vcr do
     before do
       @credit = Balanced::Credit.new(
-        :amount => 5000,
-        :description => "A sweet ride",
-        :bank_account => {
-          :account_number => "0987654321",
-          :bank_code => "321174851",
-          :name => "Timmy T. McTimmerson",
-          :type => "savings"
-        }
+          :amount => 5000,
+          :description => 'A sweet ride',
+          :destination => {
+              :routing_number => '321174851',
+              :account_number => '0987654321',
+              :name => 'Timmy T. McTimmerson',
+              :type => 'checking'
+          }
       ).save
-      @reverse = @credit.reverse
+      @reversal = @credit.reverse
+    end
+
+    describe '#amount', :vcr do
+      subject { @reversal.amount }
+      it { should == 5000 }
+    end
 
+    describe '#type', :vcr do
+      subject { @reversal }
+      it { should be_instance_of Balanced::Reversal }
+    end
+  end
+
+  describe 'credit with underwritten customer' do
+    before do
+      @customer = Balanced::Customer.new(
+          :name => 'Henry Ford',
+          :dob_month => 7,
+          :dob_year => 1963,
+          :address => {
+              :postal_code => '48120'
+          }
+      ).save
+      @bank_account = Balanced::BankAccount.new(
+          :routing_number => '321174851',
+          :account_number => '9900000003',
+          :name => 'Larry Bird',
+          :type => 'checking'
+      ).save
+      @bank_account.associate_to_customer(@customer)
+      @credit = @bank_account.credit(
+          :amount => 5000,
+          :description => 'A sweet ride'
+      )
+    end
+
+    describe 'merchant_status', :vcr do
+      subject { @customer.merchant_status }
+      it { should eq 'underwritten' }
     end
 
     describe 'amount', :vcr do
-      subject { @reverse.amount }
+      subject { @credit.amount }
       it { should == 5000 }
     end
 
+    describe 'status' do
+      subject { @credit.status }
+      it { should eq 'succeeded' }
+    end
   end
 end

data/spec/balanced/resources/customer_spec.rb

@@ -1,313 +1,133 @@
 require 'spec_helper'
 
 describe Balanced::Customer, :vcr do
+
   before do
-    api_key = Balanced::ApiKey.new.save
-    Balanced.configure api_key.secret
+    @api_key = Balanced::ApiKey.new.save
+    Balanced.configure @api_key.secret
     @marketplace = Balanced::Marketplace.new.save
+    @customer = Balanced::Customer.new(
+        :name => 'Bill',
+        :email => 'bill@bill.com',
+        :business_name => 'Bill Inc.',
+        :ssn_last4 => '1234',
+        :address => {
+            :line1 => '1234 1st Street',
+            :city => 'San Francisco',
+            :state => 'CA'
+        }
+    ).save
   end
 
-  describe "Customer.uri", :vcr do
-
-    context "when Api Key is configured properly", :vcr do
-      before do
-        api_key = Balanced::ApiKey.new.save
-        Balanced.configure api_key.secret
-        Balanced::Customer.new
-      end
-
-      it "matches the resource's uri structure" do
-        uri = Balanced::Customer.uri
-        uri.should_not be_nil
-        uri.should match CUSTOMERS_URI_REGEX
-      end
-    end
+  describe 'attributes', :vcr do
+    subject { @customer }
+    its(:href) { should match "/customers/#{@customer.id}" }
+    its(:name) { should eq 'Bill' }
+    its(:email) { should eq 'bill@bill.com' }
+    its(:business_name) { should eq 'Bill Inc.' }
   end
 
-  describe "customer", :vcr do
-    describe "#create", :vcr do
-      before do
-        @customer = @marketplace.create_customer(
-          :name           => "Bill",
-          :email          => "bill@bill.com",
-          :business_name  => "Bill Inc.",
-          :ssn_last4      => "1234",
-          :address => {
-            :line1 => "1234 1st Street",
-            :city  => "San Francisco",
-            :state => "CA"
-        }
-        ).save
-      end
-      it "should create a new customer" do
-        @customer.should_not be_nil
-      end
-      it "should contain the correct attributes" do
-        @customer.name.should eq("Bill")
-        @customer.email.should eq("bill@bill.com")
-        @customer.business_name.should eq("Bill Inc.")
-      end
-    end
-
-    describe "#add_card using untokenized object", :vcr do
-      before do
-      @customer = @marketplace.create_customer
+  describe '#add_source', :vcr do
+    before do
       @card = Balanced::Card.new(
-        :card_number       => "4111111111111111",
-        :expiration_month  => "12",
-        :expiration_year   => "2015"
-        )
-        @customer.add_card(@card)
-      end
-      it "should add a card to a customer" do
-        @customer.cards.size.should eq(1)
-      end
+          :number => '4111111111111111',
+          :expiration_month => '12',
+          :expiration_year => '2015'
+      ).save
+      @card.associate_to_customer(@customer)
     end
 
-    describe "#add_card using tokenized object", :vcr do
-      before do
-        @customer = @marketplace.create_customer
-        @card = @marketplace.create_card(
-          :card_number       => "4111111111111111",
-          :expiration_month  => "12",
-          :expiration_year   => "2015"
-        ).save
-        @customer.add_card(@card)
-        @customer_card_id = @customer.cards.first.id
-        @card_id = @card.id
-      end
-      it "should add a card to a customer" do
-        @customer.cards.size.should eq(1)
-      end
-      it "card added should be the same card" do
-        @customer_card_id.should eq(@card_id)
-      end
+    it 'assumes the card is associated', :vcr do
+      @customer.cards.total.should eql(1)
     end
 
-    describe "#add_card using uri", :vcr do
-      before do
-        @customer = @marketplace.create_customer
-        @card = @marketplace.create_card(
-          :card_number       => "4111111111111111",
-          :expiration_month  => "12",
-          :expiration_year   => "2015"
-        ).save
-        @customer.add_card(@card.uri)
-        @customer_card_id = @customer.cards.first.id
-        @card_id = @card.id
-      end
-      it "should add a card to a customer" do
-        @customer.cards.size.should eq(1)
-      end
-      it "card added should be the same card" do
-        @customer_card_id.should eq(@card_id)
-      end
+    it 'should make the card a source', :vcr do
+      @customer.add_source(@card)
+      @customer.source.should be_instance_of Balanced::Card
+      @customer.source.href.should eql(@card.href)
     end
 
-    describe "#delete card", :vcr do
-      before do
-        @card_2 = @marketplace.create_card(
-            :card_number       => "4111111111111111",
-            :expiration_month  => "12",
-            :expiration_year   => "2015"
-        ).save
-        @card_2.unstore
-      end
-      it "Should throw 404 on deleted card" do
-        expect{
-          Balanced::Card.find(@card_2.uri)
-        }.to raise_error
-      end
-    end
+  end
 
-    describe "#delete bank account", :vcr do
-      before do
-        @bank_account_2 = @marketplace.create_bank_account(
-            :account_number => "0987654321",
-            :bank_code => "321174851",
-            :name => "Timmy T. McTimmerson",
-            :type => "checking"
-        )
-        @bank_account_2.unstore
-      end
-      it "Should throw 404 on deleted card" do
-        expect {
-          Balanced::BankAccount.find(@bank_account_2.uri)
-        }.to raise_error
-      end
+  describe '#add_destination', :vcr do
+    before do
+      @bank_account = Balanced::BankAccount.new(
+          :account_number => '1234567980',
+          :routing_number => '111000025',
+          :name => 'Jack Q Merchant'
+      ).save
+      @bank_account.associate_to_customer(@customer)
     end
 
-    describe "#add_bank_account using tokenized object", :vcr do
-      before do
-        @customer = @marketplace.create_customer
-        @bank_account = @marketplace.create_bank_account(
-          :account_number => "1234567980",
-          :bank_code => "321174811",
-          :name => "Jack Q Merchant"
-        )
-        @customer.add_bank_account(@bank_account)
-        @customer_bank_account_id = @customer.bank_accounts.first.id
-        @bank_account_id = @bank_account.id
-      end
-      it "should add a bank account to a customer" do
-        @customer.bank_accounts.size.should eq(1)
-      end
-      it "bank account added should be the same bank account" do
-        @customer_bank_account_id = @bank_account_id
-      end
+    it 'assumes the bank account is associated', :vcr do
+      @customer.bank_accounts.total.should eql(1)
     end
 
-    describe "#add_bank_account using uri", :vcr do
-      before do
-        @customer = @marketplace.create_customer
-        @bank_account = @marketplace.create_bank_account(
-          :account_number => "1234567980",
-          :bank_code => "321174811",
-          :name => "Jack Q Merchant"
-        )
-        @customer.add_bank_account(@bank_account.uri)
-        @customer_bank_account_id = @customer.bank_accounts.first.id
-        @bank_account_id = @bank_account.id
-      end
-      it "should add a bank account to a customer" do
-        @customer.bank_accounts.size.should eq(1)
-      end
-      it "bank account added should be the same bank account" do
-        @customer_bank_account_id = @bank_account_id
-      end
+    it 'should make the bank account a destination', :vcr do
+      @customer.add_destination(@bank_account)
+      @customer.destination.should be_instance_of Balanced::BankAccount
+      @customer.destination.href.should eql(@bank_account.href)
     end
 
-    describe "#find_by_email", :vcr => { :record => :new_episodes } do
-      before do
-        api_key = Balanced::ApiKey.new.save
-        Balanced.configure api_key.secret
-        @marketplace = Balanced::Marketplace.new.save
-        customer = @marketplace.create_customer(
-          :name           => "Bill",
-          :email          => "bill@bill.com",
-          :business_name  => "Bill Inc.",
-          :ssn_last4      => "1234",
-          :address => {
-            :line1 => "1234 1st Street",
-            :city  => "San Francisco",
-            :state => "CA"
-          }
-        ).save
-      end
+  end
 
-      context "email address is in system", :vcr => { :record => :new_episodes } do
-        it "should return customer object" do
-          Balanced::Customer.find_by_email("bill@bill.com").should be_instance_of Balanced::Customer
-        end
-      end
+  describe '#find_by_email', :vcr do
 
-      context "email address does not exist", :vcr => { :record => :new_episodes } do
-        it "should return nil" do
-          Balanced::Customer.find_by_email("foo@bar.com").should be_nil
-        end
+    context 'email address is in system', :vcr do
+      it 'should return customer object' do
+        bill = Balanced::Customer.find_by_email('bill@bill.com')
+        bill.should be_instance_of Balanced::Customer
       end
     end
 
-    describe "#debit" do
-      before do
-        @customer = @marketplace.create_customer
-        @card = @marketplace.create_card(
-          :card_number       => "4111111111111111",
-          :expiration_month  => "12",
-          :expiration_year   => "2015"
-        ).save
-        @customer.add_card(@card)
-        @customer.debit :amount => 1000
-      end
-      context "customer debit should be added" do
-        subject {@customer.debits.first}
-        its(:amount) { should eq 1000}
+    context 'email address does not exist', :vcr do
+      it 'should return nil' do
+        Balanced::Customer.find_by_email('foo@bar.com').should be_nil
       end
     end
+  end
 
-    describe "compound credit and debit", :vcr do
-      before do
-        @customer = @marketplace.create_customer
-        @bank_account = @marketplace.create_bank_account(
-          :account_number => "1234567980",
-          :bank_code => "321174811",
-          :name => "Jack Q Merchant"
-        )
-        @card = Balanced::Card.new(
-          :card_number       => "4111111111111111",
-          :expiration_month  => "12",
-          :expiration_year   => "2015"
-        ).save
-        @customer.add_card(@card)
-        @customer.add_bank_account(@bank_account)
-        @customer.debit :amount => 1250
-      end
-
-      context "args passed by name via options hash" do
-        subject {
-          @customer.credit(
-            :amount => 1250,
-            :description => "description",
-            :meta => {}
-          )
-        }
-
-        its(:amount) { should == 1250 }
-        its(:meta) { should == {} }
-        its(:description) { should == "description" }
-      end
+  describe 'update' do
+    before do
+      @customer = Balanced::Customer.new(
+          :name => 'Bill',
+          :email => 'bill@bill.com',
+          :business_name => 'Bill Inc.'
+      ).save
     end
 
-    describe "#active_card", :vcr do
-      before do
-        @customer = @marketplace.create_customer
-        @card = @marketplace.create_card(
-          :card_number       => "4111111111111111",
-          :expiration_month  => "12",
-          :expiration_year   => "2015"
-        ).save
-        @customer.add_card(@card)
-      end
-      it "should display the most recently added valid card" do
-        @customer.active_card.should_not be_nil
-      end
+    subject do
+      @customer
     end
 
-    describe "#active_bank_account", :vcr do
-      before do
-        @customer = @marketplace.create_customer
-        @bank_account = @marketplace.create_bank_account(
-          :account_number => "1234567980",
-          :bank_code => "321174811",
-          :name => "Jack Q Merchant"
-        )
-        @customer.add_bank_account(@bank_account)
-      end
-      it "should display the most recently added valid card" do
-        @customer.active_bank_account.should_not be_nil
-      end
-    end
+    its(:name) { should eq 'Bill' }
+    its(:merchant_status) { should eq 'no-match' }
 
-    describe "find_by_email", :vcr do
-      before do
-        @customer = @marketplace.create_customer(
-            :email => "balanced-ruby-issue-110@example.com"
-        )
-      end
+    it 'update name' do
+      @customer.name = 'William'
+      @customer.save
 
-      it "should return 401 unauthorized if not authenticated" do
-        @customer.uri.should_not be_nil
-        key = Balanced.client.api_key
-        Balanced.configure(nil)
-        expect {
-          Balanced::Customer.find(
-              :first,
-              :email => "balanced-ruby-issue-110@example.com")
-        }.to raise_error Balanced::Unauthorized
-        Balanced.configure(key)
-      end
+      # Fetch the customer again
+      @customer.reload
+      @customer.name.should eq 'William'
+    end
 
+    it 'can be underwritten' do
+      @customer.name = 'Henry Ford'
+      @customer.dob_month = 7
+      @customer.dob_year = 1963
+      @customer.business_name = nil
+      @customer.address['postal_code'] = 48120
+      @customer.save
+
+      @customer.name.should eq 'Henry Ford'
+      @customer.dob_month.should eql 7
+      @customer.dob_year.should eql 1963
+      @customer.business_name.should be_nil
+      @customer.address['postal_code'].should eql '48120'
+      @customer.merchant_status.should eq 'underwritten'
     end
+
   end
 
 end