braintree 1.0.0

data/spec/unit/braintree/credit_card_verification_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::CreditCardVerification do
+  describe "inspect" do
+    it "is better than the default inspect" do
+      verification = Braintree::CreditCardVerification._new(
+        :status => "verified",
+        :avs_error_response_code => "I",
+        :avs_postal_code_response_code => "I",
+        :avs_street_address_response_code => "I",
+        :cvv_response_code => "I"
+      )
+      verification.inspect.should == %(#<Braintree::CreditCardVerification status: "verified", cvv_response_code: "I", avs_error_response_code: "I", avs_postal_code_response_code: "I", avs_street_address_response_code: "I">)
+    end
+  end
+end
+

data/spec/unit/braintree/customer_spec.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::Customer do
+  describe "inspect" do
+    it "includes the id first" do
+      output = Braintree::Customer._new({:first_name => 'Dan', :id => '1234'}).inspect
+      output.should include("#<Braintree::Customer id: \"1234\",")
+    end
+    
+    it "includes all customer attributes" do
+      customer = Braintree::Customer._new(
+        :company => "Company",
+        :email => "e@mail.com",
+        :fax => "483-438-5821",
+        :first_name => "Patrick",
+        :last_name => "Smith",
+        :phone => "802-483-5932",
+        :website => "patrick.smith.com",
+        :created_at => Time.now,
+        :updated_at => Time.now
+      )
+      output = customer.inspect
+      output.should include(%q(company: "Company"))
+      output.should include(%q(email: "e@mail.com"))
+      output.should include(%q(fax: "483-438-5821"))
+      output.should include(%q(first_name: "Patrick"))
+      output.should include(%q(last_name: "Smith"))
+      output.should include(%q(phone: "802-483-5932"))
+      output.should include(%q(website: "patrick.smith.com"))
+      output.should include(%Q(created_at: #{customer.created_at.inspect}))
+      output.should include(%Q(updated_at: #{customer.updated_at.inspect}))
+    end
+  end
+    
+  describe "self.create" do
+    it "raises an exception if hash includes an invalid key" do
+      expect do
+        Braintree::Customer.create(:first_name => "Joe", :invalid_key => "foo")
+      end.to raise_error(ArgumentError, "invalid keys: invalid_key")
+    end
+  end
+  
+  describe "self.update" do
+    it "raises an exception if hash includes an invalid key" do
+      expect do
+        Braintree::Customer.update("customer_id", :first_name => "Joe", :invalid_key => "foo")
+      end.to raise_error(ArgumentError, "invalid keys: invalid_key")
+    end
+  end
+
+  describe "self.create_from_transparent_redirect" do
+    it "raises an exception if the query string is forged" do
+      expect do
+        Braintree::Customer.create_from_transparent_redirect("forged=query_string")
+      end.to raise_error(Braintree::ForgedQueryString)
+    end
+  end
+
+  describe "==" do
+    it "returns true when given a customer with the same id" do
+      first = Braintree::Customer._new(:id => 123)
+      second = Braintree::Customer._new(:id => 123)
+      
+      first.should == second
+      second.should == first
+    end
+    
+    it "returns false when given a customer with a different id" do
+      first = Braintree::Customer._new(:id => 123)
+      second = Braintree::Customer._new(:id => 124)
+      
+      first.should_not == second
+      second.should_not == first
+    end
+    
+    it "returns false when not given a customer" do
+      customer = Braintree::Customer._new(:id => 123)
+      customer.should_not == "not a customer"
+    end
+  end
+
+  describe "initialize" do
+    it "converts payment method hashes into payment method objects" do
+      customer = Braintree::Customer._new(
+        :credit_cards => [
+          {:token => "pm1"},
+          {:token => "pm2"}
+        ]
+      )
+      customer.credit_cards.size.should == 2
+      customer.credit_cards[0].token.should == "pm1"
+      customer.credit_cards[1].token.should == "pm2"
+    end
+  end
+  
+  describe "new" do
+    it "is protected" do
+      expect do
+        Braintree::Customer.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+end

data/spec/unit/braintree/digest_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::Digest do
+  describe "self.hexdigest" do
+    it "returns the sha1 hmac of the input string (test case 6 from RFC 2202)" do
+      begin
+        original_key = Braintree::Configuration.private_key
+        Braintree::Configuration.private_key = "\xaa" * 80
+        data = "Test Using Larger Than Block-Size Key - Hash Key First"
+        Braintree::Digest.hexdigest(data).should == "aa4ae5e15272d00e95705637ce8a3b55ed402112"
+      ensure
+        Braintree::Configuration.private_key = original_key
+      end
+    end
+
+    it "returns the sha1 hmac of the input string (test case 7 from RFC 2202)" do
+      begin
+        original_key = Braintree::Configuration.private_key
+        Braintree::Configuration.private_key = "\xaa" * 80
+        data = "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data"
+        Braintree::Digest.hexdigest(data).should == "e8e99d0f45237d786d6bbaa7965c7808bbff1a91"
+      ensure
+        Braintree::Configuration.private_key = original_key
+      end
+    end
+  end
+end
+

data/spec/unit/braintree/error_result_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::ErrorResult do
+  describe "initialize" do
+    it "initializes params and errors" do
+      errors = {
+        :scope => {
+          :errors => [{:code => "123", :message => "something is invalid", :attribute => "something"}]
+        }
+      }
+      result = Braintree::ErrorResult.new(:params => "params", :errors => errors)
+      result.success?.should == false
+      result.params.should == "params"
+      result.errors.size.should == 1
+      result.errors.for(:scope)[0].message.should == "something is invalid"
+      result.errors.for(:scope)[0].attribute.should == "something"
+      result.errors.for(:scope)[0].code.should == "123"
+    end
+
+    it "ignores data other than params and errors" do
+      # so that we can add more data into the response in the future without breaking the client lib
+      expect do
+        result = Braintree::ErrorResult.new(:params => "params", :errors => {:errors => []}, :extra => "is ignored")
+      end.to_not raise_error
+    end
+  end
+
+  describe "inspect" do
+    it "shows errors 2 levels deep" do
+      errors = {
+        :level1 => {
+          :errors => [{:code => "code1", :attribute => "attr", :message => "message"}],
+          :level2 => {
+            :errors => [{:code => "code2", :attribute => "attr2", :message => "message2"}],
+          }
+        }
+      }
+      result = Braintree::ErrorResult.new(:params => "params", :errors => errors)
+      result.inspect.should == "#<Braintree::ErrorResult params:{...} errors:<level1:[(code1) message], level1/level2:[(code2) message2]>>"
+    end
+  end
+end

data/spec/unit/braintree/errors_spec.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::Errors do
+  describe "for" do
+    it "accesses errors for the given scope" do
+      errors = Braintree::Errors.new(
+        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]}
+      )
+      errors.for(:level1).size.should == 1
+      errors.for(:level1)[0].code.should == "code1"
+    end
+
+    it "returns nil if there are no errors at the given scope" do
+      errors = Braintree::Errors.new(
+        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]}
+      )
+      errors.for(:no_errors_here).should == nil
+    end
+  end
+
+  describe "inspect" do
+    it "is better than the default inspect" do
+      errors = Braintree::Errors.new(
+        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]}
+      )
+      errors.inspect.should == "#<Braintree::Errors level1:[(code1) message]>"
+    end
+
+    it "shows errors 2 levels deep" do
+      errors = Braintree::Errors.new(
+        :level1 => {
+          :errors => [{:code => "code1", :attribute => "attr", :message => "message"}],
+          :level2 => {
+            :errors => [{:code => "code2", :attribute => "attr2", :message => "message2"}],
+          }
+        }
+      )
+      errors.inspect.should == "#<Braintree::Errors level1:[(code1) message], level1/level2:[(code2) message2]>"
+    end
+
+    it "shows errors 3 levels deep" do
+      errors = Braintree::Errors.new(
+        :level1 => {
+          :errors => [{:code => "code1", :attribute => "attr", :message => "message"}],
+          :level2 => {
+            :errors => [{:code => "code2", :attribute => "attr2", :message => "message2"}],
+            :level3 => {
+              :errors => [{:code => "code3", :attribute => "attr3", :message => "message3"}],
+            }
+          }
+        }
+      )
+      errors.inspect.should == "#<Braintree::Errors level1:[(code1) message], level1/level2:[(code2) message2], level1/level2/level3:[(code3) message3]>"
+    end
+  end
+
+  describe "size" do
+    it "returns the number of validation errors at the first level if only has one level" do
+      errors = Braintree::Errors.new(
+        :level1 => {:errors => [{:code => "1", :attribute => "attr", :message => "message"}]}
+      )
+      errors.size.should == 1
+    end
+
+    it "returns the total number of validation errors in the hierarchy" do
+      errors = Braintree::Errors.new(
+        :level1 => {
+          :errors => [{:code => "1", :attribute => "attr", :message => "message"}],
+          :level2 => {
+            :errors => [
+              {:code => "2", :attribute => "attr2", :message => "message2"},
+              {:code => "3", :attribute => "attr3", :message => "message3"}
+            ],
+          }
+        }
+      )
+      errors.size.should == 3
+    end
+  end
+end
+

data/spec/unit/braintree/http_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::Http do
+  describe "self._format_and_sanitize_body_for_log" do
+    it "adds [Braintree] before each line" do
+      input_xml = <<-END
+<customer>
+  <first-name>Joe</first-name>
+  <last-name>Doe</last-name>
+</customer>
+END
+      expected_xml = <<-END
+[Braintree] <customer>
+[Braintree]   <first-name>Joe</first-name>
+[Braintree]   <last-name>Doe</last-name>
+[Braintree] </customer>
+END
+      Braintree::Http._format_and_sanitize_body_for_log(input_xml).should == expected_xml
+    end
+    
+    it "sanitizes credit card number and cvv" do
+      input_xml = <<-END
+<customer>
+  <first-name>Joe</first-name>
+  <last-name>Doe</last-name>
+  <number>1234560000001234</number>
+  <cvv>123</cvv>
+</customer>
+      END
+      
+      expected_xml = <<-END
+[Braintree] <customer>
+[Braintree]   <first-name>Joe</first-name>
+[Braintree]   <last-name>Doe</last-name>
+[Braintree]   <number>123456******1234</number>
+[Braintree]   <cvv>***</cvv>
+[Braintree] </customer>
+END
+      Braintree::Http._format_and_sanitize_body_for_log(input_xml).should == expected_xml
+    end
+  end
+end

data/spec/unit/braintree/paged_collection_spec.rb

@@ -0,0 +1,128 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe "Braintree::PagedCollection" do
+  it "includes enumerable" do
+    collection = Braintree::PagedCollection.new(:items => ["a"])
+    collection.detect { |item| item == "a" }.should == "a"
+  end
+
+  describe "[]" do
+    it "returns the element at the given index" do
+      collection = Braintree::PagedCollection.new(:items => ["one", "two", "three"])
+      collection[0].should == "one"
+      collection[2].should == "three"
+      collection[3].should == nil
+    end
+  end
+  
+  describe "each" do
+    it "iterates over the contents" do
+      expected = ["apples", "bananas", "cherries"]
+      collection = Braintree::PagedCollection.new(
+        :items => expected
+      )
+      actual = []
+      collection.each do |item|
+        actual << item
+      end
+      actual.should == expected
+    end
+  end
+  
+  describe "first" do
+    it "returns the first element" do
+      collection = Braintree::PagedCollection.new(
+        :items => ["apples", "bananas", "cherries"]
+      )
+      collection.first.should == "apples"
+    end
+  end
+  
+  describe "initialize" do
+    it "initializes attributes as expected" do
+      collection = Braintree::PagedCollection.new(
+        :current_page_number => 1,
+        :page_size => 2,
+        :total_items => 4,
+        :items => ["apples", "bananas", "cherries"]
+      )
+      collection.current_page_number.should == 1
+      collection.page_size.should == 2
+      collection.total_items.should == 4
+      collection.items.should == ["apples", "bananas", "cherries"]
+    end
+  end
+
+  describe "last_page?" do
+    it "returns true if the page is the last page" do
+      collection = Braintree::PagedCollection.new(:current_page_number => 3, :page_size => 50, :total_items => 150)
+      collection.last_page?.should == true
+    end
+
+    it "returns false if the page is not the last page" do
+      collection = Braintree::PagedCollection.new(:current_page_number => 3, :page_size => 50, :total_items => 151)
+      collection.last_page?.should == false
+    end
+  end
+  
+  describe "next_page" do
+    it "returns the next page of results" do
+      collection = Braintree::PagedCollection.new(
+          :current_page_number => 1,
+          :page_size => 1,
+          :total_items => 2
+        ) do |page_num|
+        "contents of page #{page_num}"
+      end      
+      collection.next_page.should == "contents of page 2"
+    end
+    
+    it "returns nil if on last page" do
+      collection = Braintree::PagedCollection.new(
+          :current_page_number => 2,
+          :page_size => 2,
+          :total_items => 4
+        )      
+      collection.next_page.should == nil
+    end
+  end
+  
+  describe "next_page_number" do
+    it "returns the next page number when not on the last page" do
+      collection = Braintree::PagedCollection.new(
+        :current_page_number => 2,
+        :page_size => 1,
+        :total_items => 50
+      )
+      collection.next_page_number.should == 3
+    end
+    
+    it "returns nil when on the last page" do
+      collection = Braintree::PagedCollection.new(
+        :current_page_number => 1,
+        :page_size => 1,
+        :total_items => 1
+      )
+      collection.next_page_number.should == nil      
+    end
+  end
+  
+  describe "total_pages" do
+    it "calculates the total number of pages when total items is not evenly divisible by page size" do
+      collection = Braintree::PagedCollection.new(
+        :page_size => 5,
+        :total_items => 13
+      )
+      collection.total_pages.should == 3
+    end
+
+    it "calculates the total number of pages when total items is not evenly divisible by page size" do
+      collection = Braintree::PagedCollection.new(
+        :page_size => 5,
+        :total_items => 20
+      )
+      collection.total_pages.should == 4
+    end
+  end
+  
+end