mangopay-v4 4.0.0

data/spec/mangopay/cards_spec.rb

@@ -0,0 +1,135 @@
+require_relative '../context/card_context'
+require_relative '../../lib/mangopay/api/service/cards'
+require_relative '../../lib/mangopay/common/sort_field'
+require_relative '../../lib/mangopay/common/sort_direction'
+
+describe MangoApi::Cards do
+  include_context 'card_context'
+
+  describe '.create_registration' do
+
+    context 'given a valid object' do
+      card_registration = CARD_REGISTRATION_DATA
+
+      it 'creates the card registration entity' do
+        retrieved = MangoApi::Cards.create_registration card_registration
+
+        expect(retrieved).to be_kind_of MangoModel::CardRegistration
+        expect(retrieved.id).not_to be_nil
+        expect(retrieved.access_key).not_to be_nil
+        expect(retrieved.card_registration_url).not_to be_nil
+        expect(retrieved.preregistration_data).not_to be_nil
+        expect(retrieved.status).to be MangoModel::CardStatus::CREATED
+      end
+    end
+  end
+
+  describe '.complete_registration' do
+
+    context 'given the registration data from Tokenization Server' do
+      it 'completes the card registration process' do
+        created = CARD_REGISTRATION_PERSISTED
+        completed = CARD_REGISTRATION_COMPLETED
+        expect(completed).to be_kind_of MangoModel::CardRegistration
+        expect(completed.id).to eq created.id
+        expect(completed.status).to be MangoModel::CardStatus::VALIDATED
+        expect(completed.card_id).not_to be_nil
+      end
+    end
+  end
+
+  describe '.get_registration' do
+
+    context "given an existing entity's ID" do
+      card_registration = CARD_REGISTRATION_PERSISTED
+      id = card_registration.id
+
+      it 'retrieves the corresponding entity' do
+        retrieved = MangoApi::Cards.get_registration id
+
+        expect(retrieved).to be_kind_of MangoModel::CardRegistration
+        expect(retrieved.id).to eq card_registration.id
+      end
+    end
+  end
+
+  describe '.get' do
+
+    context "given a validated card entity's ID" do
+      id = CARD_REGISTRATION_COMPLETED.card_id
+      retrieved = MangoApi::Cards.get id
+
+      it 'retrieves the corresponding card entity' do
+        expect(retrieved).to be_kind_of MangoModel::Card
+        card = retrieved
+        expect(card.id).to eq id
+        expect(card.active).to be_truthy
+        expect(card.card_type).to be MangoModel::CardType::CB_VISA_MASTERCARD
+        expect(card.currency).to be MangoModel::CurrencyIso::EUR
+        expect(card.expiration_date).to eq CARD_EXPIRATION
+        expect(card.fingerprint).not_to be_nil
+        expect(card.user_id).to eq CARD_REGISTRATION_COMPLETED.user_id
+        expect(card.validity).to be MangoModel::CardValidity::UNKNOWN
+      end
+    end
+  end
+
+  describe '.of_user' do
+
+    context "given a valid user entity's ID" do
+      id = NATURAL_USER_PERSISTED.id
+
+      context 'not having specified filters' do
+        it 'retrieves list with default parameters' do
+          results = MangoApi::Cards.of_user id
+
+          expect(results).to be_kind_of Array
+          results.each do |result|
+            expect(result).to be_kind_of MangoModel::Card
+            expect(result.id).not_to be_nil
+            expect(result.user_id).to eq id
+          end
+        end
+      end
+
+      context 'having specified filters' do
+        per_page = 1
+
+        it 'retrieves list with specified parameters' do
+          results = MangoApi::Cards.of_user id do |filter|
+            filter.page = 1
+            filter.per_page = per_page
+            filter.sort_field = MangoPay::SortField::CREATION_DATE
+            filter.sort_direction = MangoPay::SortDirection::ASC
+          end
+
+          expect(results).to be_kind_of Array
+          expect(results.length).to eq per_page
+          results.each do |result|
+            expect(result).to be_kind_of MangoModel::Card
+            expect(result.id).not_to be_nil
+            expect(result.user_id).to eq id
+          end
+        end
+      end
+    end
+
+    # Currently disabled because it deactivates the only testing card.
+    # Works if ran alone.
+    #
+    # describe '.deactivate' do
+    #
+    #   context "given a valid card entity's ID" do
+    #     it 'deactivates the corresponding card entity' do
+    #       card = CARD
+    #       id = card.id
+    #       deactivated = MangoApi::Cards.deactivate id
+    #
+    #       expect(deactivated).to be_kind_of MangoModel::Card
+    #       expect(deactivated.id).to eq id
+    #       expect(deactivated.active).to be_falsey
+    #     end
+    #   end
+    # end
+  end
+end

data/spec/mangopay/client_wallets_spec.rb

@@ -0,0 +1,148 @@
+require_relative '../../lib/mangopay/api/service/client_wallets'
+require_relative '../../lib/mangopay/model/entity/client_wallet'
+require_relative '../../lib/mangopay/common/sort_field'
+require_relative '../../lib/mangopay/common/sort_direction'
+
+describe MangoApi::ClientWallets do
+
+  describe '.get' do
+
+    context 'from a correctly-configured environment' do
+      it "retrieves the environment's client's ClientWallet entities" do
+        funds_type = MangoModel::FundsType::CREDIT
+        currency = MangoModel::CurrencyIso::EUR
+        retrieved = MangoApi::ClientWallets.get(funds_type, currency)
+
+        expect(retrieved).to be_kind_of MangoModel::ClientWallet
+        expect(retrieved.funds_type).to be funds_type
+        expect(retrieved.currency).to be currency
+      end
+    end
+  end
+
+  describe '.all' do
+    default_per_page = 10
+
+    context 'not having specified filters' do
+      results = MangoApi::ClientWallets.all
+
+      it 'retrieves list with default parameters' do
+        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::ClientWallet
+        end
+      end
+    end
+
+    context 'having specified filters' do
+      per_page = 3
+      results = MangoApi::ClientWallets.all do |filter|
+        filter.page = 1
+        filter.per_page = per_page
+        filter.sort_field = MangoPay::SortField::CREATION_DATE
+        filter.sort_direction = MangoPay::SortDirection::ASC
+      end
+
+      it 'retrieves list according to provided parameters' do
+        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::ClientWallet
+          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
+
+  describe '.of_funds_type' do
+    default_per_page = 10
+
+    describe '#FEES' do
+      funds_type = MangoModel::FundsType::FEES
+      MangoApi::ClientWallets.get(funds_type, MangoModel::CurrencyIso::FKP)
+      MangoApi::ClientWallets.get(funds_type, MangoModel::CurrencyIso::LAK)
+      MangoApi::ClientWallets.get(funds_type, MangoModel::CurrencyIso::MMK)
+      MangoApi::ClientWallets.get(funds_type, MangoModel::CurrencyIso::NOK)
+      MangoApi::ClientWallets.get(funds_type, MangoModel::CurrencyIso::XBA)
+
+      context 'not having specified filters' do
+        it 'retrieves list with default parameters' do
+          results = MangoApi::ClientWallets.of_funds_type(funds_type)
+
+          check_results(results, default_per_page, funds_type)
+        end
+      end
+
+      context 'having specified filters' do
+        per_page = 3
+        results = MangoApi::ClientWallets.of_funds_type(funds_type) do |filter|
+          filter.page = 1
+          filter.per_page = per_page
+          filter.sort_field = MangoPay::SortField::CREATION_DATE
+          filter.sort_direction = MangoPay::SortDirection::ASC
+        end
+
+        it 'retrieves list according to provided parameters' do
+          check_results(results, per_page, funds_type)
+          results.each.with_index do |result, index|
+            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
+
+    describe '#CREDIT' do
+      funds_type = MangoModel::FundsType::FEES
+      MangoApi::ClientWallets.get(funds_type, MangoModel::CurrencyIso::FKP)
+      MangoApi::ClientWallets.get(funds_type, MangoModel::CurrencyIso::LAK)
+      MangoApi::ClientWallets.get(funds_type, MangoModel::CurrencyIso::MMK)
+      MangoApi::ClientWallets.get(funds_type, MangoModel::CurrencyIso::NOK)
+      MangoApi::ClientWallets.get(funds_type, MangoModel::CurrencyIso::XBA)
+
+      context 'not having specified filters' do
+        it 'retrieves list with default parameters' do
+          results = MangoApi::ClientWallets.of_funds_type(funds_type)
+
+          check_results(results, default_per_page, funds_type)
+        end
+      end
+
+      context 'having specified filters' do
+        per_page = 3
+        results = MangoApi::ClientWallets.of_funds_type(funds_type) do |filter|
+          filter.page = 1
+          filter.per_page = per_page
+          filter.sort_field = MangoPay::SortField::CREATION_DATE
+          filter.sort_direction = MangoPay::SortDirection::ASC
+        end
+
+        it 'retrieves list according to provided parameters' do
+          check_results(results, per_page, funds_type)
+          results.each.with_index do |result, index|
+            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
+end
+
+# noinspection RubyResolve
+def check_results(results, per_page, funds_type)
+  expect(results).to be_kind_of Array
+  expect(results.length).to eq per_page
+  results.each do |result|
+    expect(result).to be_kind_of MangoModel::ClientWallet
+    expect(result.funds_type).to be funds_type
+  end
+end

data/spec/mangopay/clients_spec.rb

@@ -0,0 +1,55 @@
+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
+end

data/spec/mangopay/configuration_spec.rb

@@ -0,0 +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
+end