relish-billing 0.0.3

data/lib/relish/billing/entities.rb

@@ -0,0 +1,107 @@
+module Relish
+  module Billing
+
+    class CardDetails
+      attr_reader :first_name, :last_name, :address1, :address2, :city, :state, :zip, :country, :number, :expiry_month, :expiry_year, :cvv
+      def initialize(params = {})
+        @first_name   = params.fetch :first_name, ''
+        @last_name    = params.fetch :last_name, ''
+        @address1     = params.fetch :address1, ''
+        @address2     = params.fetch :address2, ''
+        @city         = params.fetch :city, ''
+        @state        = params.fetch :state, ''
+        @zip          = params.fetch :zip, ''
+        @country      = params.fetch :country, ''
+        @number       = params.fetch :number, ''
+        @expiry_month = params.fetch :expiry_month, ''
+        @expiry_year  = params.fetch :expiry_year, ''
+        @cvv          = params.fetch :cvv, ''
+      end
+    end
+
+    class MaskedCardDetails
+      attr_reader :last_four
+
+      def initialize(params)
+        @last_four = params.fetch :last_four
+      end
+    end
+
+    require 'date'
+    class UserProfile
+      attr_reader :email, :id, :plan
+      def initialize(params)
+        @email          = params.fetch :email
+        @id             = params.fetch :id
+        @plan           = params.fetch :plan
+        @trial_end_date = params.fetch :trial_end_date
+      end
+
+      def trial_end_date
+        realistic_trial_end_date
+      end
+
+      def with_plan(new_plan)
+        UserProfile.new(
+          email: email,
+          id: id,
+          plan: new_plan,
+          trial_end_date: trial_end_date)
+      end
+
+      private
+
+      def realistic_trial_end_date
+        return Date.today if @trial_end_date < Date.today
+        @trial_end_date
+      end
+    end
+
+    class AccountStatus
+      attr_reader :plan_id, :card_details, :next_billing_date
+      def initialize(params)
+        @plan_id = params.fetch :plan_id
+        @card_details = params.fetch :card_details
+        @next_billing_date = params.fetch :next_billing_date
+        @non_renewing = params.fetch :non_renewing
+        @active = params.fetch :active
+      end
+
+      # If this flag is true, it means that the user has
+      # cancelled their subscription, but not yet hit the end
+      # of their billing period.
+      #
+      # So they can still access their account for the time being,
+      # but they should be told that their account will go
+      # back to free plan at the end of their billing cycle.
+      def non_renewing?
+        @non_renewing
+      end
+
+      # This this flag is true, it means the user has a
+      # paid account that's all up and running normally
+      def active?
+        @active
+      end
+
+    end
+
+    CardDeclinedError = Class.new(StandardError) do
+      attr_reader :reason
+
+      def initialize(message = nil)
+        @reason = Reason.new(message)
+      end
+
+      Reason = Struct.new(:message) do
+        def append_to(string)
+          string << message if message
+        end
+      end
+    end
+
+    InvalidPlanError = Class.new(StandardError)
+    AccountNotFoundError = Class.new(StandardError)
+
+  end
+end

data/lib/relish/billing/fake_driver.rb

@@ -0,0 +1,101 @@
+require_relative 'entities'
+
+module Relish
+  module Billing
+    class FakeDriver
+      def fixtures
+        default = { expiry_month: '', expiry_year: '', cvv: '', country: 'BE' }
+        @fixtures ||= {
+          valid_credit_card:       CardDetails.new(default.merge(number: '1111111111111111')),
+          invalid_credit_card:     CardDetails.new(default.merge(number: '*INVALIDINVALID*')),
+          other_valid_credit_card: CardDetails.new(default.merge(number: '1111222233334444')),
+        }
+      end
+
+      def clear_test_data
+        @plans = nil
+        @cards = nil
+      end
+
+      def set_plan(profile)
+        ensure_account_for(profile)
+        plans[profile.id] = profile.plan
+        self
+      end
+
+      def save_card(profile, card)
+        ensure_account_for(profile)
+        raise CardDeclinedError if invalid?(card)
+        cards[profile.id] = card
+        self
+      end
+
+      def cancel_subscription(profile_id)
+        plans.delete(profile_id)
+        cards.delete(profile_id)
+        self
+      end
+
+      def account_status(profile)
+        ensure_account_for(profile)
+        plan = plans.fetch(profile.id)
+        if active?(profile)
+          card_details = mask(cards[profile.id])
+        else
+          card_details = CardDetails.new
+        end
+        AccountStatus.new plan_id: plan,
+          card_details: card_details,
+          next_billing_date: next_billing_date(profile),
+          non_renewing: true,
+          active: active?(profile)
+      end
+
+      private
+
+      def next_billing_date(profile)
+        if active?(profile) && (profile.trial_end_date == Date.today)
+          Date.today.next_month
+        else
+          profile.trial_end_date
+        end
+      end
+
+      def ensure_account_for(profile)
+        return if plans.key?(profile.id)
+        plans[profile.id] = profile.plan
+      end
+
+      def invalid?(card)
+        card == fixtures.fetch(:invalid_credit_card)
+      end
+
+      def active?(profile)
+        cards.key?(profile.id)
+      end
+
+      def mask(card)
+        MaskedCardDetails.new(
+          last_four: last_four_from(card))
+      end
+
+      def last_four_from(card)
+        card.number[12..-1]
+      end
+
+      def cards
+        @cards ||= {}
+      end
+
+      def plans
+        @plans ||= {}
+      end
+
+      class NullCard
+        def number
+          '?' * 16
+        end
+      end
+    end
+  end
+end

data/lib/relish/billing/recurly_api_driver.rb

@@ -0,0 +1,340 @@
+require 'recurly'
+require_relative 'entities'
+
+module Relish
+  module Billing
+    class RecurlyApiDriver
+
+      def self.configure
+        yield config
+      end
+
+      def self.config
+        @config ||= Config.new
+      end
+
+      def clear_test_data
+        self.class.config.environment.clear_test_data
+      end
+
+      def fixtures
+        card = lambda do |number|
+          CardDetails.new(first_name: 'Test first name',
+                          last_name: 'Test last name',
+                          number: number,
+                          cvv: '123',
+                          expiry_month: 11,
+                          expiry_year: 2015)
+        end
+
+        {
+          valid_credit_card:       card['4111111111111111'],
+          invalid_credit_card:     card['4000000000000002'],
+          other_valid_credit_card: card['378282246310005'],
+        }
+      end
+
+      def set_plan(profile)
+        ensure_account(profile) do |account|
+          ensure_subscription(profile, account) do |subscription|
+            begin
+              subscription.update_attributes! plan_code: profile.plan
+            rescue Recurly::Resource::Invalid
+              raise InvalidPlanError
+            end
+          end
+        end
+        self
+      end
+
+      def save_card(profile, card)
+        ensure_account(profile) do |account|
+          account.billing_info = build.billing_info(card)
+          account.billing_info.save!
+        end
+        set_plan(profile)
+      rescue Recurly::Transaction::DeclinedError,
+             Recurly::Resource::Invalid => exception
+        raise CardDeclinedError, exception.message
+      rescue ArgumentError,
+             NoMethodError
+        raise CardDeclinedError
+      ensure
+        self
+      end
+
+      def cancel_subscription(profile)
+        ensure_account(profile) do |account|
+          ensure_subscription(profile, account) do |subscription|
+            subscription.cancel
+          end
+        end
+        self
+      end
+
+      def account_status(profile)
+        ensure_account(profile) do |account|
+          ensure_subscription(profile, account) do |subscription|
+            return build.account_status(subscription, card_details(account))
+          end
+        end
+      end
+
+      private
+
+      def card_details(account)
+        return CardDetails.new unless account.billing_info
+        build.masked_card(account.billing_info)
+      end
+
+      def ensure_account(profile)
+        yield Recurly::Account.find(profile.id)
+      rescue Recurly::Resource::NotFound
+        yield Recurly::Account.create! build.account(profile)
+      ensure
+        self
+      end
+
+      def ensure_subscription(profile, account)
+        unless account.billing_info
+          yield NoSubscription.new(profile) if block_given?
+          return self
+        end
+
+        unless account.subscriptions.any?
+          Recurly::Subscription.create! build.subscription(profile, account)
+          account.reload
+        end
+
+        yield account.subscriptions.first if block_given?
+        self
+      end
+
+      def build
+        Module.new do
+          extend self
+
+          def account(profile)
+            {
+              account_code: profile.id,
+              email: profile.email
+            }
+          end
+
+          def subscription(profile, account)
+          {
+            plan_code: profile.plan,
+            currency: 'USD',
+            account: account,
+            trial_ends_at: profile.trial_end_date
+          }
+          end
+
+          def billing_info(card)
+            {
+              first_name: card.first_name,
+              last_name: card.last_name,
+              number: card.number,
+              month: card.expiry_month,
+              year: card.expiry_year,
+              verification_value: card.cvv,
+              address1: card.address1,
+              address2: card.address2,
+              city: card.city,
+              state: card.state,
+              zip: card.zip,
+              country: card.country
+            }
+          end
+
+          def masked_card(billing_info)
+            MaskedCardDetails.new(
+              last_four: billing_info.last_four
+            )
+          end
+
+          def account_status(subscription, card_details)
+            AccountStatus.new(
+              plan_id: subscription.plan.plan_code,
+              card_details: card_details,
+              next_billing_date: subscription.current_period_ends_at.to_date,
+              non_renewing: subscription.state == 'canceled',
+              active: subscription.state == 'active')
+          end
+
+        end
+      end
+
+      class NoSubscription
+        def initialize(profile)
+          @profile = profile
+        end
+
+        def plan
+          NoPlan.new
+        end
+
+        def update_attributes!(*)
+          # noop
+        end
+
+        def cancel
+          # noop
+        end
+
+        def current_period_ends_at
+          @profile.trial_end_date
+        end
+
+        def state
+          'non-existent'
+        end
+      end
+
+      class NoPlan
+        def plan_code
+          '????'
+        end
+      end
+
+      def upgrade_plan_to(new_plan_code, account_code)
+        new_plan = {
+          plan_code: new_plan_code,
+          timeframe: 'now'
+        }
+        subscription_for_account(account_code).update_attributes! new_plan
+        self
+      rescue Recurly::Resource::Invalid
+        raise InvalidPlanError
+      end
+
+      def subscription_for_account(account_code)
+        account = retrieve_account(account_code)
+        account.subscriptions.first
+      end
+
+      def retrieve_account(account_code)
+        Recurly::Account.find(account_code.to_s)
+      rescue Recurly::Resource::NotFound
+        raise AccountNotFoundError.new(account_code)
+      end
+
+      class Config
+        attr_reader :environment
+
+        def environment=(name)
+          @environment = env(name).configure
+          self
+        end
+
+        def enable_logging
+          require 'logger'
+          Recurly.logger = Logger.new STDOUT
+        end
+
+        private
+
+        def env(name)
+          envs = {
+            test: Test,
+            production: Production
+          }
+          envs.fetch(name).new
+        end
+
+        class Environment
+          def configure
+            Recurly.api_key        = api_key
+            Recurly.js.private_key = js_private_key
+            self
+          end
+        end
+
+        # Production
+        # matt@mattwynne.net
+        # Recurly.api_key = '843cf121e28149309292c9b500e34e1b'
+        # Recurly.js.private_key = 'a716ce2fcc904310b2ace41809ed9eb9'
+        class Production < Environment
+          VariableNotSet = Class.new(StandardError) do
+            def message
+              "Environment variable '#{super}' not set. Other values are: #{ENV.inspect}"
+            end
+          end
+          AttemptToClearProductionData = Class.new(StandardError)
+
+          def clear_test_data
+            raise AttemptToClearProductionData
+          end
+
+          private
+
+          def api_key
+            get_env_var('RECURLY_API_KEY')
+          end
+
+          def js_private_key
+            get_env_var('RECURLY_JS_PRIVATE_KEY')
+          end
+
+          def get_env_var(name)
+            ENV[name] || raise(VariableNotSet.new(name))
+          end
+        end
+
+        # Test
+        # support@relishapp.com / relishapp
+        # Recurly.api_key = '300041d517734cddaa84c705522d7354'
+        # Recurly.js.private_key = '9e052cad35774060ab4003b0c71315d9'
+        class Test < Environment
+
+          def clear_test_data
+            recurly_website.clear_test_data
+          end
+
+          private
+
+          def api_key
+            '300041d517734cddaa84c705522d7354'
+          end
+
+          def js_private_key
+            '9e052cad35774060ab4003b0c71315d9'
+          end
+
+          private
+
+          def recurly_website
+            @recurly_website ||= RecurlyWebsite.new
+          end
+
+          class RecurlyWebsite
+            def clear_test_data
+              require 'capybara/webkit'
+              Capybara.default_wait_time = (ENV['WAIT_FOR_RECURLY'] || 60).to_i
+              puts "Calling Recurly to clear test data..."
+              session.visit('https://relish-test.recurly.com/configuration/test_data')
+              session.execute_script 'window.confirm = function () { return true }'
+              session.click_on 'Delete All Test Data'
+              session.visit 'https://relish-test.recurly.com/accounts'
+              session.assert_no_selector('.account')
+            end
+
+            private
+
+            def session
+              @session ||= begin
+                session = Capybara::Session.new(:webkit)
+                session.visit('https://relish-test.recurly.com/configuration/test_data')
+                session.fill_in 'Email', with: 'support@relishapp.com'
+                session.fill_in 'Password', with: 'relishapp'
+                session.click_button 'Log In'
+                session
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end