mangopay-v4 4.0.0 → 4.0.1

data/spec/mangopay/clients_spec.rb

@@ -1,55 +1,57 @@
-require_relative '../context/client_context'
-require_relative '../../lib/mangopay/api/service/clients'
-require_relative '../../lib/mangopay/util/file_encoder'
-
-describe MangoApi::Clients do
-  include_context 'client_context'
-
-  describe '.update' do
-
-    context 'given a valid object' do
-      client = CLIENT_DATA
-
-      it 'updates the corresponding entity' do
-        updated = MangoApi::Clients.update client
-
-        expect(updated).to be_kind_of MangoModel::Client
-        expect(updated.name).not_to be_nil
-        expect(updated.client_id).not_to be_nil
-        expect(updated.logo).not_to be_nil
-        expect(its_the_same_client(client, updated)).to be_truthy
-      end
-    end
-  end
-
-  describe '.upload_logo' do
-
-    context "given a valid image file's path" do
-      path = File.join(File.dirname(__FILE__), '..', 'resources', 'logo.png')
-      base64_to_upload = FileEncoder.encode_base64(path)
-
-      it "uploads the image as the client's logo" do
-        MangoApi::Clients.upload_logo path
-
-        client = MangoApi::Clients.get
-        uploaded_logo_uri = URI(client.logo)
-        uploaded_image = MangoApi::HttpClient.get_raw(uploaded_logo_uri)
-        uploaded_base64 = Base64.strict_encode64(uploaded_image)
-
-        expect(base64_to_upload).to eq uploaded_base64
-      end
-    end
-  end
-
-  describe '.get' do
-
-    context 'from a correctly-configured environment' do
-      it "retrieves the environment's Client entity" do
-        retrieved = MangoApi::Clients.get
-
-        expect(retrieved).to be_kind_of MangoModel::Client
-        expect(retrieved.client_id).to eq MangoPay.configuration.client_id
-      end
-    end
-  end
+require_relative '../context/client_context'
+require_relative '../../lib/mangopay/api/service/clients'
+require_relative '../../lib/mangopay/util/file_encoder'
+
+describe MangoApi::Clients do
+  include_context 'client_context'
+
+  describe '.update' do
+
+    context 'given a valid object' do
+      client = CLIENT_DATA
+
+      it 'updates the corresponding entity', :focus do
+        updated = MangoApi::Clients.update client
+
+        expect(updated).to be_kind_of MangoModel::Client
+        expect(updated.name).not_to be_nil
+        expect(updated.client_id).not_to be_nil
+        expect(updated.logo).not_to be_nil
+        expect(updated.headquarters_phone_number).not_to be_nil
+        expect(its_the_same_client(client, updated)).to be_truthy
+      end
+    end
+  end
+
+  describe '.upload_logo' do
+
+    context "given a valid image file's path" do
+      path = File.join(File.dirname(__FILE__), '..', 'resources', 'logo.png')
+      base64_to_upload = FileEncoder.encode_base64(path)
+
+      it "uploads the image as the client's logo" do
+        MangoApi::Clients.upload_logo path
+
+        client = MangoApi::Clients.get
+        uploaded_logo_uri = URI(client.logo)
+        uploaded_image = MangoApi::HttpClient.get_raw(uploaded_logo_uri)
+        uploaded_base64 = Base64.strict_encode64(uploaded_image)
+
+        expect(base64_to_upload).to eq uploaded_base64
+      end
+    end
+  end
+
+  describe '.get' do
+
+    context 'from a correctly-configured environment' do
+      it "retrieves the environment's Client entity" do
+        retrieved = MangoApi::Clients.get
+
+        expect(retrieved).to be_kind_of MangoModel::Client
+        expect(retrieved.client_id).to eq MangoPay.configuration.client_id
+        expect(retrieved.platform_categorization).to be_kind_of MangoModel::PlatformCategorization
+      end
+    end
+  end
 end

data/spec/mangopay/configuration_spec.rb

@@ -1,126 +1,126 @@
-require_relative '../spec_helper'
-require_relative '../../lib/mangopay'
-require_relative '../../lib/mangopay/api/service/users'
-require_relative '../../lib/mangopay/model/entity/user/natural_user'
-
-describe MangoPay::Configuration do
-
-  let(:thread_environment_hash) { retrieve_thread_env_hash }
-
-  after :all do
-    MangoPay.use_default
-    reconfig_mangopay
-  end
-
-  context 'without specifying environment' do
-
-    it 'automatically runs on :default environment' do
-      expect(MangoPay.environment.id).to be :default
-    end
-  end
-
-  context 'when specifying multiple environments' do
-    describe 'storing configurations' do
-      CLIENT_ID1 = 'CLIENT_ID1'.freeze
-      CLIENT_ID2 = 'CLIENT_ID2'.freeze
-      CLIENT_PASS1 = 'CLIENT_PASS1'.freeze
-      CLIENT_PASS2 = 'CLIENT_PASS2'.freeze
-
-      it 'is done environment-specifically' do
-        MangoPay.use_environment :env1
-        MangoPay.configure do |config|
-          config.client_id = CLIENT_ID1
-          config.client_passphrase = CLIENT_PASS1
-        end
-        MangoPay.use_environment :env2
-        MangoPay.configure do |config|
-          config.client_id = CLIENT_ID2
-          config.client_passphrase = CLIENT_PASS2
-        end
-
-        MangoPay.use_environment :env1
-        config = MangoPay.configuration
-        expect(config.client_id).to be CLIENT_ID1
-        expect(config.client_passphrase).to be CLIENT_PASS1
-
-        MangoPay.use_environment :env2
-        config = MangoPay.configuration
-        expect(config.client_id).to be CLIENT_ID2
-        expect(config.client_passphrase).to be CLIENT_PASS2
-      end
-    end
-
-    context 'across multiple threads' do
-      describe 'switching environments' do
-
-        it 'is done thread-independently' do
-          MangoPay.use_environment :env1
-          thread = Thread.new do
-            MangoPay.use_environment :env2
-            expect(MangoPay.environment.id).to be :env2
-          end
-          thread.join
-          expect(MangoPay.environment.id).to be :env1
-          # allow background threads to terminate
-          sleep 0.05
-        end
-      end
-
-      describe 'new thread-to-environment mappings' do
-        it 'live only as long as the threads' do
-          thread = Thread.new do
-            MangoPay.use_environment :env1
-            thread_id = Thread.current.object_id
-            expect(thread_environment_hash[thread_id]).to be :env1
-          end
-          thread.join
-          # allow any post-thread-death actions to execute
-          sleep 0.05
-          expect(thread_environment_hash[thread.object_id]).to be_nil
-        end
-
-        context 'unless environment is switched' do
-          it 'are to the same environment' do
-            MangoPay.use_environment :env1
-
-            thread_id = Thread.current.object_id
-            expect(thread_environment_hash[thread_id]).to be :env1
-
-            thread = Thread.new do
-              # request an environment to be assigned to thread
-              MangoPay.environment
-              thread_id = Thread.current.object_id
-              expect(thread_environment_hash[thread_id]).to be :env1
-            end
-            thread.join
-
-            MangoPay.use_environment :env2
-
-            thread_id = Thread.current.object_id
-            expect(thread_environment_hash[thread_id]).to be :env2
-
-            thread = Thread.new do
-              MangoPay.environment
-              thread_id = Thread.current.object_id
-              expect(thread_environment_hash[thread_id]).to be :env2
-            end
-            thread.join
-            # allow background threads to terminate
-            sleep 0.05
-          end
-        end
-      end
-    end
-  end
-end
-
-# Gets the thread-to-environment ID hash from the MangoPay module.
-#
-# noinspection RubyResolve
-def retrieve_thread_env_hash
-  result = nil
-  MangoPay.instance_eval do
-    result = @env_id
-  end
-  result
+require_relative '../spec_helper'
+require_relative '../../lib/mangopay'
+require_relative '../../lib/mangopay/api/service/users'
+require_relative '../../lib/mangopay/model/entity/user/natural_user'
+
+describe MangoPay::Configuration do
+
+  let(:thread_environment_hash) { retrieve_thread_env_hash }
+
+  after :all do
+    MangoPay.use_default
+    reconfig_mangopay
+  end
+
+  context 'without specifying environment' do
+
+    it 'automatically runs on :default environment' do
+      expect(MangoPay.environment.id).to be :default
+    end
+  end
+
+  context 'when specifying multiple environments' do
+    describe 'storing configurations' do
+      CLIENT_ID1 = 'CLIENT_ID1'.freeze
+      CLIENT_ID2 = 'CLIENT_ID2'.freeze
+      CLIENT_PASS1 = 'CLIENT_PASS1'.freeze
+      CLIENT_PASS2 = 'CLIENT_PASS2'.freeze
+
+      it 'is done environment-specifically' do
+        MangoPay.use_environment :env1
+        MangoPay.configure do |config|
+          config.client_id = CLIENT_ID1
+          config.client_apiKey = CLIENT_PASS1
+        end
+        MangoPay.use_environment :env2
+        MangoPay.configure do |config|
+          config.client_id = CLIENT_ID2
+          config.client_apiKey = CLIENT_PASS2
+        end
+
+        MangoPay.use_environment :env1
+        config = MangoPay.configuration
+        expect(config.client_id).to be CLIENT_ID1
+        expect(config.client_apiKey).to be CLIENT_PASS1
+
+        MangoPay.use_environment :env2
+        config = MangoPay.configuration
+        expect(config.client_id).to be CLIENT_ID2
+        expect(config.client_apiKey).to be CLIENT_PASS2
+      end
+    end
+
+    context 'across multiple threads' do
+      describe 'switching environments' do
+
+        it 'is done thread-independently' do
+          MangoPay.use_environment :env1
+          thread = Thread.new do
+            MangoPay.use_environment :env2
+            expect(MangoPay.environment.id).to be :env2
+          end
+          thread.join
+          expect(MangoPay.environment.id).to be :env1
+          # allow background threads to terminate
+          sleep 0.05
+        end
+      end
+
+      describe 'new thread-to-environment mappings' do
+        it 'live only as long as the threads' do
+          thread = Thread.new do
+            MangoPay.use_environment :env1
+            thread_id = Thread.current.object_id
+            expect(thread_environment_hash[thread_id]).to be :env1
+          end
+          thread.join
+          # allow any post-thread-death actions to execute
+          sleep 0.05
+          expect(thread_environment_hash[thread.object_id]).to be_nil
+        end
+
+        context 'unless environment is switched' do
+          it 'are to the same environment' do
+            MangoPay.use_environment :env1
+
+            thread_id = Thread.current.object_id
+            expect(thread_environment_hash[thread_id]).to be :env1
+
+            thread = Thread.new do
+              # request an environment to be assigned to thread
+              MangoPay.environment
+              thread_id = Thread.current.object_id
+              expect(thread_environment_hash[thread_id]).to be :env1
+            end
+            thread.join
+
+            MangoPay.use_environment :env2
+
+            thread_id = Thread.current.object_id
+            expect(thread_environment_hash[thread_id]).to be :env2
+
+            thread = Thread.new do
+              MangoPay.environment
+              thread_id = Thread.current.object_id
+              expect(thread_environment_hash[thread_id]).to be :env2
+            end
+            thread.join
+            # allow background threads to terminate
+            sleep 0.05
+          end
+        end
+      end
+    end
+  end
+end
+
+# Gets the thread-to-environment ID hash from the MangoPay module.
+#
+# noinspection RubyResolve
+def retrieve_thread_env_hash
+  result = nil
+  MangoPay.instance_eval do
+    result = @env_id
+  end
+  result
 end

data/spec/mangopay/dispute_documents_spec.rb

@@ -1,174 +1,174 @@
-require_relative '../../lib/mangopay/api/service/dispute_documents'
-require_relative '../context/dispute_document_context'
-require_relative '../../lib/mangopay/common/sort_field'
-require_relative '../../lib/mangopay/common/sort_direction'
-
-describe MangoApi::DisputeDocuments do
-  include_context 'dispute_document_context'
-
-  describe '.create' do
-
-    context 'given a valid object' do
-      id = DISPUTE_PERSISTED.id
-      document = DISPUTE_DOCUMENT_DATA
-
-      it 'creates the dispute document entity' do
-        expect { MangoApi::DisputeDocuments.create(document, id) }.to(raise_error { |err|
-          expect(err).to be_kind_of MangoPay::ResponseError
-          expect(err.type).to eq 'dispute_can_not_currently_accept_documents'
-        })
-      end
-    end
-  end
-
-  describe '.upload_page' do
-
-    context "given a valid file's path" do
-      path = File.join(File.dirname(__FILE__), '..', 'resources', 'test_pdf.pdf')
-
-      it "uploads the file as one of the dispute document's pages" do
-        expect do
-          MangoApi::DisputeDocuments.upload_page(DISPUTE_DOCUMENT_PERSISTED.id,
-                                                 DISPUTE_DOCUMENT_PERSISTED.dispute_id,
-                                                 path)
-        end.to(raise_error do |err|
-          expect(err).to be_kind_of MangoPay::ResponseError
-          expect(err.type).to eq 'dispute_can_not_currently_accept_documents'
-        end)
-      end
-    end
-  end
-
-  describe '.submit' do
-
-    context "given an existing entity's ID" do
-      created = DISPUTE_DOCUMENT_PERSISTED
-      id = created.id
-
-      it 'submits the corresponding entity for approval' do
-        expect { MangoApi::DisputeDocuments.submit(id, created.dispute_id) }.to(raise_error do |err|
-          expect(err).to be_kind_of MangoPay::ResponseError
-          expect(err.type).to eq 'cant_validate_empty_document'
-        end)
-      end
-    end
-  end
-
-  describe '.get' do
-
-    context "given an existing entity's ID" do
-      document = DISPUTE_DOCUMENT_PERSISTED
-      id = document.id
-
-      it 'retrieves the corresponding entity' do
-        retrieved = MangoApi::DisputeDocuments.get id
-
-        expect(retrieved).to be_kind_of MangoModel::DisputeDocument
-        expect(retrieved.id).to eq id
-      end
-    end
-  end
-
-  describe '.of_dispute' do
-
-    context "given an existing dispute entity's ID" do
-      id = DISPUTE_PERSISTED.id
-
-      context 'not having specified filters' do
-        it 'retrieves list with default parameters' do
-          results = MangoApi::DisputeDocuments.of_dispute id
-
-          expect(results).to be_kind_of Array
-          results.each do |result|
-            expect(result).to be_kind_of MangoModel::DisputeDocument
-            expect(result.id).not_to be_nil
-          end
-        end
-      end
-
-      context 'having specified filters' do
-        per_page = 5
-
-        it 'retrieves a list with specified parameters' do
-          results = MangoApi::DisputeDocuments.of_dispute id do |filter|
-            filter.page = 1
-            filter.per_page = per_page
-            filter.sort_field = MangoPay::SortField::CREATION_DATE
-            filter.sort_direction = MangoPay::SortDirection::DESC
-          end
-
-          expect(results).to be_kind_of Array
-          expect(results.length).to eq per_page
-          results.each.with_index do |result, index|
-            expect(result).to be_kind_of MangoModel::DisputeDocument
-            expect(result.id).not_to be_nil
-            next if index == results.length - 1
-            first_date = result.creation_date
-            second_date = results[index + 1].creation_date
-            expect(first_date >= second_date).to be_truthy
-          end
-        end
-      end
-    end
-  end
-
-  describe '.all' do
-
-    context 'from a correctly-configured environment' do
-      context 'not having specified filters' do
-        default_per_page = 10
-
-        it 'retrieves list with default parameters' do
-          results = MangoApi::DisputeDocuments.all
-
-          expect(results).to be_kind_of Array
-          expect(results.length).to eq default_per_page
-          results.each do |result|
-            expect(result).to be_kind_of MangoModel::DisputeDocument
-            expect(result.id).not_to be_nil
-          end
-        end
-      end
-
-      context 'having specified filters' do
-        per_page = 11
-
-        it 'retrieves list with specified parameters' do
-          results = MangoApi::DisputeDocuments.all do |filter|
-            filter.page = 1
-            filter.per_page = per_page
-            filter.sort_field = MangoPay::SortField::CREATION_DATE
-            filter.sort_direction = MangoPay::SortDirection::DESC
-          end
-
-          expect(results).to be_kind_of Array
-          expect(results.length).to eq per_page
-          results.each.with_index do |result, index|
-            expect(result).to be_kind_of MangoModel::DisputeDocument
-            expect(result.id).not_to be_nil
-            next if index == results.length - 1
-            first_date = result.creation_date
-            second_date = results[index + 1].creation_date
-            expect(first_date >= second_date).to be_truthy
-          end
-        end
-      end
-    end
-  end
-
-  describe '.consult' do
-
-    context "given an existing entity's ID" do
-      id = DISPUTE_DOCUMENT_PERSISTED.id
-
-      it 'creates the document page consult entities' do
-        results = MangoApi::DisputeDocuments.consult id
-
-        expect(results).to be_kind_of Array
-        results.each do |result|
-          expect(result).to be_kind_of MangoModel::DocumentPageConsult
-        end
-      end
-    end
-  end
+require_relative '../../lib/mangopay/api/service/dispute_documents'
+require_relative '../context/dispute_document_context'
+require_relative '../../lib/mangopay/common/sort_field'
+require_relative '../../lib/mangopay/common/sort_direction'
+
+describe MangoApi::DisputeDocuments do
+  include_context 'dispute_document_context'
+
+  describe '.create' do
+
+    context 'given a valid object' do
+      id = DISPUTE_PERSISTED.id
+      document = DISPUTE_DOCUMENT_DATA
+
+      it 'creates the dispute document entity' do
+        expect { MangoApi::DisputeDocuments.create(document, id) }.to(raise_error { |err|
+          expect(err).to be_kind_of MangoPay::ResponseError
+          expect(err.type).to eq 'dispute_can_not_currently_accept_documents'
+        })
+      end
+    end
+  end
+
+  describe '.upload_page' do
+
+    context "given a valid file's path" do
+      path = File.join(File.dirname(__FILE__), '..', 'resources', 'test_pdf.pdf')
+
+      it "uploads the file as one of the dispute document's pages" do
+        expect do
+          MangoApi::DisputeDocuments.upload_page(DISPUTE_DOCUMENT_PERSISTED.id,
+                                                 DISPUTE_DOCUMENT_PERSISTED.dispute_id,
+                                                 path)
+        end.to(raise_error do |err|
+          expect(err).to be_kind_of MangoPay::ResponseError
+          expect(err.type).to eq 'dispute_can_not_currently_accept_documents'
+        end)
+      end
+    end
+  end
+
+  describe '.submit' do
+
+    context "given an existing entity's ID" do
+      created = DISPUTE_DOCUMENT_PERSISTED
+      id = created.id
+
+      it 'submits the corresponding entity for approval' do
+        expect { MangoApi::DisputeDocuments.submit(id, created.dispute_id) }.to(raise_error do |err|
+          expect(err).to be_kind_of MangoPay::ResponseError
+          expect(err.type).to eq 'cant_validate_empty_document'
+        end)
+      end
+    end
+  end
+
+  describe '.get' do
+
+    context "given an existing entity's ID" do
+      document = DISPUTE_DOCUMENT_PERSISTED
+      id = document.id
+
+      it 'retrieves the corresponding entity' do
+        retrieved = MangoApi::DisputeDocuments.get id
+
+        expect(retrieved).to be_kind_of MangoModel::DisputeDocument
+        expect(retrieved.id).to eq id
+      end
+    end
+  end
+
+  describe '.of_dispute' do
+
+    context "given an existing dispute entity's ID" do
+      id = DISPUTE_PERSISTED.id
+
+      context 'not having specified filters' do
+        it 'retrieves list with default parameters' do
+          results = MangoApi::DisputeDocuments.of_dispute id
+
+          expect(results).to be_kind_of Array
+          results.each do |result|
+            expect(result).to be_kind_of MangoModel::DisputeDocument
+            expect(result.id).not_to be_nil
+          end
+        end
+      end
+
+      context 'having specified filters' do
+        per_page = 5
+
+        it 'retrieves a list with specified parameters' do
+          results = MangoApi::DisputeDocuments.of_dispute id do |filter|
+            filter.page = 1
+            filter.per_page = per_page
+            filter.sort_field = MangoPay::SortField::CREATION_DATE
+            filter.sort_direction = MangoPay::SortDirection::DESC
+          end
+
+          expect(results).to be_kind_of Array
+          expect(results.length).to eq per_page
+          results.each.with_index do |result, index|
+            expect(result).to be_kind_of MangoModel::DisputeDocument
+            expect(result.id).not_to be_nil
+            next if index == results.length - 1
+            first_date = result.creation_date
+            second_date = results[index + 1].creation_date
+            expect(first_date >= second_date).to be_truthy
+          end
+        end
+      end
+    end
+  end
+
+  describe '.all' do
+
+    context 'from a correctly-configured environment' do
+      context 'not having specified filters' do
+        default_per_page = 10
+
+        it 'retrieves list with default parameters' do
+          results = MangoApi::DisputeDocuments.all
+
+          expect(results).to be_kind_of Array
+          expect(results.length).to eq default_per_page
+          results.each do |result|
+            expect(result).to be_kind_of MangoModel::DisputeDocument
+            expect(result.id).not_to be_nil
+          end
+        end
+      end
+
+      context 'having specified filters' do
+        per_page = 11
+
+        it 'retrieves list with specified parameters' do
+          results = MangoApi::DisputeDocuments.all do |filter|
+            filter.page = 1
+            filter.per_page = per_page
+            filter.sort_field = MangoPay::SortField::CREATION_DATE
+            filter.sort_direction = MangoPay::SortDirection::DESC
+          end
+
+          expect(results).to be_kind_of Array
+          expect(results.length).to eq per_page
+          results.each.with_index do |result, index|
+            expect(result).to be_kind_of MangoModel::DisputeDocument
+            expect(result.id).not_to be_nil
+            next if index == results.length - 1
+            first_date = result.creation_date
+            second_date = results[index + 1].creation_date
+            expect(first_date >= second_date).to be_truthy
+          end
+        end
+      end
+    end
+  end
+
+  describe '.consult' do
+
+    context "given an existing entity's ID" do
+      id = DISPUTE_DOCUMENT_PERSISTED.id
+
+      it 'creates the document page consult entities' do
+        results = MangoApi::DisputeDocuments.consult id
+
+        expect(results).to be_kind_of Array
+        results.each do |result|
+          expect(result).to be_kind_of MangoModel::DocumentPageConsult
+        end
+      end
+    end
+  end
 end