cheddargetter_client_rails 0.1.8

data/lib/cheddargetter_client_rails/subscription.rb

@@ -0,0 +1,186 @@
+module CheddargetterClientRails
+  class Subscription
+    include ActiveModel::Validations
+
+    Months = ("01".."12").freeze
+    Years  = (Date.current.year..Date.current.year+10).collect{|y| y.to_s }.freeze
+  
+    attr_accessor :planCode,
+                  :company,
+                  :firstName,
+                  :lastName,
+                  :ccFirstName,
+                  :ccLastName,
+                  :ccExpiration,
+                  :ccNumber,
+                  :ccLastFour,
+                  :ccCountry,
+                  :ccAddress,
+                  :ccCity,
+                  :ccState,
+                  :customerCode,
+                  :email,
+                  :zip
+
+    validates_presence_of :firstName,
+                          :lastName,
+                          :email,
+                          :planCode
+                          #:customerCode, generally we call valid before unique identifier is called
+
+    validates_presence_of :ccNumber,
+                          :ccExpiration,
+                          :zip, :if => :paid_plan?
+
+    validate :unexpired
+  
+    validate :validates_presence_of_humanized
+  
+    def paid_plan?
+      !free_plan?
+    end
+  
+    def free_plan?
+      planCode == 'FREE_PLAN'
+    end
+  
+    def unexpired
+      if ccExpiration.present?
+        month, year = ccExpiration.split("/").collect{|string| string.to_i }
+        year  = ('20' + year.to_s).to_i if year.size < 4
+        month = ('0' + month.to_s).to_i if month.size < 2
+
+        if Date.civil(year, month + 1) <= Date.today
+          errors.add(:ccExpiration, 'has been reached')
+        end
+      end
+    end
+
+    def validates_presence_of_humanized
+      if planCode.blank?
+        self.errors.add(:base, 'You must select a billing plan')
+      end
+    end
+
+    def initialize(hash = {})
+      hash.each { |k, v| send("#{k}=", v) }
+    end
+  
+    def self.get(customer_code)
+      response = CGClient.get_customer(:code => customer_code)
+
+      if response.errors.blank?
+        build_from_response(response)
+      end
+    end
+
+    def self.build_from_response(response)
+      customer_subscription = response.try(:customer_subscription)
+      customer_plan         = response.try(:customer_plan)
+    
+      if customer_plan and customer_subscription
+        new(
+          :firstName    => response.customer[:firstName],
+          :lastName     => response.customer[:lastName],
+          :email        => response.customer[:email],
+          :ccLastFour   => customer_subscription[:ccLastFour], 
+          :ccFirstName    => customer_subscription[:ccFirstName],
+          :ccLastName     => customer_subscription[:ccLastName],
+          :planCode     => customer_plan[:code],
+          :zip          => customer_subscription[:ccZip],
+          :ccExpiration => customer_subscription[:ccExpirationDate],
+          :customerCode => response.customer[:code]        
+        )
+      end
+    end
+  
+    def new_record?
+      !Subscription.get(customerCode)
+    end
+  
+    def save
+      return false if !valid?
+      
+      if new_record?
+        create
+      else
+        update
+      end
+    end
+  
+    def create
+      response = CGClient.new_customer(
+        :code      => customerCode,
+        :firstName => firstName,
+        :lastName  => lastName,
+        :email     => email,
+        :subscription => {
+          :planCode     => planCode,
+          :ccFirstName  => ccFirstName,
+          :ccLastName   => ccLastName,
+          :ccNumber     => ccNumber,
+          :ccExpiration => ccExpiration,
+          :ccZip        => zip
+        }
+      )    
+
+      add_errors_or_return_valid_response(response)
+    end
+
+    def add_errors_or_return_valid_response(response)
+      #this returns cheddargetter errors.
+      #hopefully most errors are handled before this in the valid? calls
+      #which return prettier errors, but inevitably some will not be caught.
+      if response.try(:errors).try(:any?)
+        response.errors.each do |error|
+          errors.add(:base, error[:text])
+        end
+      
+        return false
+      else
+        response
+      end    
+    end
+
+    def update
+      response = CGClient.edit_customer(
+        {:code      => customerCode},
+        {
+          :firstName => firstName,
+          :lastName  => lastName,
+          :email     => email,
+          :subscription => {
+            :planCode     => planCode,
+            :ccFirstName  => ccFirstName,
+            :ccLastName   => ccLastName,
+            :ccNumber     => ccNumber,
+            :ccExpiration => ccExpiration,
+            :ccZip        => zip
+          }
+        }
+      )    
+
+      add_errors_or_return_valid_response(response)
+    end
+  
+    def destroy
+      raise "Invalid customer code" if customerCode.blank?
+      response = CGClient.delete_customer({ :code => customerCode })
+    
+      add_errors_or_return_valid_response(response)    
+    end
+    
+    def instance_variables_hash
+      {
+        :customerCode => customerCode, 
+        :firstName => firstName,
+        :ccLastName => ccLastName,
+        :ccFirstName => ccFirstName,
+        :planCode => planCode,
+        :zip => zip,
+        :lastName => lastName,
+        :email => email
+      }     
+    end
+  end
+end

data/spec/cheddargetter_client_rails/subscription_spec.rb

@@ -0,0 +1,199 @@
+require 'spec_helper'
+
+describe CheddargetterClientRails::Subscription do
+  let(:user)          { double("TestUser") }
+  let(:subscription)  { CheddargetterClientRails::Subscription.new }
+  let(:customer_code) { 'JOHN_DOE' }
+
+  let(:valid_subscription_attributes) {
+    {
+      :planCode     => 'PAID_PLAN',
+      :firstName    => 'Joe',
+      :lastName     => 'Collins',
+      :ccNumber     => '4111111111111111',
+      :ccExpiration => '04/' + 3.years.from_now.year.to_s,
+      :zip          => '47401',
+      :email        => 'jim@test.com'
+    }
+  }
+
+  before { 
+    user.should_receive(:customer_code=).with(customer_code)
+    user.customer_code = subscription.customerCode = customer_code
+  }
+  
+  describe 'subscription#create' do
+    subject { subscription.create }
+    before  { 
+      subscription.stub(:add_errors_or_return_valid_response).and_return true
+      subscription.should_receive(:add_errors_or_return_valid_response)    
+      CGClient.should_receive(:new_customer) 
+    }
+    
+    it      { subject }
+  end
+  
+  describe 'subscription#update' do
+    subject { subscription.update }
+    before  { 
+      subscription.stub(:add_errors_or_return_valid_response).and_return true      
+      subscription.should_receive(:add_errors_or_return_valid_response) 
+      CGClient.should_receive(:edit_customer)
+    }
+    
+    it      { subject }
+  end
+  
+  describe 'subscription#new_record?' do
+    subject { subscription.new_record? }
+    
+    context 'when a subscription already exists' do
+      before  { CheddargetterClientRails::Subscription.stub(:get).and_return true }
+      it      { should be(false) }
+    end
+
+    context 'when no subscription exists' do
+      before  { CheddargetterClientRails::Subscription.stub(:get).and_return false }
+      it      { should be(true) }
+    end
+  end
+  
+  describe 'subscription#save' do
+    subject { subscription.save }
+    
+    context 'when a subscription already exists' do
+      before  { subscription.stub(:new_record?).and_return false }
+      before  { valid_subscription_attributes.each {|attribute, value| subscription.send(attribute.to_s + '=', value )} }      
+      before  { subscription.should_receive(:update) }
+      it      { subject }
+    end
+
+    context 'when a subscription already exists' do
+      before  { CheddargetterClientRails::Subscription.stub(:new_record?).and_return true }
+      before  { valid_subscription_attributes.each {|attribute, value| subscription.send(attribute.to_s + '=', value )} }
+      before  { subscription.should_receive(:create) }
+      it      { subject }
+    end
+    
+    context 'when not valid' do
+      before  { CheddargetterClientRails::Subscription.stub(:new_record?).and_return true }
+      
+      specify { subject; (subscription.errors.length > 1).should be_true }
+    end    
+  end
+  
+  describe 'subscription#destroy' do
+    subject { subscription.destroy }
+    context 'without customerCode' do
+      before { subscription.customerCode = nil }
+      specify { lambda{subject}.should raise_error }
+    end
+    
+    context 'with customerCode' do
+      specify { lambda{subject}.should_not raise_error }
+    end
+  end
+  
+  describe 'validates_presence_of' do
+    # this tests validations
+    #
+    # validates_presence_of :firstName,
+    #                       :lastName,
+    #                       :email,
+    #                       :customerCode,
+    #                       :planCode
+    # 
+    # validates_presence_of :ccNumber,
+    #                       :ccExpiration,
+    #                       :zip, :if => :paid_plan?
+
+    subject { subscription.valid? }
+    before  { valid_subscription_attributes.each{ |attribute, value| subscription.send(attribute.to_s + '=', value) } }
+     
+    context 'when free plan' do
+      before { subscription.planCode = "FREE_PLAN" }
+      
+      context 'when firstName is not set' do
+        before { subscription.firstName = nil }
+        it { should be_false }
+      end
+      context 'when lastName is not set' do
+        before { subscription.lastName = nil }
+        it { should be_false }
+      end
+      context 'when email is not set' do
+        before { subscription.email = nil }
+        it { should be_false }
+      end
+      context 'when planCode is not set' do
+        before { subscription.planCode = nil }
+        it { should be_false }
+      end
+      context 'when ccNumber is not set' do
+        before { subscription.ccNumber = nil }
+        it { should be_true }
+      end
+      context 'when ccExpiration is not set' do
+        before { subscription.ccExpiration = nil }
+        it { should be_true }
+      end
+      context 'when zip is not set' do
+        before { subscription.zip = nil }
+        it { should be_true }
+      end    
+    end
+    
+    context 'when paid plan' do
+      context 'when firstName is not set' do
+        before { subscription.firstName = nil }
+        it { should be_false }
+      end
+      context 'when lastName is not set' do
+        before { subscription.lastName = nil }
+        it { should be_false }
+      end
+      context 'when email is not set' do
+        before { subscription.email = nil }
+        it { should be_false }
+      end
+      context 'when planCode is not set' do
+        before { subscription.planCode = nil }
+        it { should be_false }
+      end
+      context 'when ccNumber is not set' do
+        before { subscription.ccNumber = nil }
+        it { should be_false }
+      end
+      context 'when ccExpiration is not set' do
+        before { subscription.ccExpiration = nil }
+        it { should be_false }
+      end
+      context 'when zip is not set' do
+        before { subscription.zip = nil }
+        it { should be_false }
+      end      
+    end
+  end
+  
+  describe 'instance_variables_hash' do
+    before  { valid_subscription_attributes.each {|attribute, value| subscription.send(attribute.to_s + '=', value )} }
+    before  { 
+      subscription.customerCode = "CUSTOMER_CODE" 
+      subscription.ccFirstName  = "Joe"
+      subscription.ccLastName   = "Collins"
+    }      
+    subject { subscription.instance_variables_hash }
+    it {
+      should eq({
+        :planCode     => 'PAID_PLAN',
+        :firstName    => 'Joe',
+        :lastName     => 'Collins',
+        :ccFirstName    => 'Joe',
+        :ccLastName     => 'Collins',
+        :zip          => '47401',
+        :email        => 'jim@test.com',
+        :customerCode => 'CUSTOMER_CODE'
+      })
+    }
+  end
+end

data/spec/cheddargetter_client_rails_spec.rb

@@ -0,0 +1,470 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+
+
+describe "CheddargetterClientRails" do
+  before {
+    class TestUser < ActiveRecord::Base
+      attr_accessor :customer_code, :first_name, :last_name, :plan_code
+
+      def self.column_names
+        []
+      end
+            
+      cheddargetter_billable_on :customer_code, :shared_columns => {
+                                                  :firstName    => :first_name, 
+                                                  :lastName     => :last_name, 
+                                                  :ccFirstName  => :first_name, 
+                                                  :ccLastName   => :last_name, 
+                                                  :planCode     => :plan_code
+                                                }
+
+
+    end
+  }
+  
+  before { TestUser.stub(:connection).and_return mock(:columns => []) }
+  
+  let(:user_class) {
+    TestUser
+  }
+  
+  let(:user) {
+    TestUser.new
+  }
+  
+  describe 'module included?' do
+    subject { CheddargetterClientRails }
+    specify { lambda { subject }.should_not raise_error }
+  end
+  
+  describe "inclusion of class methods" do
+    subject { user_class.respond_to?(:cheddargetter_billable_on) }
+    
+    it { should be_true }
+  end
+  
+  describe 'cheddargetter_billable_on' do
+    context 'argument errors' do
+      context 'without customer code column' do
+        subject {
+          class NoCustomerCodeUser < ActiveRecord::Base
+            cheddargetter_billable_on
+          end
+        }
+      
+        specify { lambda { subject }.should raise_error(ArgumentError) }
+      end 
+      
+      context 'when record does not responsd to customer_code_column' do
+        subject {
+          class NoCustomerCodeUser < ActiveRecord::Base
+            cheddargetter_billable_on :id
+          end
+        }
+        specify { lambda { subject }.should raise_error }
+      end
+    end
+    
+    context 'setting customer_code_column' do
+      subject { user_class.customer_code_column }
+      it { should eq(:customer_code) }
+    end
+    
+    context 'setting shared_columns' do
+      subject { user_class.shared_columns }
+      it { should eq( :firstName    => :first_name, 
+                      :lastName     => :last_name, 
+                      :ccFirstName  => :first_name, 
+                      :ccLastName   => :last_name, 
+                      :planCode     => :plan_code
+                    ) 
+      }      
+    end
+  end
+    
+  describe 'validate' do
+    let!(:test_user) {
+      TestUser.new  
+    }
+    
+    subject { test_user.valid? }
+
+    it 'should call validate_subscription' do
+      test_user.should_receive(:validate_subscription)
+      subject
+    end
+    
+    it 'should call supplement_subscription_fields' do
+      test_user.should_receive(:supplement_subscription_fields)
+      subject
+    end
+  end
+  
+  describe 'before_create' do
+    let!(:test_user) {
+      TestUser.new  
+    }
+
+    before  { test_user.should_receive :create_subscription }
+    subject { test_user.run_callbacks(:save) }
+    it do subject end
+  end
+  
+  describe 'subscription' do
+    let!(:subscription) { # use ! to set it now!
+      CheddargetterClientRails::Subscription.new
+    }
+
+    before {
+      CheddargetterClientRails::Subscription.stub(:new).and_return subscription
+      user.should_receive(:subscription).at_least(1).times.and_return(subscription)
+    }    
+    
+    context 'when not yet set' do
+      subject { user.subscription }
+      it { should eq(subscription) }    
+    end
+    
+    context 'when already set' do
+      before {
+        subscription = user.subscription
+        subscription.firstName = "First"
+      }
+      
+      subject { user.subscription.firstName }
+      it { should eq("First") }
+    end
+  end
+  
+  describe 'validate_subscription' do
+    let!(:user) {
+      TestUser.new  
+    }
+
+    let(:subscription) {
+      user.subscription
+    }
+    
+    subject { user.validate_subscription }
+    
+    context 'with subscription' do
+      context 'that is valid' do
+        before {
+          user.should_receive(:skip_cheddargetter).and_return false
+          user.should_receive(:new_record?).and_return true
+          subscription.should_receive(:valid?).and_return true         
+        }
+      
+        it "should not add errors" do
+          subject
+          (user.errors.length < 1).should be_true
+        end
+      end
+  
+      context 'that is invalid' do
+        before {
+          user.should_receive(:skip_cheddargetter).and_return false
+          user.should_receive(:new_record?).and_return true
+          subscription.should_receive(:valid?).and_return false        
+        }
+
+        it "should add errors" do
+          subject
+          (user.errors.length < 1).should be_false
+        end
+      end
+      
+      context 'with no subscription' do
+        before {
+          user.stub(:skip_cheddargetter).and_return false
+          user.stub(:new_record?).and_return true
+        }
+        
+        specify { subject; user.valid?.should be_false }
+      end
+      
+      context 'when skip_cheddargetter returns true' do
+        before {
+          user.stub(:skip_cheddargetter).and_return true
+          user.stub(:new_record?).and_return true
+          subscription.stub(:valid?).and_return true          
+        }
+
+        specify { subject; user.valid?.should be_true }
+      end
+      
+      context 'when record is not new' do
+        before {
+          user.stub(:skip_cheddargetter).and_return false
+          user.stub(:new_record?).and_return false
+          subscription.stub(:valid?).and_return false        
+        }
+
+        specify { subject; user.valid?.should be_true }                
+      end
+    end
+  end
+  
+  describe 'responds_to_customer_code_column?' do
+    context 'when columns include message' do
+      before {
+        class MessageInColumns < ActiveRecord::Base          
+          def self.column_names
+            ['customer_code']
+          end
+          
+          cheddargetter_billable_on :customer_code
+        end                    
+      }
+      
+      let(:record_class) {
+        MessageInColumns
+      }
+
+      before { record_class.stub(:connection).and_return mock(:columns => [])}      
+      
+      subject { record_class.responds_to_customer_code_column? }
+      it { should be_true }
+    end
+    
+    context 'when instance methods includes message' do
+      before {
+        class MessageInMethods < ActiveRecord::Base          
+          
+          def self.column_names
+            []
+          end
+
+          def customer_code
+            'TEST_CODE'
+          end
+          
+          p 'Make not that if method and not column, then it must be declared before cheddargetter_billable_on'
+                    
+          cheddargetter_billable_on :customer_code
+        end        
+      }
+      
+      let(:record_class) {
+        MessageInMethods
+      }
+  
+      before { record_class.stub(:connection).and_return mock(:columns => [])}      
+  
+      subject { record_class.responds_to_customer_code_column? }      
+      it { should be_true }
+    end
+    
+    context 'when instance does not respond to message' do
+      subject {
+        class MessageMissing < ActiveRecord::Base   
+          def self.column_names
+            []
+          end
+          
+          cheddargetter_billable_on :customer_code       
+        end           
+      }
+
+      specify { lambda { subject }.should raise_error }
+    end
+  end
+  
+  describe 'supplement_subscription_fields' do
+    let!(:user) {
+      TestUser.new  
+    }
+    
+    before { user.class.stub(:shared_columns).and_return({
+                                                :firstName    => :first_name, 
+                                                :lastName     => :last_name, 
+                                                :ccFirstName  => :first_name, 
+                                                :ccLastName   => :last_name, 
+                                                :planCode     => :plan_code
+                                              })
+    }
+                                            
+    before {
+      user.customer_code  = "FIRST_NAME" 
+      user.first_name     = "First"
+      user.last_name      = "Last"
+      user.plan_code      = "TEST_PLAN"
+    }
+    
+    subject { user.supplement_subscription_fields }
+    specify { 
+      subject
+      user.subscription.firstName.should == "First"
+      user.subscription.lastName.should == "Last"
+      user.subscription.planCode.should == "TEST_PLAN"
+    }
+    
+    context 'when planCode is a string' do
+      let!(:user) {
+        TestUser.new  
+      }
+
+      before { user.class.stub(:shared_columns).and_return({
+                                                  :planCode     => "EVERYBODYS_PLAN"
+                                                })
+      }
+
+      subject { user.supplement_subscription_fields }
+      specify { 
+        subject
+        user.subscription.planCode.should == "EVERYBODYS_PLAN"
+      }
+    end
+  end
+
+  describe 'create_subscription' do
+    let!(:user) {
+      TestUser.new  
+    }
+    
+    subject { user.create_subscription }
+    
+    context 'when skipping cheddargetter' do
+      before { user.customer_code = 'TEST_CODE' }
+      before { user.skip_cheddargetter = true }
+      before { user.subscription.should_not_receive(:create) }
+      it do subject end
+    end
+    
+    context 'when not skipping cheddargetter' do
+      before { user.customer_code = 'TEST_CODE' }      
+      before { user.skip_cheddargetter = false }
+      before { user.subscription.should_receive(:create) }
+      it do subject end
+    end
+    
+    context 'when subscription customer_code is not set' do
+      before { user.customer_code = 'TEST_CODE' }
+      it do subject; user.subscription.customerCode.should eq('TEST_CODE') end
+    end
+    
+    context 'when user customer code column is not set' do
+      specify { lambda { subject }.should raise_error }
+    end
+  end
+  
+  describe 'current_subscription' do
+    let!(:user) {
+      TestUser.new  
+    }
+    
+    let(:subscription) { CheddargetterClientRails::Subscription.new() }
+    before { CheddargetterClientRails::Subscription.stub(:get).and_return subscription }
+    
+    context 'when it does not exist' do
+      before { user.stub(:customer_code_column_value).and_return nil }
+      subject { user.current_subscription }
+      it { should be_nil }
+    end    
+
+    context 'when it does exist' do
+      before { user.stub(:customer_code_column_value).and_return 'CUSTOMER_CODE' }
+      context 'when it has not been accessed' do
+        subject { user.current_subscription }
+        it { should eq(subscription) }        
+      end
+
+      context 'when it has been accesssed' do
+        before { user.current_subscription.firstName = 'First' }
+        subject { user.current_subscription.firstName }
+        it { should eq("First") }
+      end    
+    end
+  end
+  
+  describe 'destroy_subscription' do
+    let!(:user) {
+      TestUser.new(:customer_code => 'CUSTOMER_CODE')  
+    }
+    
+    let(:subscription) { CheddargetterClientRails::Subscription.new }    
+    before { CheddargetterClientRails::Subscription.stub(:get).and_return subscription }
+    before { subscription.should_receive(:destroy) }
+    
+    subject { user.destroy_subscription }
+    it { subject }
+  end
+  
+  describe 'build_subscription' do
+    let!(:current_subscription) { 
+      CheddargetterClientRails::Subscription.new({:firstName => "First", :lastName => "Last"}) 
+    }    
+        
+    let(:subscription_params) {
+      {:lastName => 'NewLast'}
+    }
+        
+    subject { user.build_subscription(subscription_params) }
+        
+    context 'when current subscription' do
+      before { user.stub(:current_subscription).and_return(current_subscription) }
+      it 'should use data from current subscription' do
+        subject
+        user.subscription.firstName.should eq("First")
+      end
+      
+      it 'should overwrite data from current_subscription' do
+        subject
+        user.subscription.lastName.should eq("NewLast")
+      end
+    end
+    
+    context 'when no current_subscription' do
+      it 'should use a blank subscription object' do
+        subject
+        user.subscription.firstName.should be_nil
+      end
+      
+      it 'should fill in new data' do
+        subject
+        user.subscription.lastName.should eq("NewLast")
+      end
+    end
+  end
+  
+  describe 'customer_code_column_value' do
+    subject { user.customer_code_column_value }
+    
+    context 'when customer_code_column is set and value is set' do
+      before { user.customer_code = 'Customer Code' }
+      it { should eq('Customer Code') }
+    end
+    
+    context 'when customer_code_column is not set' do
+      before { user.class.stub(:customer_code_column).and_return nil }
+      it { should be_nil }
+    end
+    
+    context 'when value is not set' do
+      it { should be_nil }
+    end
+  end
+  
+  describe 'save_subscription' do
+    let!(:current_subscription) { 
+      CheddargetterClientRails::Subscription.new({:firstName => "First", :lastName => "Last"}) 
+    }    
+        
+    let!(:subscription_params) {
+      {:lastName => 'NewLast'}
+    }
+    
+    let!(:new_subscription) {
+      CheddargetterClientRails::Subscription.new
+    }
+    
+    subject { user.save_subscription(subscription_params) }
+    
+    before { CheddargetterClientRails::Subscription.stub(:new).and_return new_subscription }
+    
+    before { user.should_receive(:build_subscription) }
+    before { user.subscription.should_receive(:save) }
+    it do subject end
+  end
+end