mustwin-stripe-ruby-mock 1.8.4.10

data/lib/stripe_mock/api/debug.rb

@@ -0,0 +1,11 @@
+module StripeMock
+
+  def self.toggle_debug(toggle)
+    if @state == 'local'
+      @instance.debug = toggle
+    elsif @state == 'remote'
+      @client.set_server_debug(toggle)
+    end
+  end
+
+end

data/lib/stripe_mock/api/errors.rb

@@ -0,0 +1,41 @@
+module StripeMock
+
+  def self.prepare_error(stripe_error, *handler_names)
+    handler_names.push(:all) if handler_names.count == 0
+
+    if @state == 'local'
+      instance.error_queue.queue(stripe_error, handler_names)
+    elsif @state == 'remote'
+      client.error_queue.queue(stripe_error, handler_names)
+    else
+      raise UnstartedStateError
+    end
+  end
+
+  def self.prepare_card_error(code, *handler_names)
+    handler_names.push(:new_charge) if handler_names.count == 0
+
+    args = CardErrors.argument_map[code]
+    raise StripeMockError.new("Unrecognized stripe card error code: #{code}") if args.nil?
+    self.prepare_error  Stripe::CardError.new(*args), *handler_names
+  end
+
+  module CardErrors
+
+    def self.argument_map
+      @__map ||= {
+        incorrect_number: ["The card number is incorrect", 'number', 'incorrect_number', 402],
+        invalid_number: ["The card number is not a valid credit card number", 'number', 'invalid_number', 402],
+        invalid_expiry_month: ["The card's expiration month is invalid", 'exp_month', 'invalid_expiry_month', 402],
+        invalid_expiry_year: ["The card's expiration year is invalid", 'exp_year', 'invalid_expiry_year', 402],
+        invalid_cvc: ["The card's security code is invalid", 'cvc', 'invalid_cvc', 402],
+        expired_card: ["The card has expired", 'exp_month', 'expired_card', 402],
+        incorrect_cvc: ["The card's security code is incorrect", 'cvc', 'incorrect_cvc', 402],
+        card_declined: ["The card was declined", nil, 'card_declined', 402],
+        missing: ["There is no card on a customer that is being charged.", nil, 'missing', 402],
+        processing_error: ["An error occurred while processing the card", nil, 'processing_error', 402],
+      }
+    end
+  end
+
+end

data/lib/stripe_mock/api/instance.rb

@@ -0,0 +1,27 @@
+module StripeMock
+
+  @state = 'ready'
+  @instance = nil
+  @original_request_method = Stripe.method(:request)
+
+  def self.start
+    @instance = Instance.new
+    alias_stripe_method :request, @instance.method(:mock_request)
+    @state = 'local'
+  end
+
+  def self.stop
+    return unless @state == 'local'
+    alias_stripe_method :request, @original_request_method
+    @instance = nil
+    @state = 'ready'
+  end
+
+  def self.alias_stripe_method(new_name, method_object)
+    Stripe.define_singleton_method(new_name) {|*args| method_object.call(*args) }
+  end
+
+  def self.instance; @instance; end
+  def self.state; @state; end
+
+end

data/lib/stripe_mock/api/server.rb

@@ -0,0 +1,24 @@
+module StripeMock
+
+  @default_pid_path = './stripe-mock-server.pid'
+
+  def self.default_server_pid_path; @default_pid_path; end
+  def self.default_server_pid_path=(new_path)
+    @default_pid_path = new_path
+  end
+
+
+  def self.spawn_server(opts={})
+    pid_path = opts[:pid_path] || @default_pid_path
+    Dante::Runner.new('stripe-mock-server').execute(:daemonize => true, :pid_path => pid_path) {
+      StripeMock::Server.start_new(opts)
+    }
+    at_exit { kill_server(pid_path) }
+  end
+
+  def self.kill_server(pid_path=nil)
+    path = pid_path || @default_pid_path
+    Dante::Runner.new('stripe-mock-server').execute(:kill => true, :pid_path => path)
+  end
+
+end

data/lib/stripe_mock/api/strict.rb

@@ -0,0 +1,11 @@
+module StripeMock
+
+  def self.toggle_strict(toggle)
+    if @state == 'local'
+      @instance.strict = toggle
+    elsif @state == 'remote'
+      @client.set_server_strict(toggle)
+    end
+  end
+
+end

data/lib/stripe_mock/api/webhooks.rb

@@ -0,0 +1,64 @@
+module StripeMock
+
+  def self.mock_webhook_event(type, params={})
+
+    fixture_file = File.join(@webhook_fixture_path, "#{type}.json")
+
+    if File.exists?(fixture_file) == false
+      unless Webhooks.event_list.include?(type)
+        raise UnsupportedRequestError.new "Unsupported webhook event `#{type}` (Searched in #{@webhook_fixture_path})"
+      end
+      fixture_file = File.join(@webhook_fixture_fallback_path, "#{type}.json")
+    end
+
+    json = MultiJson.load  File.read(fixture_file)
+
+    json = Stripe::Util.symbolize_names(json)
+    params = Stripe::Util.symbolize_names(params)
+    json[:data][:object] = Util.rmerge(json[:data][:object], params)
+
+    Stripe::Event.construct_from(json)
+  end
+
+  module Webhooks
+    def self.event_list
+      @__list = [
+        'account.updated',
+        'account.application.deauthorized',
+        'charge.succeeded',
+        'charge.failed',
+        'charge.refunded',
+        'charge.dispute.created',
+        'charge.dispute.updated',
+        'charge.dispute.closed',
+        'customer.created',
+        'customer.updated',
+        'customer.deleted',
+        'customer.subscription.created',
+        'customer.subscription.updated',
+        'customer.subscription.deleted',
+        'customer.subscription.trial_will_end',
+        'customer.discount.created',
+        'customer.discount.updated',
+        'customer.discount.deleted',
+        'invoice.created',
+        'invoice.updated',
+        'invoice.payment_succeeded',
+        'invoice.payment_failed',
+        'invoiceitem.created',
+        'invoiceitem.updated',
+        'invoiceitem.deleted',
+        'plan.created',
+        'plan.updated',
+        'plan.deleted',
+        'coupon.created',
+        'coupon.deleted',
+        'transfer.created',
+        'transfer.paid',
+        'transfer.updated',
+        'transfer.failed'
+      ]
+    end
+  end
+
+end

data/lib/stripe_mock/client.rb

@@ -0,0 +1,84 @@
+module StripeMock
+
+  class Client
+    attr_reader :port, :state, :error_queue
+
+    def initialize(port)
+      @port = port
+      @pipe = Jimson::Client.new("http://0.0.0.0:#{port}")
+      # Ensure client can connect to server
+      timeout_wrap { @pipe.ping }
+      @state = 'ready'
+      @error_queue = ErrorQueue.new
+    end
+
+    def mock_request(method, url, api_key, params={}, headers={})
+      timeout_wrap do
+        @pipe.mock_request(method, url, api_key, params, headers).tap {|result|
+          response, api_key = result
+          if response.is_a?(Hash) && response['error_raised'] == 'invalid_request'
+            raise Stripe::InvalidRequestError.new(*response['error_params'])
+          end
+        }
+      end
+    end
+
+    def get_server_data(key)
+      timeout_wrap {
+        # Massage the data make this behave the same as the local StripeMock.start
+        result = {}
+        @pipe.get_data(key).each {|k,v| result[k] = Stripe::Util.symbolize_names(v) }
+        result
+      }
+    end
+
+    def set_server_debug(toggle)
+      timeout_wrap { @pipe.set_debug(toggle) }
+    end
+
+    def server_debug?
+      timeout_wrap { @pipe.debug? }
+    end
+
+    def set_server_strict(toggle)
+      timeout_wrap { @pipe.set_strict(toggle) }
+    end
+
+    def server_strict?
+      timeout_wrap { @pipe.strict? }
+    end
+
+    def generate_recipient_token(recipient_params)
+      timeout_wrap { @pipe.generate_recipient_token(recipient_params) }
+    end
+
+    def generate_card_token(card_params)
+      timeout_wrap { @pipe.generate_card_token(card_params) }
+    end
+
+    def clear_server_data
+      timeout_wrap { @pipe.clear_data }
+    end
+
+    def close!
+      self.cleanup
+      StripeMock.stop_client(:clear_server_data => false)
+    end
+
+    def cleanup
+      return if @state == 'closed'
+      set_server_debug(false)
+      @state = 'closed'
+    end
+
+    def timeout_wrap
+      raise ClosedClientConnectionError if @state == 'closed'
+      yield
+    rescue ClosedClientConnectionError
+      raise
+    rescue Errno::ECONNREFUSED => e
+      raise StripeMock::ServerTimeoutError.new(e)
+    end
+  end
+
+end

data/lib/stripe_mock/data.rb

@@ -0,0 +1,317 @@
+module StripeMock
+  module Data
+
+    def self.mock_customer(cards, params)
+      cus_id = params[:id] || "test_cus_default"
+      cards.each {|card| card[:customer] = cus_id}
+      {
+        email: 'stripe_mock@example.com',
+        description: 'an auto-generated stripe customer data mock',
+        object: "customer",
+        created: 1372126710,
+        id: cus_id,
+        livemode: false,
+        delinquent: false,
+        subscription: nil,
+        discount: nil,
+        account_balance: 0,
+        cards: {
+          object: "list",
+          count: cards.count,
+          url: "/v1/customers/#{cus_id}/cards",
+          data: cards
+        },
+        default_card: nil
+      }.merge(params)
+    end
+
+    def self.mock_charge(params={})
+      {
+        id: "ch_1fD6uiR9FAA2zc",
+        object: "charge",
+        created: 1366194027,
+        livemode: false,
+        paid: true,
+        amount: 0,
+        currency: "usd",
+        refunded: false,
+        fee: 0,
+        fee_details: [
+        ],
+        card: {
+          object: "card",
+          last4: "4242",
+          type: "Visa",
+          exp_month: 12,
+          exp_year: 2013,
+          fingerprint: "3TQGpK9JoY1GgXPw",
+          country: "US",
+          name: "name",
+          address_line1: nil,
+          address_line2: nil,
+          address_city: nil,
+          address_state: nil,
+          address_zip: nil,
+          address_country: nil,
+          cvc_check: nil,
+          address_line1_check: nil,
+          address_zip_check: nil
+        },
+        captured: params.has_key?(:capture) ? params.delete(:capture) : true,
+        failure_message: nil,
+        amount_refunded: 0,
+        customer: nil,
+        invoice: nil,
+        description: nil,
+        dispute: nil
+      }.merge(params)
+    end
+
+    def self.mock_charge_array
+      {
+        :data => [test_charge, test_charge, test_charge],
+        :object => 'list',
+        :url => '/v1/charges'
+      }
+    end
+
+    def self.mock_card(params={})
+      {
+        id: "test_cc_default",
+        object: "card",
+        last4: "4242",
+        type: "Visa",
+        exp_month: 4,
+        exp_year: 2016,
+        fingerprint: "wXWJT135mEK107G8",
+        customer: "test_cus_default",
+        country: "US",
+        name: "Johnny App",
+        address_line1: nil,
+        address_line2: nil,
+        address_city: nil,
+        address_state: nil,
+        address_zip: nil,
+        address_country: nil,
+        cvc_check: nil,
+        address_line1_check: nil,
+        address_zip_check: nil
+      }.merge(params)
+    end
+
+    def self.mock_coupon(params={})
+      {
+        :duration => 'repeating',
+        :duration_in_months => 3,
+        :percent_off => 25,
+        :id => "co_test_coupon",
+        :object => "coupon"
+      }.merge(params)
+    end
+
+    #FIXME nested overrides would be better than hardcoding plan_id
+    def self.mock_subscription(params={})
+      StripeMock::Util.rmerge({
+        :current_period_end => 1308681468,
+        :status => "trialing",
+        :plan => {
+          :interval => "month",
+          :amount => 7500,
+          :trial_period_days => 30,
+          :object => "plan",
+          :id => '__test_plan_id__'
+        },
+        :current_period_start => 1308595038,
+        :cancel_at_period_end => false,
+        :canceled_at => nil,
+        :start => 1308595038,
+        :object => "subscription",
+        :trial_start => 1308595038,
+        :trial_end => 1308681468,
+        :customer => "c_test_customer",
+        :quantity => 1
+      }, params)
+    end
+
+    def self.mock_invoice(params={})
+      {
+        :id => 'in_test_invoice',
+        :object => 'invoice',
+        :livemode => false,
+        :amount_due => 1000,
+        :attempt_count => 0,
+        :attempted => false,
+        :closed => false,
+        :currency => 'usd',
+        :customer => 'c_test_customer',
+        :date => 1349738950,
+        :lines => {
+          "invoiceitems" => [
+            {
+              :id => 'ii_test_invoice_item',
+              :object => '',
+              :livemode => false,
+              :amount => 1000,
+              :currency => 'usd',
+              :customer => 'c_test_customer',
+              :date => 1349738950,
+              :description => "A Test Invoice Item",
+              :invoice => 'in_test_invoice'
+            },
+          ],
+        },
+        :paid => false,
+        :period_end => 1349738950,
+        :period_start => 1349738950,
+        :starting_balance => 0,
+        :subtotal => 1000,
+        :total => 1000,
+        :charge => nil,
+        :discount => nil,
+        :ending_balance => nil,
+        :next_payemnt_attempt => 1349825350,
+      }.merge(params)
+    end
+
+    def self.mock_paid_invoice
+      test_invoice.merge({
+          :attempt_count => 1,
+          :attempted => true,
+          :closed => true,
+          :paid => true,
+          :charge => 'ch_test_charge',
+          :ending_balance => 0,
+          :next_payment_attempt => nil,
+        })
+    end
+
+    def self.mock_invoice_customer_array
+      {
+        :data => [test_invoice],
+        :object => 'list',
+        :url => '/v1/invoices?customer=test_customer'
+      }
+    end
+
+    def self.mock_plan(params={})
+      {
+        interval: "month",
+        name: "The Basic Plan",
+        amount: 2300,
+        currency: "usd",
+        id: "2",
+        object: "plan",
+        livemode: false,
+        interval_count: 1,
+        trial_period_days: nil
+      }.merge(params)
+    end
+
+    def self.mock_recipient(params={})
+      {
+        :name => "Stripe User",
+        :type => "individual",
+        :livemode => false,
+        :object => "recipient",
+        :id => "rp_test_recipient",
+        :active_account => {
+          :last4 => "6789",
+          :bank_name => "STRIPE TEST BANK",
+          :country => "US",
+          :object => "bank_account"
+        },
+        :created => 1304114758,
+        :verified => true
+      }.merge(params)
+    end
+
+    def self.mock_recipient_array
+      {
+        :data => [test_recipient, test_recipient, test_recipient],
+        :object => 'list',
+        :url => '/v1/recipients'
+      }
+    end
+
+    def self.mock_transfer(params={})
+      {
+        :status => 'pending',
+        :amount => 100,
+        :account => {
+          :object => 'bank_account',
+          :country => 'US',
+          :bank_name => 'STRIPE TEST BANK',
+          :last4 => '6789'
+        },
+        :recipient => 'test_recipient',
+        :fee => 0,
+        :fee_details => [],
+        :id => "tr_test_transfer",
+        :livemode => false,
+        :currency => "usd",
+        :object => "transfer",
+        :date => 1304114826
+      }.merge(params)
+    end
+
+    def self.mock_transfer_array
+      {
+        :data => [test_transfer, test_transfer, test_transfer],
+        :object => 'list',
+        :url => '/v1/transfers'
+      }
+    end
+
+    def self.mock_invalid_api_key_error
+      {
+        "error" => {
+          "type" => "invalid_request_error",
+          "message" => "Invalid API Key provided: invalid"
+        }
+      }
+    end
+
+    def self.mock_invalid_exp_year_error
+      {
+        "error" => {
+          "code" => "invalid_expiry_year",
+          "param" => "exp_year",
+          "type" => "card_error",
+          "message" => "Your card's expiration year is invalid"
+        }
+      }
+    end
+
+    def self.mock_missing_id_error
+      {
+        :error => {
+          :param => "id",
+          :type => "invalid_request_error",
+          :message => "Missing id"
+        }
+      }
+    end
+
+    def self.mock_delete_subscription(params={})
+      {
+        deleted: true
+      }.merge(params)
+    end
+
+    def self.mock_api_error
+      {
+        :error => {
+          :type => "api_error"
+        }
+      }
+    end
+
+    def self.mock_delete_discount_response
+      {
+        :deleted => true,
+        :id => "di_test_coupon"
+      }
+    end
+
+  end
+end