pay_simple 0.0.1

data/spec/factories/recurring_payment.rb

@@ -0,0 +1,25 @@
+FactoryGirl.define do
+  factory :recurring_payment, :class => PS::RecurringPayment do
+     customer_id                   0
+     customer_account_id           0
+     schedule_type                 RecurringScheduleType::PAYMENT_PLAN
+     start_date                    Time.now
+     has_end_date                  false
+     billing_frequency_type        BillingFrequencyType::WEEKLY
+     billing_frequency_param       1
+     payment_amount                100
+     first_payment_done            true
+     first_payment_amount          100
+     first_payment_date            Time.now-(86400*3)
+     total_due_amount              1000
+     total_number_of_payments      10
+     balance_remaining             900
+     number_of_payments_remaining  9
+     invoice_no                    0
+     order_id                      0
+     schedule_status               PS::ScheduleStatus::ACTIVE
+     number_of_payment_made        1
+     total_amount_paid             100
+     date_of_last_payment_made     Time.now-(86400*3)
+  end
+end

data/spec/ps/api/json_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+describe "An instance of PS::Api::json" do
+  before { connect }
+  #TODO test date formatting 
+  describe "#request" do
+    subject { $api }
+
+    it "should make a request" do
+      subject.request("addcustomer", FactoryGirl.attributes_for(:customer, { :last_modified => Time.now }))
+    end
+  end
+end

data/spec/ps/api_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+class DummyClass
+  extend PS::Api
+end
+describe "An instance of", PS::Api do
+  before { connect() }
+  context "given a JSON format" do
+    subject { DummyClass }
+    before { subject.connect("json") }
+
+    it "should initialize the JSON api class" do
+      $api.class.should == PS::Api::Json
+    end
+
+    it "should returned the required attributes" do
+      subject.required_attributes().class.should == Array
+    end
+
+    it "should make an api request" do
+      #PS::Response.stub(:ps_object) { false }
+      PS::Api::Json.any_instance.should_receive(:request)
+      PS::Response.should_receive(:new) 
+      subject.request("getstates")
+    end
+  end
+
+  context "Given an unsupported format" do
+    subject { DummyClass }
+
+    it "should raise a connection error" do
+      expect {
+        subject.connect("invalid_format")
+      }.to raise_error(PS::ConnectionError, "invalid_format is not a supported format")
+    end
+  end
+
+  describe "#host" do
+    let(:ps_api) { DummyClass }
+
+    subject { ps_api.host() }
+    
+    it "should return the dev url" do
+      ps_api.should_receive(:env) { "development" }
+      subject.should == "https://sandbox-api.paysimple.com/3.00/paysimpleapi"
+    end
+
+    it "should return the production  url" do
+      ps_api.should_receive(:env).exactly(2) { "production" }
+      subject.should == "https://api.paysimple.com/3.00/paysimpleapi"
+    end
+  end
+end

data/spec/ps/base_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe "An instance of", PS::Base do
+  before { connect() }
+
+  context "given a valid connection Hash" do 
+    context "with the format being JSON" do
+      let(:ps_base) { PS::Base }
+      subject { ps_base.establish_connection(formatted_connection_config("JSON")) }
+
+      it "should create a connection to the Paysimple API" do
+        subject
+        $api.class.should == PS::Api::Json
+      end
+
+      it "Should output the connection config" do
+        $stdout.should_receive(:puts)
+        subject
+        ps_base.current_connection()
+      end
+    end
+
+    context "with no format provided" do
+      subject { PS::Base.establish_connection(formatless_connection_config()) }
+
+      it "should default to JSON" do
+        subject
+        $api.class.should == PS::Api::Json
+      end
+    end
+  end
+
+  context "given an invalid connectiond Hash" do
+    subject { PS::Base.establish_connection({}) }
+
+    it "should raise an exception" do
+      expect { subject }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/ps/format_spec.rb

@@ -0,0 +1,16 @@
+#high level tests for the format classes
+require 'spec_helper'
+
+describe "High level format class" do
+  Dir.glob("lib/ps/api/*.rb").each do |format_klass|
+    require File.dirname(__FILE__)+"/../../"+format_klass
+    klass = PS::Api.const_get(format_klass.scan(/[a-zA-Z]+\.rb/)[0].gsub(/\.rb/, '').capitalize)
+    describe klass do
+      context "required methods" do
+        it { klass.method_defined?(:request).should be_true }
+        it { klass.method_defined?(:date?).should be_true }
+        it { klass.method_defined?(:parse_date).should be_true }
+      end
+    end
+  end
+end

data/spec/ps/object_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+class PS::DummyClass < PS::Object
+  attr_accessor :first_name, :last_name
+
+  def initialize(params)
+    @first_name = params[:first_name]
+    @last_name = params[:last_name]
+  end
+end
+
+describe "An instance of", PS::Object do
+  describe "#attributes" do
+    let(:attributes_hash) { { :first_name => "test", :last_name => "test" } }
+
+    subject { PS::DummyClass.new(attributes_hash) }
+
+    it { subject.should respond_to(:request) }
+
+    it "should return the attributes of subject" do
+      subject.attributes.should == attributes_hash
+    end
+  end
+
+  describe "#new" do
+    let(:customer) { FactoryGirl.attributes_for(:customer) }
+    subject { PS::Customer.new(customer) }
+
+    it "should assign attributes for the appropriate class" do 
+      subject.instance_variables.each do |v|
+        subject.send(v.to_s[1..-1]).should eq(customer[v.to_s[1..-1].to_sym])
+      end
+    end
+  end
+end

data/spec/ps/objects/ach_account_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe "An instance of", PS::AchAccount do 
+  before { connect() }
+  let(:customer_id) do 
+    PS::Customer.create(FactoryGirl.attributes_for(:customer)).ps_reference_id
+  end
+
+  describe "#create" do
+    subject do
+      PS::AchAccount.create(
+        FactoryGirl.attributes_for(:ach_account, { :customer_id => customer_id })
+      ) 
+    end
+
+    it "should create an ach account" do
+      subject.ps_reference_id.should_not be_nil
+    end
+  end
+
+  describe "instantiated" do
+    let(:ach_account) do
+      PS::AchAccount.create(
+        FactoryGirl.attributes_for(:ach_account, { :customer_id => customer_id })
+      ) 
+    end
+
+    describe "#update" do
+      subject { ach_account.update }
+
+      it "should update attributes" do
+        ach_account.bank_name = "test"
+        subject
+      end
+    end
+
+    describe "delete" do
+      subject { ach_account.delete }
+
+      it "should delete the customer" do
+        subject
+      end
+    end
+
+    context "bad save" do
+      subject do
+        PS::AchAccount.new(
+          FactoryGirl.attributes_for(:ach_account)
+        ).save()
+      end
+
+      it "should catch the exception and return false" do
+        subject.should == false
+      end
+    end
+  end
+end

data/spec/ps/objects/credit_card_account_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe PS::CreditCardAccount do
+  before { connect() }
+  let(:customer_id) do
+    PS::Customer.create(FactoryGirl.attributes_for(:customer)).ps_reference_id 
+  end
+
+  describe "class methods" do
+    describe "#create" do
+      subject do
+        PS::CreditCardAccount.create(
+          FactoryGirl.attributes_for(:credit_card_account, :customer_id => customer_id)
+        )
+      end
+
+      it "should create a credit card account" do
+        subject.class.should == PS::CreditCardAccount
+      end
+
+    end
+
+    context "bad save" do
+      subject do
+        PS::CreditCardAccount.new(
+          FactoryGirl.attributes_for(:credit_card_account)
+        ).save
+      end
+
+      it "should catch the exception and return false" do
+        subject.should == false
+      end
+    end
+
+    describe "#default_for_customer_id" do
+      let(:credit_card) { FactoryGirl.create(:credit_card_account, :customer_id => customer_id) }
+      before { credit_card.make_default }
+      subject { PS::CreditCardAccount.default_for_customer_id(customer_id) }
+
+      it "should get the default credit card for a customer" do
+        subject.ps_reference_id.should == credit_card.ps_reference_id
+      end
+    end
+  end
+
+  describe "instance methods" do
+    let(:credit_card) { FactoryGirl.create(:credit_card_account, :customer_id => customer_id) }
+
+    describe ".update" do
+      before do 
+        credit_card.c_c_expiry = "11/2016"
+      end
+      subject { credit_card.update }
+
+      it "should update the credit card's attributes" do
+        subject
+      end
+    end
+
+
+    describe ".delete" do
+      subject { credit_card.delete() }
+
+      it "should delete the credit_card" do
+        subject
+      end
+    end
+  end
+end

data/spec/ps/objects/customer_account_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe "An instance of", PS::CustomerAccount do
+  before { connect() }
+  let(:customer_id) { FactoryGirl.create(:customer).ps_reference_id }
+
+  describe ".make_default" do
+    let(:customer_id) { FactoryGirl.create(:customer).ps_reference_id }
+    subject do
+      FactoryGirl.create(:credit_card_account, { :customer_id => customer_id }) 
+    end
+
+    it "should make it default" do
+      subject.make_default
+      PS::CustomerAccount.default(customer_id).ps_reference_id.should == subject.ps_reference_id
+    end
+  end
+
+  describe "#find" do
+    let(:account_id) do
+      FactoryGirl.create(:credit_card_account, { :customer_id => customer_id }).ps_reference_id 
+    end
+    subject { PS::CustomerAccount.find(account_id, customer_id) }
+
+    it "should retreive the customer account" do
+      subject.ps_reference_id.should == account_id
+    end
+  end
+
+  describe "#default" do
+    let(:default_account) do
+      FactoryGirl.create(:credit_card_account, { :customer_id => customer_id })
+    end
+    before do 
+      default_account.make_default
+    end
+    subject { PS::CustomerAccount.default(customer_id) }
+
+    it "should get the default customer account" do
+      subject.ps_reference_id.should == default_account.ps_reference_id
+    end
+  end
+end

data/spec/ps/objects/customer_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe "An instance of", PS::Customer do
+  before { connect() }
+
+  describe "#create" do
+    subject { PS::Customer }
+
+    it "should create a new customer" do
+      new_customer = subject.create(FactoryGirl.attributes_for(:customer))
+      new_customer.class.should == subject
+    end
+  end
+
+  describe "#create_and_make_cc_payment" do
+    subject do
+      PS::Customer.create_and_make_cc_payment(
+        FactoryGirl.attributes_for(:customer),
+        FactoryGirl.attributes_for(:credit_card_account),
+        amount=1.00,
+        "999"
+      ) 
+    end
+
+    it "should create a customer, creditCardAccount, and Payment" do
+      response = subject
+      response[0].class.should == PS::Customer
+      response[1].class.should == PS::CreditCardAccount
+      response[2].class.should == PS::Payment
+    end
+  end
+
+  describe "#create_and_make_ach_payment" do
+    subject do
+      PS::Customer.create_and_make_ach_payment(
+        FactoryGirl.attributes_for(:customer),
+        FactoryGirl.attributes_for(:ach_account),
+        amount=1.00,
+        "999"
+      ) 
+    end
+
+    it "should create a customer, customerAccount, and Payment" do
+      response = subject
+      response[0].class.should == PS::Customer
+      response[1].class.should == PS::AchAccount
+      response[2].class.should == PS::Payment
+    end
+  end
+
+  describe "get_customer_and_default_accounts" do
+    let(:customer_id) { FactoryGirl.create(:customer).ps_reference_id }
+
+    before do
+      FactoryGirl.create(:credit_card_account, { :customer_id => customer_id }).make_default
+      #FactoryGirl.create(:ach_account, { :customer_id => customer_id }).make_default
+    end
+
+    subject { PS::Customer.get_customer_and_default_accounts(customer_id) }
+
+    it "should get the customer and return customerAccount subclasses" do
+      response = subject
+      response[0].class.should == PS::Customer
+      response[1].class.should == PS::CreditCardAccount
+      #response[2].class.should == PS::AchAccount
+    end
+  end
+
+  describe "list methods" do
+    subject { PS::Customer }
+
+    describe "#find" do
+      let(:customer_id) { PS::Customer.create(FactoryGirl.attributes_for(:customer)).ps_reference_id }
+      context "given an id" do
+        it "should find a customer" do
+          customer = subject.find(customer_id)
+          customer.class.should == subject
+        end
+      end
+
+      context "given a hash of customer attributes" do
+        let(:customer_attributes) { FactoryGirl.attributes_for(:customer) }
+        it "should find a customer"
+      end
+
+      it "should search for a customer based off of search criteria provided."
+      it "should list all customers"
+    end
+  end
+
+  describe "#destroy" do
+    context "given existing customer object" do
+      subject { PS::Customer.create(FactoryGirl.attributes_for(:customer)) }
+
+      it "should delete a customer object that exists" do
+        subject.destroy.should == true
+      end
+    end
+
+    context "given a customer object that doesn't exist" do
+      subject { FactoryGirl.build(:customer).destroy }
+
+      it "should return false" do
+        subject.should eq(false) 
+      end
+    end
+  end
+
+  describe "#save" do
+    context "with valid input" do
+      subject { PS::Customer.new(FactoryGirl.attributes_for(:customer)) }
+
+      it "should save a customer" do
+        subject.save().should == true
+        subject.ps_reference_id.should_not be_nil
+      end
+    end
+
+    context "with invalid input" do
+      subject { PS::Customer.new({ :farw => 'tetet' }) }
+
+      it "should return false" do
+        subject.save().should == false
+      end
+    end
+  end
+
+  describe "relations" do
+    let(:customer_id) { PS::Customer.create(FactoryGirl.attributes_for(:customer)).ps_reference_id }
+    subject { PS::Customer.find(customer_id) }
+
+    it "should find the credit card account associated with the customer" do
+      PS::CreditCardAccount.should_receive(:default_for_customer_id).with(customer_id)
+      subject.default_credit_card_account
+    end
+    
+    it "should set the default customer account" do
+      PS::CustomerAccount.should_receive(:find) { FactoryGirl.build(:customer_account) }
+      PS::CustomerAccount.any_instance.should_receive(:make_default)
+      subject.set_default_customer_account(5)
+    end
+
+    it "should get the default customer account" do
+      PS::CustomerAccount.should_receive(:default).with(customer_id)
+      subject.default_customer_account
+    end
+
+    it "should get payments for the customer" do
+      PS::Payment.should_receive(:find).with(customer_id)
+      subject.payments
+    end
+  end
+end