recurly 0.4.16 → 2.0.0

data/spec/unit/coupon_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-module Recurly
-  describe Coupon do
-    context "new record" do
-      subject{Coupon.new}
-
-      it { should respond_to(:coupon_code)}
-      it { should respond_to(:redeemed_at)}
-    end
-
-  end
-end

data/spec/unit/credit_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-module Recurly
-  describe Credit do
-    context "new record" do
-      subject{Credit.new}
-
-      it { should respond_to(:id)}
-      it { should respond_to(:account_code)}
-      it { should respond_to(:quantity)}
-      it { should respond_to(:unit_amount_in_cents)}
-      it { should respond_to(:amount_in_cents)}
-      it { should respond_to(:start_date)}
-      it { should respond_to(:end_date)}
-      it { should respond_to(:description)}
-      it { should respond_to(:created_at)}
-    end
-
-  end
-end

data/spec/unit/plan_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-module Recurly
-  describe Plan do
-    context "new record" do
-      subject{Plan.new}
-
-      it { should respond_to(:plan_code)}
-      it { should respond_to(:name)}
-      it { should respond_to(:description)}
-      it { should respond_to(:success_url)}
-      it { should respond_to(:cancel_url)}
-      it { should respond_to(:created_at)}
-
-    end
-
-  end
-end

data/spec/unit/subscription_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-module Recurly
-  describe Subscription do
-    context "new record" do
-      subject{Subscription.new}
-
-      it { should respond_to(:plan_code)}
-      it { should respond_to(:coupon_code)}
-      it { should respond_to(:unit_amount_in_cents)}
-      it { should respond_to(:quantity)}
-      it { should respond_to(:trial_ends_at)}
-
-      # TODO: embedded account
-
-      # TODO: embedded billing_info
-
-      # TODO: embedded credit_card
-
-      # TODO: embedded addons list
-
-    end
-
-  end
-end

data/spec/unit/transaction_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-module Recurly
-  describe Transaction do
-    context "new record" do
-      subject{Transaction.new}
-
-      it { should respond_to(:id)}
-      it { should respond_to(:account_code)}
-      it { should respond_to(:type)}
-      it { should respond_to(:action)}
-      it { should respond_to(:date)}
-      it { should respond_to(:amount_in_cents)}
-      it { should respond_to(:status)}
-      it { should respond_to(:message)}
-      it { should respond_to(:reference)}
-      it { should respond_to(:ccv_result)}
-      it { should respond_to(:avs_result)}
-      it { should respond_to(:avs_result_street)}
-      it { should respond_to(:avs_result_postal)}
-      it { should respond_to(:test)}
-      it { should respond_to(:voidable)}
-      it { should respond_to(:refundable)}
-
-      # TODO: embedded account
-      # TODO: embedded billing_info
-      # TODO: embedded credit_card
-
-    end
-
-  end
-end

data/spec/unit/transparent_spec.rb

@@ -1,152 +0,0 @@
-require 'spec_helper'
-
-module Recurly
-  describe Transparent do
-    before(:each) do
-      Recurly.configure_from_yaml("#{File.dirname(__FILE__)}/../config/recurly.yml")
-    end
-
-    describe ".url" do
-      it "should return the url for the configured Recurly site" do
-        Transparent.url.should == "#{Recurly::Base.site}/transparent/#{Recurly.subdomain}/subscription"
-      end
-
-      it "should allow passing in the type of action" do
-        Transparent.url(Action::CreateSubscription).should == "#{Recurly::Base.site}/transparent/#{Recurly.subdomain}/subscription"
-        Transparent.url(Action::UpdateBilling).should == "#{Recurly::Base.site}/transparent/#{Recurly.subdomain}/billing_info"
-        Transparent.url(Action::CreateTransaction).should == "#{Recurly::Base.site}/transparent/#{Recurly.subdomain}/transaction"
-      end
-    end
-
-    describe ".encrypt_string" do
-      it "should encrypt the data using the configured private key" do
-        Recurly.configure do |config|
-          config.private_key = '986bfa2bec61479ca560dbaaec345820'
-        end
-        result = Transparent.encrypt_string("d00d")
-
-        # hashed manually
-        result.should == "790a4038fb9047889a767baadf8edc3e07b6e66b"
-
-        result2 = Transparent.encrypt_string("d00d2")
-        result2.should_not eq(result)
-
-        result3 = Transparent.encrypt_string("d00d")
-        result3.should eq(result)
-      end
-    end
-
-    describe "#encoded_data" do
-      it "should return a data string for use within an input hidden field" do
-
-        transparent = Transparent.new({
-          :redirect_url => "http://example.com/",
-          :account => { :account_code => 'howdy' },
-          :value => "hello"
-        })
-
-        query_string = Transparent.query_string({
-          :redirect_url => "http://example.com/",
-          :account => { :account_code => 'howdy' },
-          :value => "hello"
-        })
-
-        transparent.encoded_data.split("|").last.should eq(query_string)
-      end
-
-      it "should allow fixnums" do
-        transparent = Transparent.new({
-          :redirect_url => "http://example.com/",
-          :account => { :account_code => '123' },
-          :amount => 10
-        })
-
-        query_string = Transparent.query_string({
-          :redirect_url => "http://example.com/",
-          :account => { :account_code => '123' },
-          :amount => 10
-        })
-
-        transparent.encoded_data.split("|").last.should == query_string
-      end
-
-      it "should allow nested fixnums" do
-        transparent = Transparent.new({
-          :redirect_url => "http://example.com/",
-          :account => { :account_code => '123' },
-          :transaction => {
-            :amount => 10
-          }
-        })
-
-        query_string = Transparent.query_string({
-          :redirect_url => "http://example.com/",
-          :account => { :account_code => '123' },
-          :transaction => {
-            :amount => 10
-          }
-        })
-
-        transparent.encoded_data.split("|").last.should == query_string
-      end
-
-      it "should prepend the validation string" do
-        transparent = Transparent.new({
-          :redirect_url => "http://example.com/",
-          :account => { :account_code => '123' },
-          :transaction => {
-            :amount => 10
-          }
-        })
-
-        query_string = Transparent.query_string({
-          :redirect_url => "http://example.com/",
-          :account => { :account_code => '123' },
-          :transaction => {
-            :amount => 10
-          }
-        })
-
-        validation_string = Transparent.encrypt_string(query_string)
-
-        transparent.encoded_data.split("|").first.should == validation_string
-      end
-    end
-
-    describe "#hidden_field" do
-      it "should return a string of a HTML hidden input element" do
-
-        transparent = Transparent.new({
-          :redirect_url => "http://example.com/",
-          :account => { :account_code => 'howdy' },
-          :value => "hello"
-        })
-
-        transparent.hidden_field.class.should eq(String)
-      end
-
-      it "should return a string of a HTML hidden input element" do
-        transparent = Transparent.new({
-          :redirect_url => "http://example.com/",
-          :account => { :account_code => '123' },
-          :amount => 10
-        })
-
-        transparent.hidden_field.class.should eq(String)
-      end
-
-      it "should return a string of a HTML hidden input element" do
-        transparent = Transparent.new({
-          :redirect_url => "http://example.com/",
-          :account => { :account_code => '123' },
-          :transaction => {
-            :amount => 10
-          }
-        })
-
-        transparent.hidden_field.class.should eq(String)
-      end
-    end
-
-  end
-end

data/spec/unit/verification_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-module Recurly
-  describe Verification do
-    origin_time = 1312806801
-    test_sig = 'fb5194a51aa97996cdb995a89064764c5c1bfd93-1312806801'
-
-    before(:each) do
-      Recurly.configure_from_yaml("#{File.dirname(__FILE__)}/../config/recurly.yml")
-      Recurly::private_key = '0123456789abcdef0123456789abcdef' # Used for testing
-    end
-
-    it "should ignore empty arrays, hashes, strings, and nil" do
-      Verification::digest_data([
-        [], {}, '', nil
-      ]).should == '[]'
-    end
-
-    it "should encode nested arrays and hashes" do
-      Verification::digest_data( 
-        {:a => [1,2,3], :b => {:c => '123', :d => '456'}}
-      ).should == '[a:[1,2,3],b:[c:123,d:456]]'
-    end
-
-    it "should alphabetize keys" do
-      Verification::digest_data( 
-        {:a => 1, :c => 3, :b => 2}
-      ).should == '[a:1,b:2,c:3]'
-    end
-
-    it "should treat hashes with numeric indexes as arrays" do
-      Verification::digest_data( 
-        {'1' => 4, '2' => 5, '3' => 6}
-      ).should == '[4,5,6]'
-    end
-
-    it "should escape syntax characters" do
-      Verification::digest_data(
-        { :syntaxchars =>  ' \\ [ ] : , '}
-      ).should == '[syntaxchars: \\\\ \[ \] \: \, ]'
-    end
-
-    it "should generate proper signatures" do
-      Time.stub!(:now).and_return(origin_time) # gen at origin time
-      sig = Verification.generate_signature('update',{ :a => 'foo', :b => 'bar'})
-      sig.should == test_sig
-    end
-
-    it "should validate proper signatures" do
-      Time.stub!(:now).and_return(Time.at(origin_time+60)) # one minute passed
-      lambda {
-        good = Verification.verify_params!('update',
-                           { :a => 'foo', :b => 'bar', :signature => test_sig})
-      }.should_not raise_error
-    end
-
-    it "should reject invalid signature" do
-      Time.stub!(:now).and_return(Time.at(origin_time+60)) # one minute passed
-      lambda {
-        good = Verification.verify_params!('update',
-                           { :a => 'foo', :b => 'bar', :signature => 'badsig'})
-      }.should raise_error(Recurly::ForgedQueryString)
-    end
-
-    it "should reject expired signature" do
-      Time.stub!(:now).and_return(Time.at(origin_time+7200)) # two hours passed
-      lambda {
-        good = Verification.verify_params!('update',
-                           { :a => 'foo', :b => 'bar', :signature => test_sig})
-      }.should raise_error(Recurly::ForgedQueryString)
-    end
-
-    it "should reject time traveling signatures from the future (with 1 hour grace period)" do
-      Time.stub!(:now).and_return(Time.at(origin_time-7200)) # two hours earlier
-      lambda {
-        good = Verification.verify_params!('update',
-                           { :a => 'foo', :b => 'bar', :signature => test_sig})
-      }.should raise_error(Recurly::ForgedQueryString)
-    end
-  end
-
-end