leetchi-wallet-services 1.0.0 → 1.1.0

data/spec/lib/leetchi/card_spec.rb

@@ -1,8 +1,6 @@
 require_relative '../../spec_helper'
 
-describe Leetchi::Card do
-
-    include Capybara::DSL
+describe Leetchi::Card, :type => :feature do
 
     let(:new_user) {
         Leetchi::User.create({
@@ -24,34 +22,30 @@ describe Leetchi::Card do
         fill_in('number', :with => '4970100000000154')
         fill_in('cvv', :with => '123')
         click_button('paybutton')
-        page.driver.render('/Users/glorieux/Desktop/file.png')
+        card = Leetchi::Card.details(card['ID'])
+        while card["IsSucceeded"] == false do
+            card = Leetchi::Card.details(card['ID'])
+        end
         card
     end
 
-    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
+            expect(new_card['RedirectURL']).not_to 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"]
+            expect(card["ID"]).to eq(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\""
+            expect(deleted_card).to eq("\"OK\"")
         end
     end
 

data/spec/lib/leetchi/contribution_spec.rb

@@ -1,15 +1,6 @@
 require_relative '../../spec_helper'
 
-describe Leetchi::Contribution do
-
-    include Capybara::DSL
-
-    before do
-        VCR.insert_cassette 'contribution', :record => :new_episodes
-    end
-    after do
-        VCR.eject_cassette
-    end
+describe Leetchi::Contribution, :type => :feature do
 
     let(:new_user) {
         Leetchi::User.create({
@@ -27,13 +18,16 @@ describe Leetchi::Contribution do
             'UserID' => new_user['ID'],
             'WalletID' => 0,
             'Amount' => 10000,
-            'ReturnURL' => 'https://leetchi.com',
-            'BankAccountBIC' => 'AGRIFRPP879'
+            'ReturnURL' => 'https://leetchi.com'
             })
         visit(contribution['PaymentURL'])
         fill_in('number', :with => '4970100000000154')
         fill_in('cvv', :with => '123')
         click_button('paybutton')
+        contribution = Leetchi::Contribution.details(contribution['ID'])
+        while contribution["IsSucceeded"] == false do
+            contribution = Leetchi::Contribution.details(contribution['ID'])
+        end
         contribution
     end
 
@@ -47,25 +41,25 @@ describe Leetchi::Contribution do
 
     describe "CREATE" do
         it "creates a contribution" do
-            new_contribution['ID'].wont_be_nil
-            new_contribution['PaymentURL'].wont_be_nil
+            expect(new_contribution['ID']).not_to be_nil
+            expect(new_contribution['PaymentURL']).not_to 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']
+            expect(contribution['ID']).to eq(new_contribution['ID'])
         end
     end
 
     describe "REFUND" do
         it "creates a refund request for the contribution" do
-            new_contribution_refund['ID'].wont_be_nil
+            expect(new_contribution_refund['ID']).not_to 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']
+            expect(contribution_refund['ID']).to eq(new_contribution_refund['ID'])
         end
     end
 end

data/spec/lib/leetchi/expense_spec.rb

@@ -2,13 +2,6 @@ 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)

data/spec/lib/leetchi/operation_spec.rb

@@ -1,12 +1,6 @@
 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)

data/spec/lib/leetchi/recurrent_contribution_spec.rb

@@ -1,48 +1,55 @@
-# require_relative '../../spec_helper'
+require_relative '../../spec_helper'
 
-# describe Leetchi::RecurrentContribution do
+describe Leetchi::RecurrentContribution do
 
-#     let(:new_user) {
-#         Leetchi::User.create({
-#             'Tag' => 'test',
-#             'Email' => 'my@email.com',
-#             'FirstName' => 'John',
-#             'LastName' => 'Doe',
-#             'CanRegisterMeanOfPayment' => true
-#             })
-#     }
+    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'
-#             })
-#     }
+    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
+            expect(new_recurrent_contribution['PaymentURL']).not_to be_empty
+        end
+    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"])
+            expect(recurrent_contribution["ID"]).to eq(new_recurrent_contribution["ID"])
+        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
+    describe "UPDATE" do
+        it "updates a recurrent contribution" do
+            recurrent_contribution = Leetchi::RecurrentContribution.update(new_recurrent_contribution["ID"], { :IsEnabled => false })
+            expect(recurrent_contribution["IsEnabled"]).to be_false
+        end
+    end
 
-# end
+    describe "GET_EXECUTIONS" do
+        it "get a list of the recurrent contribution executions" do
+            recurrent_contribution_executions = Leetchi::RecurrentContribution.get_executions(new_recurrent_contribution["ID"])
+            expect(recurrent_contribution_executions).to be_a_kind_of(Array)
+            expect(recurrent_contribution_executions).to be_empty
+        end
+    end
+end

data/spec/lib/leetchi/ressource_spec.rb

@@ -1,7 +1,5 @@
 require_relative '../../spec_helper'
 
 describe Leetchi::Ressource do
-    it "must work" do
-        "Yay!".must_be_instance_of String
-    end
+    pending "It should test the ressource"
 end

data/spec/lib/leetchi/strong_authentication_spec.rb

@@ -1,17 +1,57 @@
 require_relative '../../spec_helper'
 
 describe Leetchi::StrongAuthentication do
-    before do
-        VCR.insert_cassette 'strong_authentication', :record => :new_episodes
-    end
-    after do
-        VCR.eject_cassette
+
+  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'
+      })
+  }
+
+  describe "GET" do
+    it "get the pending strong authentication requests" do
+      strong_authentication = Leetchi::StrongAuthentication.get
+      expect(strong_authentication).to be_kind_of(Array)
     end
+  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
+  describe "UPLOAD" do
+    it "uploads a PDF file to complete a beneficiary strong authentication request" do
+      document_upload = Leetchi::StrongAuthentication.upload(new_strong_authentication['UrlRequest'], 'spec/support-files/test_upload.pdf')
+      expect(document_upload).to be_true
+    end
+    it "uploads a JPG file to complete a beneficiary strong authentication request" do
+      document_upload = Leetchi::StrongAuthentication.upload(new_strong_authentication['UrlRequest'], 'spec/support-files/test_upload.jpg')
+      expect(document_upload).to be_true
+    end
+    it "uploads a PNG file to complete a beneficiary strong authentication request" do
+      document_upload = Leetchi::StrongAuthentication.upload(new_strong_authentication['UrlRequest'], 'spec/support-files/test_upload.png')
+      expect(document_upload).to be_true
+    end
+    it "uploads a GIF file to complete a beneficiary strong authentication request" do
+      document_upload = Leetchi::StrongAuthentication.upload(new_strong_authentication['UrlRequest'], 'spec/support-files/test_upload.gif')
+      expect(document_upload).to be_true
     end
+  end
 end

data/spec/lib/leetchi/transfer_spec.rb

@@ -1,15 +1,6 @@
 require_relative '../../spec_helper'
 
-describe Leetchi::Transfer do
-
-    include Capybara::DSL
-
-    before do
-        VCR.insert_cassette 'transfer', :record => :new_episodes
-    end
-    after do
-        VCR.eject_cassette
-    end
+describe Leetchi::Transfer, :type => :feature do
 
     let(:new_payer) {
         user = Leetchi::User.create({
@@ -31,6 +22,10 @@ describe Leetchi::Transfer do
         fill_in('number', :with => '4970100000000154')
         fill_in('cvv', :with => '123')
         click_button('paybutton')
+        contribution = Leetchi::Contribution.details(contribution['ID'])
+        while contribution["IsSucceeded"] == false do
+            contribution = Leetchi::Contribution.details(contribution['ID'])
+        end
         user
     }
 
@@ -70,24 +65,24 @@ describe Leetchi::Transfer do
 
     describe "CREATE" do
         it "create a transfer" do
-            new_transfert['ID'].wont_be_nil
+            expect(new_transfert['ID']).not_to 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']
+            expect(transfert['ID']).to eq(new_transfert['ID'])
         end
     end
 
     describe "REFUND" do
         it "create a refund for the transfer" do
-            new_transfer_refund['ID'].wont_be_nil
+            expect(new_transfer_refund['ID']).not_to 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']
+            expect(transfer_refund['ID']).to eq(new_transfer_refund['ID'])
         end
     end
 end

data/spec/lib/leetchi/user_spec.rb

@@ -26,20 +26,13 @@ describe Leetchi::User do
             })
     }
 
-    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
+            expect(new_user["FirstName"]).to eq('John')
+            expect(new_user["LastName"]).to eq('Doe')
+            expect(new_user["Email"]).to eq('my@email.com')
+            expect(new_user["CanRegisterMeanOfPayment"]).to be_true
+            expect(new_user["ID"]).not_to be_nil
         end
     end
 
@@ -47,10 +40,10 @@ describe Leetchi::User 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"]
+            expect(user["FirstName"]).to eq(new_user["FirstName"])
+            expect(user["LastName"]).to eq(new_user["LastName"])
+            expect(user["Email"]).to eq(new_user["Email"])
+            expect(user["ID"]).to eq(new_user["ID"])
         end
     end
 
@@ -63,69 +56,69 @@ describe Leetchi::User do
                 '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"]
+            expect(user["FirstName"]).to eq('Jack')
+            expect(user["LastName"]).to eq('Black')
+            expect(user["Email"]).to eq('mynew@email.com')
+            expect(user["CanRegisterMeanOfPayment"]).to be_false
+            expect(user["ID"]).to eq(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
+            expect(wallets).to 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']
+            expect(wallets).not_to be_empty
+            expect(wallets[0]["Owners"][0]).to eq(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
+            expect(cards).to 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
+            expect(operations).to 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
+            expect(personal_operations).to be_empty
         end
     end
 
     describe "STRONG_AUTHENTICATION" do
         it "creates a new strong authentication request" do
-            new_strong_authentication['ID'].wont_be_nil
+            expect(new_strong_authentication['ID']).not_to be_nil
         end
         it "gets the user strong authentication request" do
             strong_authentication = Leetchi::User.get_strong_authentication(new_strong_authentication['UserID'])
-            strong_authentication['ID'].must_equal new_strong_authentication['ID']
+            expect(strong_authentication['ID']).to eq(new_strong_authentication['ID'])
         end
         it "updates the user strong authentication request" do
             strong_authentication = Leetchi::User.update_strong_authentication(new_strong_authentication['UserID'], {
                     'Tag' => 'test_strong_authentication2',
                     'IsDocumentsTransmitted' => true
                 })
-            strong_authentication['ID'].must_equal new_strong_authentication['ID']
-            strong_authentication['UserID'].must_equal new_strong_authentication['UserID']
-            strong_authentication['Tag'].must_equal 'test_strong_authentication2'
-            strong_authentication['IsDocumentsTransmitted'].must_equal true
+            expect(strong_authentication['ID']).to eq(new_strong_authentication['ID'])
+            expect(strong_authentication['UserID']).to eq(new_strong_authentication['UserID'])
+            expect(strong_authentication['Tag']).to eq('test_strong_authentication2')
+            expect(strong_authentication['IsDocumentsTransmitted']).to be_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
+        expect(expense_sites).to be_kind_of(Array)
       end
     end
 end