braintree 2.76.0 → 2.77.0

data/spec/fixtures/files/malformed_pdf.pdf

@@ -0,0 +1 @@
+XXXXXXXXXXX¾?^gfkbfu¶šÙú”¼Åxc¯ÄÖñ•:x„BºS·É=]óqçÅÒÐwî+=	x	wÁ
¼/7ú7ÀݛeÀÅA¿8?À­‹6Á2[î(†¤Ö@+3[ß}

data/spec/httpsd.pid

@@ -1 +1 @@
-13345
+3946

data/spec/integration/braintree/apple_pay_spec.rb

@@ -0,0 +1,92 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::ApplePayGateway do
+  before(:each) do
+    gateway = Braintree::Gateway.new(
+      :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
+      :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
+      :logger => Logger.new("/dev/null")
+    )
+
+    result = gateway.merchant.create(
+      :email => "name@email.com",
+      :country_code_alpha3 => "USA",
+      :payment_methods => ["credit_card", "paypal"]
+    )
+
+    @gateway = Braintree::Gateway.new(
+      :access_token => result.credentials.access_token,
+      :logger => Logger.new("/dev/null")
+    )
+  end
+
+  describe "register_domain" do
+    it "registers an apple pay domain" do
+      result = @gateway.apple_pay.register_domain("www.example.com")
+      result.should be_success
+    end
+
+    it "gets a validation error when attempting to register no domains" do
+      result = @gateway.apple_pay.register_domain("")
+      result.should_not be_success
+      result.errors.for(:apple_pay)[0].message.should eq("Domain name is required.")
+    end
+  end
+
+  describe "unregister_domain" do
+    it "unregisters an apple pay domain" do
+      domain = "example.org"
+      result = @gateway.apple_pay.register_domain(domain)
+      result.should be_success
+
+      result = @gateway.apple_pay.unregister_domain(domain)
+      result.should be_success
+      @gateway.apple_pay.registered_domains.apple_pay_options.domains.should be_empty
+    end
+
+    it "unregisters an apple pay domain with scheme in url" do
+      domain = "http://example.org"
+      result = @gateway.apple_pay.register_domain(domain)
+      result.should be_success
+
+      result = @gateway.apple_pay.unregister_domain(domain)
+      result.should be_success
+      @gateway.apple_pay.registered_domains.apple_pay_options.domains.should be_empty
+    end
+
+    it "does not fail when unregistering a non-registered domain" do
+      result = @gateway.apple_pay.unregister_domain("unregistered.com")
+      result.should be_success
+    end
+
+    it "escapes the unregistered domain query parameter" do
+      domain = "ex&mple.org"
+      result = @gateway.apple_pay.register_domain(domain)
+      result.should be_success
+      @gateway.apple_pay.registered_domains.apple_pay_options.domains.should_not be_empty
+
+      result = @gateway.apple_pay.unregister_domain(domain)
+      result.should be_success
+      @gateway.apple_pay.registered_domains.apple_pay_options.domains.should be_empty
+    end
+  end
+
+  describe "registered_domains" do
+    it "returns registered domains" do
+      result = @gateway.apple_pay.register_domain("www.example.com")
+      result.should be_success
+      result = @gateway.apple_pay.register_domain("www.example.org")
+      result.should be_success
+
+      result = @gateway.apple_pay.registered_domains
+      result.should be_success
+      result.apple_pay_options.domains.should =~ ["www.example.org", "www.example.com"]
+    end
+
+    it "returns an empty list if no domains are registered" do
+      result = @gateway.apple_pay.registered_domains
+      result.should be_success
+      result.apple_pay_options.domains.should == []
+    end
+  end
+end

data/spec/integration/braintree/coinbase_spec.rb

@@ -8,24 +8,27 @@ describe "Coinbase" do
     end
   end
 
-  it "works for transaction#create" do
+  it "is no longer supported with transaction#create" do
     result = Braintree::Transaction.sale(:payment_method_nonce => Braintree::Test::Nonce::Coinbase, :amount => "0.02")
-    result.should be_success
-    assert_valid_coinbase_attrs(result.transaction.coinbase_details)
+    result.should_not be_success
+
+    result.errors.for(:transaction).first.code.should == Braintree::ErrorCodes::PaymentMethod::PaymentMethodNoLongerSupported
   end
 
-  it "works for vaulting" do
+  it "is no longer supported for vaulting" do
     customer = Braintree::Customer.create!
-    vaulted = Braintree::PaymentMethod.create(:customer_id => customer.id, :payment_method_nonce => Braintree::Test::Nonce::Coinbase).payment_method
-    assert_valid_coinbase_attrs(vaulted)
+    result = Braintree::PaymentMethod.create(:customer_id => customer.id, :payment_method_nonce => Braintree::Test::Nonce::Coinbase)
+    result.should_not be_success
 
-    found = Braintree::PaymentMethod.find(vaulted.token).payment_method
-    assert_valid_coinbase_attrs(found)
+    result.errors.for(:coinbase_account).first.code.should == Braintree::ErrorCodes::PaymentMethod::PaymentMethodNoLongerSupported
   end
 
-  it "is returned on Customers" do
-    customer = Braintree::Customer.create!(:payment_method_nonce => Braintree::Test::Nonce::Coinbase)
-    customer.payment_methods.should == customer.coinbase_accounts
-    assert_valid_coinbase_attrs(customer.coinbase_accounts[0])
+  it "is no longer supported when creating a Customer with a Coinbase payment method nonce" do
+    expect do
+      Braintree::Customer.create!(:payment_method_nonce => Braintree::Test::Nonce::Coinbase)
+    end.to raise_error { |error|
+      error.should be_a(Braintree::ValidationsFailed)
+      error.error_result.errors.for(:coinbase_account).first.code.should == Braintree::ErrorCodes::PaymentMethod::PaymentMethodNoLongerSupported
+    }
   end
 end

data/spec/integration/braintree/dispute_search_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::Dispute, "search" do
+  context "advanced" do
+    it "correctly returns a result with no matches" do
+      collection = Braintree::Dispute.search do |search|
+        search.id.is "non_existent_dispute"
+      end
+
+      expect(collection.disputes.count).to eq(0)
+    end
+
+    it "correctly returns a single dispute by id" do
+      collection = Braintree::Dispute.search do |search|
+        search.id.is "open_dispute"
+      end
+
+      expect(collection.disputes.count).to eq(1)
+      dispute = collection.disputes.first
+
+      expect(dispute.id).to eq("open_dispute")
+      expect(dispute.status).to eq(Braintree::Dispute::Status::Open)
+    end
+
+    it "correctly returns disputes by multiple reasons" do
+      collection = Braintree::Dispute.search do |search|
+        search.reason.in [
+          Braintree::Dispute::Reason::ProductUnsatisfactory,
+          Braintree::Dispute::Reason::Retrieval
+        ]
+      end
+
+      expect(collection.disputes.count).to eq(2)
+      dispute = collection.disputes.first
+    end
+
+    it "correctly returns disputes by received_date range" do
+      collection = Braintree::Dispute.search do |search|
+        search.received_date.between("03/03/2014", "03/05/2014")
+      end
+
+      expect(collection.disputes.count).to eq(1)
+      dispute = collection.disputes.first
+
+      expect(dispute.received_date).to eq(Date.new(2014, 3, 4))
+    end
+  end
+end

data/spec/integration/braintree/dispute_spec.rb

@@ -0,0 +1,216 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::Dispute do
+  let(:transaction) do
+    result = Braintree::Transaction.sale(
+      :amount => '10.00',
+      :credit_card => {
+        :expiration_date => '01/2020',
+        :number => Braintree::Test::CreditCardNumbers::Disputes::Chargeback
+      },
+      :options => {
+        :submit_for_settlement => true
+      }
+    )
+
+    result.transaction
+  end
+
+  let(:dispute) { transaction.disputes.first }
+
+  describe "self.accept" do
+    it "changes the dispute status to accepted" do
+      result = Braintree::Dispute.accept(dispute.id)
+
+      result.success?.should == true
+
+      refreshed_dispute = Braintree::Dispute.find(dispute.id)
+      refreshed_dispute.status.should == Braintree::Dispute::Status::Accepted
+    end
+
+    it "returns an error response if the dispute is not in open status" do
+      result = Braintree::Dispute.accept("wells_dispute")
+
+      result.success?.should == false
+      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::CanOnlyAcceptOpenDispute
+      result.errors.for(:dispute)[0].message.should == "Disputes can only be accepted when they are in an Open state"
+    end
+
+    it "raises a NotFound exception if the dispute cannot be found" do
+      expect do
+        Braintree::Dispute.accept("invalid-id")
+      end.to raise_error(Braintree::NotFoundError, 'dispute with id invalid-id not found')
+    end
+  end
+
+  describe "self.add_file_evidence" do
+    let(:document_upload) do
+      file = File.new("#{File.dirname(__FILE__)}/../../fixtures/files/bt_logo.png", "r")
+      response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
+      document_upload = response.document_upload
+    end
+
+    it "creates text evidence for the dispute" do
+      result = Braintree::Dispute.add_file_evidence(dispute.id, document_upload.id)
+
+      result.success?.should == true
+      result.evidence.comment.should be_nil
+      result.evidence.created_at.between?(Time.now - 10, Time.now).should == true
+      result.evidence.id.should =~ /^\w{16,}$/
+      result.evidence.sent_to_processor_at.should == nil
+      result.evidence.url.should include("bt_logo.png")
+    end
+
+    it "returns a NotFoundError if the dispute doesn't exist" do
+      expect do
+        Braintree::Dispute.add_file_evidence("unknown_dispute_id", "b51927a6-4ed7-4a32-8404-df8ef892e1a3")
+      end.to raise_error(Braintree::NotFoundError)
+    end
+
+    it "returns an error response if the dispute is not in open status" do
+      Braintree::Dispute.accept(dispute.id)
+
+      result = Braintree::Dispute.add_file_evidence(dispute.id, document_upload.id)
+      result.success?.should == false
+      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::CanOnlyAddEvidenceToOpenDispute
+      result.errors.for(:dispute)[0].message.should == "Evidence can only be attached to disputes that are in an Open state"
+    end
+
+    it "returns the new evidence record in subsequent dispute finds" do
+      result = Braintree::Dispute.add_file_evidence(dispute.id, document_upload.id)
+      refreshed_dispute = Braintree::Dispute.find(dispute.id)
+
+      expected_evidence = refreshed_dispute.evidence.find { |e| e.id == result.evidence.id }
+      expected_evidence.should_not == nil
+      expected_evidence.comment.should be_nil
+      expected_evidence.url.should include("bt_logo.png")
+    end
+  end
+
+  describe "self.add_text_evidence" do
+    it "creates text evidence for the dispute" do
+      result = Braintree::Dispute.add_text_evidence(dispute.id, "text evidence")
+
+      result.success?.should == true
+      result.evidence.comment.should == "text evidence"
+      result.evidence.created_at.between?(Time.now - 10, Time.now).should == true
+      result.evidence.id.should =~ /^\w{16,}$/
+      result.evidence.sent_to_processor_at.should == nil
+      result.evidence.url.should == nil
+    end
+
+    it "returns a NotFoundError if the dispute doesn't exist" do
+      expect do
+        Braintree::Dispute.add_text_evidence("unknown_dispute_id", "text evidence")
+      end.to raise_error(Braintree::NotFoundError)
+    end
+
+    it "returns an error response if the dispute is not in open status" do
+      Braintree::Dispute.accept(dispute.id)
+
+      result = Braintree::Dispute.add_text_evidence(dispute.id, "text evidence")
+      result.success?.should == false
+      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::CanOnlyAddEvidenceToOpenDispute
+      result.errors.for(:dispute)[0].message.should == "Evidence can only be attached to disputes that are in an Open state"
+    end
+
+    it "returns the new evidence record in subsequent dispute finds" do
+      result = Braintree::Dispute.add_text_evidence(dispute.id, "text evidence")
+      refreshed_dispute = Braintree::Dispute.find(dispute.id)
+
+      expected_evidence = refreshed_dispute.evidence.find { |e| e.id == result.evidence.id }
+      expected_evidence.should_not == nil
+      expected_evidence.comment.should == "text evidence"
+    end
+  end
+
+  describe "self.finalize" do
+    it "changes the dispute status to disputed" do
+      result = Braintree::Dispute.finalize(dispute.id)
+
+      result.success?.should == true
+
+      refreshed_dispute = Braintree::Dispute.find(dispute.id)
+      refreshed_dispute.status.should == Braintree::Dispute::Status::Disputed
+    end
+
+    it "returns an error response if the dispute is not in open status" do
+      result = Braintree::Dispute.finalize("wells_dispute")
+
+      result.success?.should == false
+      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::CanOnlyFinalizeOpenDispute
+      result.errors.for(:dispute)[0].message.should == "Disputes can only be finalized when they are in an Open state"
+    end
+
+    it "raises a NotFound exception if the dispute cannot be found" do
+      expect do
+        Braintree::Dispute.finalize("invalid-id")
+      end.to raise_error(Braintree::NotFoundError, 'dispute with id invalid-id not found')
+    end
+  end
+
+  describe "self.find" do
+    it "finds the dispute with the given id" do
+      dispute = Braintree::Dispute.find("open_dispute")
+
+      dispute.amount_disputed.should == 31.0
+      dispute.amount_won.should == 0.0
+      dispute.id.should == "open_dispute"
+      dispute.status.should == Braintree::Dispute::Status::Open
+      dispute.transaction.amount.should == 31.0
+      dispute.transaction.id.should == "open_disputed_transaction"
+    end
+
+    it "raises an ArgumentError if dispute_id is not a string" do
+      expect do
+        Braintree::Dispute.find(Object.new)
+      end.to raise_error(ArgumentError, "dispute_id contains invalid characters")
+    end
+
+    it "raises an ArgumentError if dispute_id is blank" do
+      expect do
+        Braintree::Dispute.find("")
+      end.to raise_error(ArgumentError, "dispute_id contains invalid characters")
+    end
+
+    it "raises a NotFoundError exception if the dispute cannot be found" do
+      expect do
+        Braintree::Dispute.find("invalid-id")
+      end.to raise_error(Braintree::NotFoundError, "dispute with id invalid-id not found")
+    end
+  end
+
+  describe "self.remove_evidence" do
+    let(:evidence) { Braintree::Dispute.add_text_evidence(dispute.id, "text evidence").evidence }
+
+    it "removes evidence from the dispute" do
+      result = Braintree::Dispute.remove_evidence(dispute.id, evidence.id)
+
+      result.success?.should == true
+    end
+
+    it "returns a NotFoundError if the dispute doesn't exist" do
+      expect do
+        Braintree::Dispute.remove_evidence("unknown_dispute_id", evidence.id)
+      end.to raise_error(Braintree::NotFoundError, "evidence with id #{evidence.id} for dispute with id unknown_dispute_id not found")
+    end
+
+    it "returns a NotFoundError if the dispute doesn't exist" do
+      expect do
+        Braintree::Dispute.remove_evidence(dispute.id, "unknown_evidence_id")
+      end.to raise_error(Braintree::NotFoundError, "evidence with id unknown_evidence_id for dispute with id #{dispute.id} not found")
+    end
+
+    it "returns an error response if the dispute is not in open status" do
+      evidence = Braintree::Dispute.add_text_evidence(dispute.id, "text evidence").evidence
+      Braintree::Dispute.accept(dispute.id)
+
+      result = Braintree::Dispute.remove_evidence(dispute.id, evidence.id)
+      result.success?.should == false
+      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::CanOnlyRemoveEvidenceFromOpenDispute
+      result.errors.for(:dispute)[0].message.should == "Evidence can only be removed from disputes that are in an Open state"
+    end
+  end
+end

data/spec/integration/braintree/document_upload_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::DocumentUploadGateway do
+  describe "create" do
+    it "returns successful with valid request" do
+      file = File.new("#{File.dirname(__FILE__)}/../../fixtures/files/bt_logo.png", "r")
+      response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
+      document_upload = response.document_upload
+
+      response.success?.should == true
+      document_upload.id.should_not be_nil
+      document_upload.content_type.should == "image/png"
+      document_upload.kind.should == Braintree::DocumentUpload::Kind::EvidenceDocument
+      document_upload.name.should == "bt_logo.png"
+      document_upload.size.should == 2443
+    end
+
+    it "returns file type error with unsupported file type" do
+      file = File.new("#{File.dirname(__FILE__)}/../../fixtures/files/gif_extension_bt_logo.gif", "r")
+      response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
+      response.errors.for(:document_upload).first.code.should == Braintree::ErrorCodes::DocumentUpload::FileTypeIsInvalid
+    end
+
+    it "returns malformed error with malformed file" do
+      file = File.new("#{File.dirname(__FILE__)}/../../fixtures/files/malformed_pdf.pdf", "r")
+      response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
+      response.errors.for(:document_upload).first.code.should == Braintree::ErrorCodes::DocumentUpload::FileIsMalformedOrEncrypted
+    end
+
+    it "returns invalid kind error with invalid kind" do
+      file = File.new("#{File.dirname(__FILE__)}/../../fixtures/files/bt_logo.png", "r")
+      response = Braintree::DocumentUpload.create({:kind => "invalid_kind", :file => file})
+      response.errors.for(:document_upload).first.code.should == Braintree::ErrorCodes::DocumentUpload::KindIsInvalid
+    end
+
+    it "returns file too large error with file over 4mb" do
+      filename = "#{File.dirname(__FILE__)}/../../fixtures/files/large_file.png"
+      begin
+        write_times = 1048577 * 4
+        File.open(filename, "w+") { |f| write_times.times { f.write "a" } }
+        file = File.new(filename, "r")
+        response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
+        response.errors.for(:document_upload).first.code.should == Braintree::ErrorCodes::DocumentUpload::FileIsTooLarge
+      ensure
+        File.delete(filename)
+      end
+    end
+
+    it "returns invalid keys error if signature is invalid" do
+      expect do
+        response = Braintree::DocumentUpload.create({:invalid_key => "do not add", :kind => Braintree::DocumentUpload::Kind::EvidenceDocument})
+      end.to raise_error(ArgumentError, "invalid keys: invalid_key")
+    end
+  end
+end