ashmont 0.0.12

data/lib/ashmont/subscription.rb

@@ -0,0 +1,104 @@
+require "ashmont/errors"
+require "active_support/core_ext"
+require "braintree"
+
+module Ashmont
+  class Subscription
+    attr_reader :token, :errors
+
+    def initialize(token = nil, cached_attributes = {})
+      @token = token
+      @cached_attributes = cached_attributes
+      @errors = {}
+    end
+
+    delegate :transactions, :to => :remote_subscription, :allow_nil => true
+
+    def status
+      @cached_attributes[:status] || remote_status
+    end
+
+    def save(attributes)
+      attributes_for_merchant = add_merchant_to_attributes(attributes)
+      if token
+        update(attributes_for_merchant)
+      else
+        create(attributes_for_merchant)
+      end
+    end
+
+    def retry_charge
+      transaction = Braintree::Subscription.retry_charge(token).transaction
+      result = Braintree::Transaction.submit_for_settlement(transaction.id)
+      reload
+      if result.success?
+        true
+      else
+        @errors = Ashmont::Errors.new(transaction, result.errors)
+        false
+      end
+    end
+
+    def most_recent_transaction
+      transactions.sort_by(&:created_at).last
+    end
+
+    def next_billing_date
+      merchant_account_time_zone.parse(remote_subscription.next_billing_date) if remote_subscription
+    end
+
+    def reload
+      @remote_subscription = nil
+      @cached_attributes = {}
+      self
+    end
+
+    def past_due?
+      status == Braintree::Subscription::Status::PastDue
+    end
+
+    private
+
+    def remote_status
+      remote_subscription.status if remote_subscription
+    end
+
+    def add_merchant_to_attributes(attributes)
+      if Ashmont.merchant_account_id
+        attributes.merge(:merchant_account_id => Ashmont.merchant_account_id)
+      else
+        attributes
+      end
+    end
+
+    def create(attributes)
+      result = Braintree::Subscription.create(attributes)
+      if result.success?
+        @token = result.subscription.id
+        @remote_subscription = result.subscription
+        true
+      else
+        false
+      end
+    end
+
+    def update(attributes)
+      @remote_subscription = nil
+      Braintree::Subscription.update(token, attributes)
+    end
+
+    def remote_subscription
+      @remote_subscription ||= find_remote_subscription
+    end
+
+    def find_remote_subscription
+      if token
+        Braintree::Subscription.find(token)
+      end
+    end
+
+    def merchant_account_time_zone
+      ActiveSupport::TimeZone[Ashmont.merchant_account_time_zone]
+    end
+  end
+end

data/lib/ashmont/version.rb

@@ -0,0 +1,3 @@
+module Ashmont
+  VERSION = "0.0.12"
+end

data/lib/ashmont.rb

@@ -0,0 +1,13 @@
+require "ashmont/version"
+require "ashmont/subscription"
+require "ashmont/customer"
+require "ashmont/subscribed_customer"
+
+module Ashmont
+  class << self
+    attr_accessor :merchant_account_time_zone
+    attr_accessor :merchant_account_id
+  end
+
+  self.merchant_account_time_zone = 'Eastern Time (US & Canada)'
+end

data/spec/ashmont/customer_spec.rb

@@ -0,0 +1,286 @@
+require 'spec_helper'
+require 'ashmont/customer'
+
+describe Ashmont::Customer do
+  it "returns its first credit card" do
+    token = "xyz"
+    remote_customer = stub("customer", :credit_cards => ["first", "second"])
+    Braintree::Customer.stubs(:find => remote_customer)
+
+    result = Ashmont::Customer.new(token).credit_card
+
+    Braintree::Customer.should have_received(:find).with(token)
+    result.should == "first"
+  end
+
+  it "returns nothing without a remote customer" do
+    Ashmont::Customer.new.credit_card.should be_nil
+  end
+
+  it "returns all credit cards" do
+    token = "xyz"
+    remote_customer = stub("customer", :credit_cards => ["first", "second"])
+    Braintree::Customer.stubs(:find => remote_customer)
+
+    result = Ashmont::Customer.new(token).credit_cards
+
+    Braintree::Customer.should have_received(:find).with(token)
+    result.should == ["first", "second"]
+  end
+
+  it "returns an empty array without a remote customer" do
+    Ashmont::Customer.new.credit_cards.should == []
+  end
+
+
+  it "returns the remote email" do
+    remote_customer = stub("customer", :email => "admin@example.com")
+    Braintree::Customer.stubs(:find => remote_customer)
+
+    Ashmont::Customer.new("abc").billing_email.should == "admin@example.com"
+  end
+
+  it "doesn't have an email without a remote customer" do
+    Ashmont::Customer.new.billing_email.should be_nil
+  end
+
+  it "creates a valid remote customer" do
+    token = "xyz"
+    remote_customer = stub("customer", :credit_cards => [], :id => token)
+    create_result = stub("result", :success? => true, :customer => remote_customer)
+    attributes = { "email" => "ben@example.com" }
+    Braintree::Customer.stubs(:create => create_result)
+
+    customer = Ashmont::Customer.new
+    customer.save(attributes).should be_true
+
+    Braintree::Customer.should have_received(:create).with(:email => "ben@example.com", :credit_card => {})
+    customer.token.should == token
+    customer.errors.should be_empty
+  end
+
+  it "creates a remote customer with a credit card" do
+    token = "xyz"
+    remote_customer = stub("customer", :credit_cards => [], :id => token)
+    create_result = stub("result", :success? => true, :customer => remote_customer)
+    attributes = { "email" => "ben@example.com" }
+    Braintree::Customer.stubs(:create => create_result)
+
+    customer = Ashmont::Customer.new
+    customer.save(
+      :email => "jrobot@example.com",
+      :cardholder_name => "Jim Robot", 
+      :number => "4111111111111115",
+      :cvv => "123",
+      :expiration_month => 5,
+      :expiration_year => 2013,
+      :street_address => "1 E Main St",
+      :extended_address => "Suite 3",
+      :locality => "Chicago",
+      :region => "Illinois",
+      :postal_code => "60622",
+      :country_name => "United States of America"
+    )
+
+    Braintree::Customer.should have_received(:create).with(
+      :email => "jrobot@example.com",
+      :credit_card => {
+        :cardholder_name => "Jim Robot",
+        :number => "4111111111111115",
+        :cvv => "123",
+        :expiration_month => 5,
+        :expiration_year => 2013,
+        :billing_address => {
+          :street_address => "1 E Main St",
+          :extended_address => "Suite 3",
+          :locality => "Chicago",
+          :region => "Illinois",
+          :postal_code => "60622",
+          :country_name => "United States of America"
+        }
+      }
+    )
+  end
+
+  it "returns errors while creating an invalid remote customer" do
+    error_messages = "error messages"
+    errors = "errors"
+    verification = "failure"
+    create_result = stub("result",
+                         :success? => false,
+                         :errors => error_messages,
+                         :credit_card_verification => verification)
+    Braintree::Customer.stubs(:create => create_result)
+    Ashmont::Errors.stubs(:new => errors)
+
+    customer = Ashmont::Customer.new
+    customer.save("email" => "ben.franklin@example.com").should be_false
+
+    Ashmont::Errors.should have_received(:new).with(verification, error_messages)
+    customer.errors.should == errors
+  end
+
+  it "updates a remote customer with valid changes" do
+    token = "xyz"
+    updates = { "email" => 'somebody@example.com' }
+    customer = stub("customer", :id => token, :email => "somebody@example.com")
+    update_result = stub('result', :success? => true, :customer => customer)
+    Braintree::Customer.stubs(:update => update_result)
+
+    customer = Ashmont::Customer.new(token)
+    customer.save(updates).should be_true
+
+    Braintree::Customer.should have_received(:update).with(token, :email => "somebody@example.com", :credit_card => {})
+    customer.billing_email.should == "somebody@example.com"
+  end
+
+  it "updates a remote customer with a credit card" do
+    token = "xyz"
+    payment_method_token = "abc"
+    credit_card = stub("credit_card", :token => payment_method_token)
+    remote_customer = stub("customer", :credit_cards => [credit_card], :id => token)
+    update_result = stub("result", :success? => true, :customer => remote_customer)
+    Braintree::Customer.stubs(:update => update_result)
+    Braintree::Customer.stubs(:find => remote_customer)
+
+    customer = Ashmont::Customer.new(token)
+    customer.save(
+      :email => "jrobot@example.com",
+      :cardholder_name => "Jim Robot", 
+      :number => "4111111111111115",
+      :cvv => "123",
+      :expiration_month => 5,
+      :expiration_year => 2013,
+      :street_address => "1 E Main St",
+      :extended_address => "Suite 3",
+      :locality => "Chicago",
+      :region => "Illinois",
+      :postal_code => "60622",
+      :country_name => "United States of America"
+    )
+
+    Braintree::Customer.should have_received(:update).with(
+      token,
+      :email => "jrobot@example.com",
+      :credit_card => {
+        :cardholder_name => "Jim Robot",
+        :number => "4111111111111115",
+        :cvv => "123",
+        :expiration_month => 5,
+        :expiration_year => 2013,
+        :billing_address => {
+          :street_address => "1 E Main St",
+          :extended_address => "Suite 3",
+          :locality => "Chicago",
+          :region => "Illinois",
+          :postal_code => "60622",
+          :country_name => "United States of America"
+        },
+        :options => {
+          :update_existing_token => payment_method_token
+        }
+      }
+    )
+  end
+
+  it "returns errors while updating an invalid customer" do
+    error_messages = "error messages"
+    errors = "errors"
+    verification = "failure"
+    update_result = stub("result",
+                         :success? => false,
+                         :errors => error_messages,
+                         :credit_card_verification => verification)
+    Braintree::Customer.stubs(:update => update_result)
+    Ashmont::Errors.stubs(:new => errors)
+
+    customer = Ashmont::Customer.new("xyz")
+    customer.save("email" => "ben.franklin@example.com").should be_false
+
+    Ashmont::Errors.should have_received(:new).with(verification, error_messages)
+    customer.errors.should == errors
+  end
+
+  it "delete a remote customer" do
+    token = "xyz"
+    Braintree::Customer.stubs(:delete)
+
+    customer = Ashmont::Customer.new(token)
+    customer.delete
+
+    Braintree::Customer.should have_received(:delete).with(token)
+  end
+
+  it "has billing info with a credit card" do
+    token = "abc"
+    credit_card = stub("credit_card", :token => token)
+    remote_customer = stub("customer", :credit_cards => [credit_card])
+    Braintree::Customer.stubs(:find => remote_customer)
+
+    customer = Ashmont::Customer.new("xyz")
+    customer.should have_billing_info
+    customer.payment_method_token.should == token
+  end
+
+  it "doesn't have billing info without a credit card" do
+    remote_customer = stub("customer", :credit_cards => [])
+    Braintree::Customer.stubs(:find => remote_customer)
+
+    customer = Ashmont::Customer.new("xyz")
+    customer.should_not have_billing_info
+    customer.payment_method_token.should be_nil
+  end
+
+  %w(last_4 cardholder_name expiration_month expiration_year).each do |credit_card_attribute|
+    it "delegates ##{credit_card_attribute} to its credit card" do
+      credit_card = stub("credit_card", credit_card_attribute => "expected")
+      remote_customer = stub("customer", :credit_cards => [credit_card])
+      Braintree::Customer.stubs(:find => remote_customer)
+
+      Ashmont::Customer.new("xyz").send(credit_card_attribute).should == "expected"
+    end
+  end
+
+  %w(street_address extended_address locality region postal_code country_name).each do |billing_address_attribute|
+    it "delegates ##{billing_address_attribute} to its billing address" do
+      billing_address = stub("billing_address", billing_address_attribute => "expected")
+      credit_card = stub("credit_card", :billing_address => billing_address)
+      remote_customer = stub("customer", :credit_cards => [credit_card])
+      Braintree::Customer.stubs(:find => remote_customer)
+
+      Ashmont::Customer.new("xyz").send(billing_address_attribute).should == "expected"
+    end
+  end
+
+  it "confirms a transparent redirect query string" do
+    token = "xyz"
+    query_string = "abcmagic"
+    remote_customer = stub("customer", :credit_cards => [], :id => token)
+    confirm_result = stub("result", :success? => true, :customer => remote_customer)
+    Braintree::TransparentRedirect.stubs(:confirm => confirm_result)
+
+    customer = Ashmont::Customer.new
+    customer.confirm(query_string).should be_true
+
+    Braintree::TransparentRedirect.should have_received(:confirm).with(query_string)
+    customer.token.should == token
+  end
+
+  it "adds errors for an invalid transparent redirect query string" do
+    error_messages = "error messages"
+    errors = "errors"
+    verification = "failure"
+    confirm_result = stub("result",
+                          :success? => false,
+                          :errors => error_messages,
+                          :credit_card_verification => verification)
+    Braintree::TransparentRedirect.stubs(:confirm => confirm_result)
+    Ashmont::Errors.stubs(:new => errors)
+
+    customer = Ashmont::Customer.new
+    customer.confirm("abc").should be_false
+
+    Ashmont::Errors.should have_received(:new).with(verification, error_messages)
+    customer.errors.should == errors
+  end
+end

data/spec/ashmont/errors_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Ashmont::Errors do
+  it "adds an error for a declined number" do
+    errors_for(:status => "processor_declined", :processor_response_text => "failure").
+      should include("number was denied by the payment processor with the message: failure")
+  end
+
+  it "adds an error for a mismatched cvv" do
+    errors_for(:status => "gateway_rejected").should include("cvv did not match")
+  end
+
+  it "adds a generic card number error" do
+    errors_for(:messages => { :number => "Credit card number is unsupported" }).
+      should include("number is unsupported")
+  end
+
+  it "adds a generic cvv error" do
+    errors_for(:messages => { :CVV => "CVV is unsupported" }).
+      should include("cvv is unsupported")
+  end
+
+  it "adds a generic expiration_month error" do
+    errors_for(:messages => { :expiration_month => "Expiration month is unsupported" }).
+      should include("expiration_month is unsupported")
+  end
+
+  it "adds a generic expiration_year error" do
+    errors_for(:messages => { :expiration_year => "Expiration year is unsupported" }).
+      should include("expiration_year is unsupported")
+  end
+
+  it "handles error results without a status" do
+    result = {}
+    errors = [ stub("error", :attribute => "foo", :message => "bar") ]
+    expect { Ashmont::Errors.new(result, errors).to_hash }.to_not raise_error(NoMethodError)
+  end
+
+  def errors_for(options = {})
+    result = stub("result",
+                  :status => options[:status] || "rejected",
+                  :processor_response_text => options[:processor_response_text] || "error")
+    errors = (options[:messages] || {}).map do |attribute, message|
+      stub("error", :attribute => attribute.to_s, :message => message)
+    end
+
+    Ashmont::Errors.new(result, errors).to_hash.inject([]) do |result, (attribute, message)|
+      result << [attribute, message].join(" ")
+    end
+  end
+end

data/spec/ashmont/subscribed_customer_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Ashmont::SubscribedCustomer do
+  it "delegates Customer methods to the customer" do
+    customer = stub("customer")
+    subscribed_customer = build_subscribed_customer(:customer => customer)
+    customer_methods = Ashmont::Customer.instance_methods(false)
+    merged_methods = [:errors, :save]
+    delegated_methods = customer_methods - merged_methods
+    delegated_methods.each do |method|
+      customer.stubs(method => "expected")
+      result = subscribed_customer.send(method, "argument")
+      customer.should have_received(method).with("argument")
+      result.should == "expected"
+    end
+  end
+
+  it "delegates some Subscription methods to the subscription" do
+    subscription = stub("subscription")
+    subscribed_customer = build_subscribed_customer(:subscription => subscription)
+    %w(reload status next_billing_date transactions most_recent_transaction retry_charge past_due?).each do |method|
+      subscription.stubs(method => "expected")
+      result = subscribed_customer.send(method, "argument")
+      subscription.should have_received(method).with("argument")
+      result.should == "expected"
+    end
+  end
+
+  it "delegates #subscription_token to its subscription's token" do
+    subscription = stub("subscription", :token => "expected")
+    subscribed_customer = build_subscribed_customer(:subscription => subscription)
+    subscribed_customer.subscription_token.should == "expected"
+  end
+
+  it "#reloads the subscription" do
+    subscription = stub("subscription", :reload => "expected")
+    subscribed_customer = build_subscribed_customer(:subscription => subscription)
+
+    result = subscribed_customer.reload
+
+    subscription.should have_received(:reload)
+    result.should == "expected"
+  end
+
+  it "can #save the customer" do
+    attributes = { :email => "somebody@example.com" }
+    customer = stub("customer", :save => true, :token => nil)
+    subscribed_customer = build_subscribed_customer(:customer => customer)
+
+    result = subscribed_customer.save(attributes)
+
+    customer.should have_received(:save).with(attributes)
+    result.should be_true
+  end
+
+  it "saves a new customer without attributes" do
+    customer = stub("customer", :token => nil, :save => true)
+    subscribed_customer = build_subscribed_customer(:customer => customer)
+
+    subscribed_customer.save({})
+
+    customer.should have_received(:save).with({})
+  end
+
+  it "doesn't #save the customer without any customer attributes" do
+    attributes = { :price => 49 }
+    customer = stub("customer", :save => true, :token => "xyz")
+    subscribed_customer = build_subscribed_customer(:customer => customer)
+
+    subscribed_customer.save(attributes)
+
+    customer.should have_received(:save).never
+  end
+
+  it "can #save the subscription" do
+    attributes = { :plan_id => 41, :price => 15 }
+    subscription = stub("subscription", :save => "expected", :past_due? => false)
+    payment_method_token = "xyz"
+    customer = stub("customer", :payment_method_token => payment_method_token, :token => "xyz")
+    subscribed_customer = build_subscribed_customer(:subscription => subscription, :customer => customer)
+
+    result = subscribed_customer.save(attributes)
+
+    subscription.should have_received(:save).with(:plan_id => 41, :price => "15", :payment_method_token => payment_method_token)
+    result.should == "expected"
+  end
+
+  it "retries the subscription when past due" do
+    subscription = stub("subscription", :past_due? => true, :retry_charge => true)
+
+    subscribed_customer = build_subscribed_customer(:subscription => subscription)
+    subscribed_customer.save({})
+
+    subscription.should have_received(:retry_charge)
+  end
+
+  it "merges #errors from the customer and subscription" do
+    subscription = stub("subscription", :errors => stub_errors("one" => "first"))
+    customer = stub("customer", :errors => stub_errors("two" => "second"))
+    subscribed_customer = build_subscribed_customer(:subscription => subscription, :customer => customer)
+
+    subscribed_customer.errors.to_hash.should == { "one" => "first", "two" => "second" }
+  end
+
+  def build_subscribed_customer(options = {})
+    Ashmont::SubscribedCustomer.new(
+      options[:customer] || build_customer,
+      options[:subscription] || build_subscription
+    )
+  end
+
+  def build_customer
+    Ashmont::Customer.new("xyz")
+  end
+
+  def build_subscription
+    Ashmont::Subscription.new("abc", :status => "Active")
+  end
+
+  def stub_errors(messages)
+    stub("errors", :to_hash => messages)
+  end
+end