leetchi-wallet-services 0.0.1

data/spec/lib/leetchi/beneficiary_spec.rb

@@ -0,0 +1,129 @@
+require_relative '../../spec_helper'
+
+describe Leetchi::Beneficiary do
+
+    let(:new_user) {
+        Leetchi::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+    }
+
+    let(:new_beneficiary) {
+        Leetchi::Beneficiary.create({
+            'Tag' => 'test',
+            'UserID' => new_user['ID'],
+            'BankAccountOwnerName' => new_user['FirstName'],
+            'BankAccountOwnerAddress' => '1 bis cite paradis',
+            'BankAccountIBAN' => 'FR76 1790 6000 3200 0833 5232 973',
+            'BankAccountBIC' => 'AGRIFRPP879'
+            })
+    }
+
+    let(:new_strong_authentication) {
+        Leetchi::Beneficiary.create_strong_authentication(new_beneficiary['ID'], {
+            'Tag' => 'test_beneficiary_strong_authentication'
+            })
+    }
+
+    before do
+        VCR.insert_cassette 'beneficiary', :record => :new_episodes
+    end
+    after do
+        VCR.eject_cassette
+    end
+
+    describe "CREATE" do
+        it "create a beneficiary" do
+            new_beneficiary['ID'].wont_be_nil
+            new_beneficiary['UserID'].must_equal new_user['ID']
+        end
+
+        it "fails and returns a 2004 error code" do
+            fail_beneficiary = Leetchi::Beneficiary.create({
+                'Tag' => 'test',
+                'UserID' => new_user['ID'],
+                'BankAccountOwnerAddress' => '1 bis cite paradis',
+                'BankAccountIBAN' => 'FR76 1790 6000 3200 0833 5232 973',
+                'BankAccountBIC' => 'AGRIFRPP879'
+                })
+            fail_beneficiary["ErrorCode"].must_equal 2004
+        end
+
+        it "fails and returns a 2005 error code" do
+            fail_beneficiary = Leetchi::Beneficiary.create({
+                'Tag' => 'test',
+                'UserID' => new_user['ID'],
+                'BankAccountOwnerName' => new_user['FirstName'],
+                'BankAccountIBAN' => 'FR76 1790 6000 3200 0833 5232 973',
+                'BankAccountBIC' => 'AGRIFRPP879'
+                })
+            fail_beneficiary["ErrorCode"].must_equal 2005
+        end
+
+        it "fail and returns a 2006 error code" do
+            fail_beneficiary = Leetchi::Beneficiary.create({
+                'Tag' => 'test',
+                'UserID' => new_user['ID'],
+                'BankAccountOwnerName' => new_user['FirstName'],
+                'BankAccountOwnerAddress' => '1 bis cite paradis',
+                'BankAccountIBAN' => 'FR76 1790 6000 3200 0833 5232 973',
+                'BankAccountBIC' => 'RPPdsakdnsajkdna79'
+                })
+            fail_beneficiary["ErrorCode"].must_equal 2006
+        end
+
+        it "fail and returns a 2007 error code" do
+            fail_beneficiary = Leetchi::Beneficiary.create({
+                'Tag' => 'test',
+                'UserID' => new_user['ID'],
+                'BankAccountOwnerName' => new_user['FirstName'],
+                'BankAccountOwnerAddress' => '1 bis cite paradis',
+                'BankAccountIBAN' => 'OIJDSAOIJDSAOIDJSAOIJDSA',
+                'BankAccountBIC' => 'AGRIFRPP879'
+                })
+            fail_beneficiary["ErrorCode"].must_equal 2007
+        end
+
+        it "fail and returns a 2008 error code" do
+            fail_beneficiary = Leetchi::Beneficiary.create({
+                'Tag' => 'test',
+                'UserID' => new_user['ID'],
+                'BankAccountOwnerName' => new_user['FirstName'],
+                'BankAccountOwnerAddress' => '1 bis cite paradis',
+                'BankAccountIBAN' => 'GB87 BARC 2065 8244 9716 55',
+                'BankAccountBIC' => 'CRLYFRPP'
+                })
+            fail_beneficiary["ErrorCode"].must_equal 2008
+        end
+    end
+
+    describe "GET" do
+        it "it gets a beneficiary" do
+            beneficiary = Leetchi::Beneficiary.details(new_beneficiary["ID"])
+            beneficiary["ID"].must_equal new_beneficiary['ID']
+        end
+    end
+
+    describe "StrongAuthentication" do
+      it "creates the beneficiary strong authentication request" do
+        new_strong_authentication.wont_be_nil
+    end
+    it "gets the beneficiary strong authentication request" do
+        strong_authentication = Leetchi::Beneficiary.get_strong_authentication(new_strong_authentication['ID'])
+        strong_authentication['ID'].must_equal new_strong_authentication['ID']
+    end
+    it "updated the beneficiary strong authentication request" do
+        strong_authentication = Leetchi::Beneficiary.update_strong_authentication(new_beneficiary['ID'], {
+            'Tag' => 'test_beneficiary_strong_authentication2',
+            'IsDocumentsTransmitted' => true
+            })
+        strong_authentication['ID'].must_equal new_strong_authentication['ID']
+        strong_authentication['Tag'].must_equal 'test_beneficiary_strong_authentication2'
+        strong_authentication['IsDocumentsTransmitted'].must_equal true
+    end
+end
+end

data/spec/lib/leetchi/card_spec.rb

@@ -0,0 +1,50 @@
+require_relative '../../spec_helper'
+
+describe Leetchi::Card do
+
+    let(:new_user) {
+        Leetchi::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+    }
+
+    let(:new_card) {
+        Leetchi::Card.create({
+            'Tag' => 'test-card',
+            'OwnerID' => new_user['ID'],
+            'ReturnURL' => 'http://leetchi.com'
+            })
+    }
+
+    before do
+        VCR.insert_cassette 'card', :record => :new_episodes
+    end
+    after do
+        VCR.eject_cassette
+    end
+
+    describe "CREATE" do
+        it "create a new card and return a redirect url" do
+            new_card['RedirectURL'].wont_be_empty
+        end
+    end
+
+    describe "GET" do
+        it "get the users card" do
+            card = Leetchi::Card.details(new_card["ID"])
+            card["ID"].must_equal new_card["ID"]
+        end
+    end
+
+    describe "DELETE" do
+        it "delete the card" do
+            deleted_card = Leetchi::Card.delete(new_card["ID"])
+            deleted_card.must_equal 'OK'
+        end
+    end
+
+end

data/spec/lib/leetchi/contribution_spec.rb

@@ -0,0 +1,64 @@
+require_relative '../../spec_helper'
+
+describe Leetchi::Contribution do
+
+    before do
+        VCR.insert_cassette 'contribution', :record => :new_episodes
+    end
+    after do
+        VCR.eject_cassette
+    end
+
+    let(:new_user) {
+        Leetchi::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+    }
+
+    let(:new_contribution) {
+        Leetchi::Contribution.create({
+            'Tag' => 'test_contribution',
+            'UserID' => new_user['ID'],
+            'WalletID' => 0,
+            'Amount' => 10000,
+            'ReturnURL' => 'https://leetchi.com',
+            'BankAccountBIC' => 'AGRIFRPP879'
+            })
+    }
+
+    let(:new_contribution_refund) {
+        Leetchi::Contribution.refund({
+            'ContributionID' => new_contribution['ID'],
+            'UserID' => new_user['ID'],
+            'Tag' => 'test_contribution_refund'
+            })
+    }
+
+    describe "CREATE" do
+        it "creates a contribution" do
+            new_contribution['ID'].wont_be_nil
+            new_contribution['PaymentURL'].wont_be_nil
+        end
+    end
+
+    describe "GET" do
+        it "get the contribution" do
+            contribution = Leetchi::Contribution.details(new_contribution['ID'])
+            contribution['ID'].must_equal new_contribution['ID']
+        end
+    end
+
+    describe "REFUND" do
+        it "creates a refund request for the contribution" do
+            new_contribution_refund['ID'].wont_be_nil
+        end
+        it "gets the refund request" do
+            contribution_refund = Leetchi::Contribution.get_refund(new_contribution_refund['ID'])
+            contribution_refund['ID'].must_equal new_contribution_refund['ID']
+        end
+    end
+end

data/spec/lib/leetchi/expense_spec.rb

@@ -0,0 +1,17 @@
+require_relative '../../spec_helper'
+
+describe Leetchi::Expense do
+
+    before do
+        VCR.insert_cassette 'expense', :record => :new_episodes
+    end
+    after do
+        VCR.eject_cassette
+    end
+
+    describe "GET" do
+        it "get the expense" do
+            card = Leetchi::Expense.get(1)
+        end
+    end
+end

data/spec/lib/leetchi/operation_spec.rb

@@ -0,0 +1,14 @@
+require_relative '../../spec_helper'
+
+describe Leetchi::Operation do
+    before do
+        VCR.insert_cassette 'operation', :record => :new_episodes
+    end
+    after do
+        VCR.eject_cassette
+    end
+
+    it "gets the operation" do
+        operation = Leetchi::Operation.get(1)
+    end
+end

data/spec/lib/leetchi/recurrent_contribution_spec.rb

@@ -0,0 +1,48 @@
+require_relative '../../spec_helper'
+
+describe Leetchi::RecurrentContribution do
+
+    let(:new_user) {
+        Leetchi::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+    }
+
+    let(:new_recurrent_contribution) {
+        Leetchi::RecurrentContribution.create({
+            'Tag' => 'test-recurrent-contribution',
+            'UserID' => new_user['ID'],
+            'WalletID' => 0,
+            'Amount' => 4200,
+            'StartDate' => '1388534400',
+            'FrequencyCode' => 'TwiceMonthly',
+            'NumberOfExecutions' => 10,
+            'ReturnURL' => 'http://leetchi.com'
+            })
+    }
+
+    before do
+        VCR.insert_cassette 'recurrent_contribution', :record => :new_episodes
+    end
+    after do
+        VCR.eject_cassette
+    end
+
+    describe "CREATE" do
+        it "create a new recurrent contribution and return a PaymentURL" do
+            new_recurrent_contribution['PaymentURL'].wont_be_empty
+        end
+    end
+
+    describe "GET" do
+        it "get a recurrent contribution" do
+            recurrent_contribution = Leetchi::RecurrentContribution.get(new_recurrent_contribution["ID"])
+            recurrent_contribution["ID"].must_equal new_recurrent_contribution["ID"]
+        end
+    end
+
+end

data/spec/lib/leetchi/ressource_spec.rb

@@ -0,0 +1,7 @@
+require_relative '../../spec_helper'
+
+describe Leetchi::Ressource do
+    it "must work" do
+        "Yay!".must_be_instance_of String
+    end
+end

data/spec/lib/leetchi/strong_authentication_spec.rb

@@ -0,0 +1,17 @@
+require_relative '../../spec_helper'
+
+describe Leetchi::StrongAuthentication do
+    before do
+        VCR.insert_cassette 'strong_authentication', :record => :new_episodes
+    end
+    after do
+        VCR.eject_cassette
+    end
+
+    describe "GET" do
+        it "get the pending strong authentication requests" do
+            strong_authentication = Leetchi::StrongAuthentication.get
+            strong_authentication.must_be_kind_of Array
+        end
+    end
+end

data/spec/lib/leetchi/transfer_spec.rb

@@ -0,0 +1,71 @@
+require_relative '../../spec_helper'
+
+describe Leetchi::Transfer do
+    before do
+        VCR.insert_cassette 'transfer', :record => :new_episodes
+    end
+    after do
+        VCR.eject_cassette
+    end
+
+    let(:new_payer) {
+        Leetchi::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+    }
+
+    let(:new_beneficiary) {
+        Leetchi::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+    }
+
+    let(:new_transfert) {
+        Leetchi::Transfer.create({
+            'Tag' => 'test transfer',
+            'PayerID' => new_payer['ID'],
+            'BeneficiaryID' => new_beneficiary['ID'],
+            'Amount' => 1000,
+            'PayerWalletID' => 0,
+            'BeneficiaryWalletID' => 0
+            })
+    }
+
+    let(:new_transfer_refund) {
+        Leetchi::Transfer.refund({
+            'TransferID' => new_transfert['ID'],
+            'UserID' => new_payer['ID']
+            })
+    }
+
+    describe "CREATE" do
+        it "create a transfer" do
+            new_transfert['ID'].wont_be_nil
+        end
+    end
+
+    describe "GET" do
+        it "gets the transfer" do
+            transfert = Leetchi::Transfer.details(new_transfert['ID'])
+            transfert['ID'].must_equal new_transfert['ID']
+        end
+    end
+
+    describe "REFUND" do
+        it "create a refund for the transfer" do
+            new_transfer_refund['ID'].wont_be_nil
+        end
+        it "gets a the transfer refund" do
+            transfer_refund = Leetchi::Transfer.get_refund(new_transfer_refund['ID'])
+            transfer_refund['ID'].must_equal new_transfer_refund['ID']
+        end
+    end
+end

data/spec/lib/leetchi/user_spec.rb

@@ -0,0 +1,130 @@
+require_relative '../../spec_helper'
+
+describe Leetchi::User do
+
+    let(:new_user) {
+        Leetchi::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+    }
+
+    let(:new_wallet) {
+        Leetchi::Wallet.create({
+            'Name' => 'test',
+            'Owners' => [ new_user['ID'] ],
+            'RaisingGoalAmount' => 12000
+            })
+    }
+
+    let(:new_strong_authentication) {
+        Leetchi::User.create_strong_authentication(new_user['ID'], {
+            'Tag' => 'test_strong_auth'
+            })
+    }
+
+    before do
+        VCR.insert_cassette 'user', :record => :new_episodes
+    end
+    after do
+        VCR.eject_cassette
+    end
+
+    describe "CREATE" do
+        it "create a user" do
+            new_user["FirstName"].must_equal 'John'
+            new_user["LastName"].must_equal 'Doe'
+            new_user["Email"].must_equal 'my@email.com'
+            new_user["CanRegisterMeanOfPayment"].must_equal true
+            new_user["ID"].wont_be_nil
+        end
+    end
+
+    describe "GET" do
+        it "gets the user infos" do
+            user = Leetchi::User.details(new_user["ID"])
+
+            user["FirstName"].must_equal new_user["FirstName"]
+            user["LastName"].must_equal new_user["LastName"]
+            user["Email"].must_equal new_user["Email"]
+            user["ID"].must_equal new_user["ID"]
+        end
+    end
+
+    describe "UPDATE" do
+        it "update the user infos" do
+            user = Leetchi::User.update(new_user["ID"], {
+                'Tag' => 'test-update',
+                'Email' => 'mynew@email.com',
+                'FirstName' => 'Jack',
+                'LastName' => 'Black',
+                'CanRegisterMeanOfPayment' => false
+                })
+            user["FirstName"].must_equal 'Jack'
+            user["LastName"].must_equal 'Black'
+            user["Email"].must_equal 'mynew@email.com'
+            user["CanRegisterMeanOfPayment"].must_equal false
+            user["ID"].must_equal new_user["ID"]
+        end
+    end
+
+    describe "GET_WALLETS" do
+        it "get an empty list of wallets" do
+            wallets = Leetchi::User.get_wallets(new_user["ID"])
+            wallets.must_be_empty
+        end
+        it "gets a new wallet for the user" do
+            new_wallet
+            wallets = Leetchi::User.get_wallets(new_user['ID'])
+            wallets.wont_be_empty
+            wallets[0]["Owners"][0].must_equal new_user['ID']
+        end
+    end
+
+    describe "CARDS" do
+        it "gets the user cards" do
+            cards = Leetchi::User.cards(new_user["ID"])
+            cards.must_be_empty
+        end
+    end
+
+    describe "OPERATIONS" do
+        it "gets all the users operations" do
+            operations = Leetchi::User.operations(new_user['ID'])
+            operations.must_be_empty
+        end
+        it "gets all the users personal operation" do
+            personal_operations = Leetchi::User.personal_operations(new_user['ID'])
+            personal_operations.must_be_empty
+        end
+    end
+
+    describe "STRONG_AUTHENTICATION" do
+        it "creates a new strong authentication request" do
+            new_strong_authentication['ID'].wont_be_nil
+        end
+        it "gets the user strong authentication request" do
+            strong_authentication = Leetchi::User.get_strong_authentication(new_user['ID'])
+            strong_authentication['ID'].must_equal new_strong_authentication['ID']
+        end
+        it "updates the user strong authentication request" do
+            strong_authentication = Leetchi::User.update_strong_authentication(new_user['ID'], {
+                    'Tag' => 'test_strong_authentication2',
+                    'IsDocumentsTransmitted' => true
+                })
+            strong_authentication['ID'].must_equal new_strong_authentication['ID']
+            strong_authentication['Tag'].must_equal 'test_strong_authentication2'
+            strong_authentication['IsDocumentsTransmitted'].must_equal true
+        end
+    end
+
+    describe "EXPENSE_SITES" do
+      it "get the expense sites for the given user" do
+        expense_sites = Leetchi::User.expense_sites(new_user['ID'], new_wallet['ID'])
+        expense_sites.must_be_kind_of Array
+      end
+    end
+end