recurly 0.4.16 → 2.0.0

data/lib/recurly/verification.rb

@@ -1,83 +0,0 @@
-module Recurly
-  module Verification
-
-    def stringify_keys data
-      Hash[data.map { |k, v| [k.to_s, v] }]
-    end
-
-    class PreEscapedString < String
-    end
-
-    def digest_data(data) 
-      if data.is_a? Array
-        return nil if data.empty?
-        PreEscapedString.new( '[%s]' % data.map{|v|digest_data(v)}.compact.join(',') )
-      elsif data.is_a? Hash
-        data = stringify_keys data
-        digest_data data.sort.map {|k,v|
-          prefix = (k =~ /\A\d+\Z/) ? '' : (k.to_s+':')
-          (v=digest_data(v)).nil? ? nil : PreEscapedString.new('%s%s' % [prefix,v])
-        }
-      elsif data.is_a?(String) && !data.instance_of?(PreEscapedString)
-        PreEscapedString.new( data.gsub(/([\[\]\,\:\\])/) { |c| '\\' + c } )
-      else
-        data
-      end
-    end
-
-    def generate_signature(claim, args, timestamp=nil)
-      raise Recurly::ConfigurationError.new("Recurly gem not configured. 'private_key' missing.") if Recurly.private_key.blank?
-
-      timestamp ||= Time.now.to_i
-      timestamp = timestamp.to_s
-      input_data = [timestamp,claim,args]
-      input_string = digest_data(input_data)
-
-      digest_key = ::Digest::SHA1.digest(Recurly.private_key)
-      sha1_hash = ::OpenSSL::Digest::Digest.new("sha1")
-      signature = ::OpenSSL::HMAC.hexdigest(sha1_hash, digest_key, input_string.to_s)
-      signature + '-' + timestamp
-    end
-
-    # Raises a Recurly::ForgedQueryString exception if the signature cannot be validated
-    def verify_params!(claim, args)
-      args = stringify_keys args
-      signature = args.delete('signature') or raise Recurly::ForgedQueryString.new('Signature is missing')
-      hmac, timestamp = signature.split('-')
-      age = Time.now.to_i - timestamp.to_i
-      raise Recurly::ForgedQueryString.new('Timestamp is too old or new') if age > 3600 || age < -3600
-
-      if signature != generate_signature(claim, args, timestamp)
-        raise Recurly::ForgedQueryString.new('Signature cannot be verified')
-      end
-    end
-
-    def sign_billing_info_update(account_code)
-      generate_signature('billinginfoupdate', {
-        :account_code => account_code
-      })
-    end
-
-    def sign_transaction(amount_in_cents, currency, account_code=nil)
-      generate_signature('transactioncreate', {
-        :account_code => account_code,
-        :currency => currency,
-        :amount_in_cents => amount_in_cents
-      }) 
-    end
-
-    def verify_subscription!(params)
-      verify_params! 'subscriptioncreated', params
-    end
-
-    def verify_transaction!(params)
-      verify_params! 'transactioncreated', params
-    end
-
-    def verify_billing_info_update!(params)
-      verify_params! 'billinginfoupdated', params
-    end
-
-    extend self
-  end
-end

data/spec/config/recurly.yml

@@ -1,6 +0,0 @@
----
-username: api-test@litle.com
-password: 6499f1cd3ae14875beb91417d31e91b7
-private_key: 78753d36439c423aba60e581be828a2a
-subdomain: litle-test
-environment: :development

data/spec/config/test1.yml

@@ -1,4 +0,0 @@
----
-api_key: asdf4jk31
-subdomain: site1
-private_key: asdfasdfasdf

data/spec/config/test2.yml

@@ -1,7 +0,0 @@
-development:
-  api_key: asdf4jk31
-  subdomain: site1
-
-test:
-  api_key: asdf4jk32
-  subdomain: site2

data/spec/integration/account_spec.rb

@@ -1,286 +0,0 @@
-require 'spec_helper'
-
-module Recurly
-  describe Account do
-    timestamp = File.mtime(__FILE__).to_i
-
-    describe "#new" do
-      let(:attributes) { Factory.account_attributes("account-new-#{timestamp}") }
-      before(:each) do
-        @account = Account.new(attributes)
-      end
-
-      it "should be valid" do
-        @account.should be_valid
-      end
-      
-      it "should not be persisted" do
-        @account.should_not be_persisted
-      end
-
-      it "should set the attributes correctly" do
-        attributes.each do |key, val|
-          @account.attributes[key].should == val
-        end
-      end
-    end
-
-    describe "#create" do
-      context "with full data" do
-        use_vcr_cassette "account/create/#{timestamp}"
-
-        let(:attributes) { Factory.account_attributes("account-create-#{timestamp}") }
-        before(:each) do
-          @account = Account.create(attributes)
-        end
-
-        it "should be persisted" do
-          @account.should be_persisted
-        end
-
-        it "should be valid" do
-          @account.should be_valid
-        end
-
-        it "should set a created_at date from the server" do
-          @account.created_at.should_not be_nil
-        end
-
-        it "should set a hosted_login_token from the server" do
-          @account.hosted_login_token.should_not be_nil
-        end
-
-        it "should set the balance to 0" do
-          @account.balance_in_cents.should == 0
-        end
-
-        it "should set the account status to active" do
-          @account.state.should == "active"
-          @account.closed?.should be_false
-        end
-      end
-
-      context "with just account-code" do
-        use_vcr_cassette "account/create-min/#{timestamp}"
-
-        before(:each) do
-          @account = Account.create(:account_code => "d00d-#{timestamp}")
-        end
-
-        it "should be valid" do
-          @account.should be_valid
-        end
-
-        it "should set a created_at date from the server" do
-          @account.created_at.should_not be_nil
-        end
-
-      end
-    end
-
-    describe "#find" do
-      use_vcr_cassette "account/find/#{timestamp}"
-      let(:orig){ Factory.create_account("account-get-#{timestamp}") }
-
-      before(:each) do
-        @account = Account.find(orig.account_code)
-      end
-
-      it "should return the account object" do
-        @account.should_not be_nil
-      end
-
-      it "should be persisted" do
-        @account.should be_persisted
-      end
-
-      describe "returned account" do
-        it "should have a created_at date" do
-          @account.created_at.should_not be_nil
-        end
-
-        it "should match the original account code" do
-          @account.account_code.should == orig.account_code
-        end
-
-        it "should match the original account email" do
-          @account.email.should == orig.email
-        end
-
-        it "should match the original first name" do
-          @account.first_name.should == orig.first_name
-        end
-      end
-
-      context "looking for a non-existant account" do
-        it "should raise an ActiveResource::ResourceNotFound exception" do
-          expect {
-            Account.find('account-that-doesnt-exist')
-          }.to raise_error ActiveResource::ResourceNotFound
-        end
-      end
-    end
-
-
-    # spec list queries for finding acocunts
-    describe "#list" do
-      use_vcr_cassette "account/list/#{timestamp}"
-
-      before(:each) do
-
-        # create new ones
-        @accounts = []
-        8.times do |i|
-          @accounts << Factory.create_account("account-list-num-#{i}-#{timestamp}")
-        end
-
-        # mark the 4 of them as paid
-        @subscriptions = []
-        @accounts[0, 4].each do |account|
-          @subscriptions << Factory.create_subscription(account, :paid)
-        end
-      end
-
-      it "should return a list of accounts with matching criteria" do
-        Account.list(:all).total_entries.should >= 8
-        Account.list(:active).total_entries.should >= 4
-        Account.list(:free).total_entries.should >= 4
-      end
-
-    end
-
-
-    describe "#update" do
-      use_vcr_cassette "account/update/#{timestamp}"
-
-      let(:orig){ Factory.create_account("account-update-#{timestamp}") }
-
-      before(:each) do
-        # update account data
-        @account = Account.find(orig.account_code)
-        @account.last_name = "Update Test"
-        @account.company_name = "Recurly Ruby Gem -- Update"
-        @account.save!
-
-        # refetch account
-        @account = Account.find(orig.account_code)
-      end
-
-      it "should not have updated the email address" do
-        @account.email.should == orig.email
-      end
-
-      it "should have updated the last_name" do
-        @account.last_name.should == "Update Test"
-      end
-
-      it "should have updated the company_name" do
-        @account.company_name.should == "Recurly Ruby Gem -- Update"
-      end
-    end
-
-    # EDITING ACCOUNT_CODE NOT YET SUPPORTED ON RECURLY API
-    # describe "#update with account_code" do
-    #   use_vcr_cassette "account/update2/#{timestamp}"
-    #
-    #   let(:orig){ Factory.create_account("account-update2-#{timestamp}") }
-    #
-    #   let(:new_account_code){ "#{orig.account_code}-edited" }
-    #
-    #   before(:each) do
-    #     # update account data
-    #     @account = Account.find(orig.account_code)
-    #     @account.account_code = new_account_code
-    #     @account.save!
-    #
-    #     @account = Account.find(new_account_code)
-    #   end
-    #
-    #   it "should update the account code" do
-    #     @account.account_code.should == new_account_code
-    #   end
-    # end
-
-    describe "#close_account" do
-      use_vcr_cassette "account/close/#{timestamp}"
-      let(:account){ Factory.create_account("account-close-#{timestamp}") }
-
-      before(:each) do
-        account.close_account
-
-        # load a fresh account
-        @account = Account.find(account.account_code)
-      end
-
-      it "should mark the account as closed" do
-        @account.state.should == "closed"
-        @account.closed?.should be_true
-      end
-    end
-
-    describe "validations" do
-      context "with blank data" do
-        use_vcr_cassette "account/create-blank/#{timestamp}"
-
-        before(:each) do
-          @account = Account.create({:account_code => ""})
-        end
-
-        it "should not be valid" do
-          @account.should_not be_valid
-        end
-
-        it "should require setting an account code" do
-          @account.errors[:account_code].should include("can't be blank")
-          @account.errors[:account_code].should include("is invalid")
-        end
-      end
-
-      context "with duplicate data" do
-        use_vcr_cassette "account/create-duplicate/#{timestamp}"
-
-        before(:each) do
-          Account.create({:account_code => "account-exists"})
-          @account = Account.create({:account_code => "account-exists"})
-        end
-
-        it "should not be valid" do
-          @account.should_not be_valid
-        end
-
-        it "should require setting an account code" do
-          @account.errors[:account_code].should include("has already been taken")
-        end
-      end
-    end
-
-    describe "defaulting account's accept_language to Recurly.current_accept_language" do
-
-      context "user is from france" do
-        # wrap these example runs, setting current_accept_language properly
-        around(:each) do |example|
-          old_setting = Recurly.current_accept_language
-          Recurly.current_accept_language = "fr"
-          example.run
-          Recurly.current_accept_language = old_setting
-        end
-
-        context "user creates an account" do
-          use_vcr_cassette "account/accept-language-account/#{timestamp}"
-          let(:attributes) { Factory.account_attributes("account1-french-#{timestamp}") }
-
-          before(:each) do
-            @account = Account.create(attributes)
-          end
-
-          it "should automaticaly set the accounts accept_language" do
-            @account.attributes[:accept_language].should == "fr"
-          end
-        end
-
-      end
-
-    end
-
-  end
-end

data/spec/integration/add_on_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-module Recurly
-  describe "Subscription Addons" do
-    # version accounts based on this current files modification dates
-    timestamp = File.mtime(__FILE__).to_i
-
-    describe "create a subscription with addons" do
-      use_vcr_cassette "subscription/addons/create/#{timestamp}"
-
-      let(:account){ Factory.create_account("subscription-addons-create-#{timestamp}") }
-
-      before(:each) do
-        Factory.create_subscription(account, :paid, :add_ons => [
-          {
-            :add_on_code => "special",
-            :quantity => 1,
-            :unit_amount => 10,
-          }
-        ])
-      end
-
-      it "should return the subscription addons" do
-        subscription = Subscription.find(account.account_code)
-        subscription.add_ons.count == 1
-      end
-    end
-
-    describe "add an addon to a subscription" do
-      use_vcr_cassette "subscription/addons/add/#{timestamp}"
-
-      let(:account){ Factory.create_account("subscription-addons-add-#{timestamp}") }
-
-      before(:each) do
-        Factory.create_subscription(account, :paid, :add_ons => [
-          {
-            :add_on_code => "special",
-            :quantity => 1,
-            :unit_amount => 10,
-          }
-        ])
-      end
-
-      it "should allow adding a new addon" do
-        subscription = Subscription.find(account.account_code)
-        subscription.add_ons << {
-          :add_on_code => "special2",
-          :quantity => 2,
-          :unit_amount => 500
-        }
-        subscription.change('now', :add_ons => subscription.add_ons)
-
-        subscription = Subscription.find(account.account_code)
-        subscription.add_ons.count == 2
-      end
-    end
-
-    describe "remove an addon from a subscription" do
-      use_vcr_cassette "subscription/addons/remove/#{timestamp}"
-
-      let(:account){ Factory.create_account("subscription-addons-remove-#{timestamp}") }
-
-      before(:each) do
-        Factory.create_subscription(account, :paid, :add_ons => [
-          {
-            :add_on_code => "special",
-            :quantity => 1,
-            :unit_amount => 1000,
-          }
-        ])
-      end
-
-      it "should allow removing an addon" do
-        subscription = Subscription.find(account.account_code)
-        subscription.change('now', :add_ons => [])
-
-        subscription = Subscription.find(account.account_code)
-        subscription.add_ons.count == 0
-      end
-
-    end
-
-  end
-end