aggcat 0.1.1 → 0.1.2

data/lib/aggcat/base.rb

@@ -68,7 +68,7 @@ module Aggcat
       signed_info = %[<ds:SignedInfo xmlns:ds="http://www.w3.org/2000/09/xmldsig#"><ds:CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/><ds:SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/><ds:Reference URI="#_#{reference_id}"><ds:Transforms><ds:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/><ds:Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/></ds:Transforms><ds:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/><ds:DigestValue>#{encoded_digest.strip}</ds:DigestValue></ds:Reference></ds:SignedInfo>]
       signature_value = Nokogiri::XML(signed_info).canonicalize
       key = OpenSSL::PKey::RSA.new(File.read(@certificate_path))
-      encoded_signature_value = Base64.encode64(key.sign(OpenSSL::Digest::SHA1.new, signature_value)).gsub!(/\n/, '')
+      encoded_signature_value = Base64.encode64(key.sign(OpenSSL::Digest::SHA1.new, signature_value)).gsub(/\n/, '')
       Base64.encode64(assertion % [encoded_digest, encoded_signature_value])
     end
 

data/lib/aggcat/client.rb

@@ -42,11 +42,11 @@ module Aggcat
 
     def account_transactions(account_id, start_date, end_date = nil)
       validate(account_id: account_id, start_date: start_date)
-      uri = "/accounts/#{account_id}/transactions?txnStartDate=#{start_date.strftime(DATE_FORMAT)}"
+      path = "/accounts/#{account_id}/transactions?txnStartDate=#{start_date.strftime(DATE_FORMAT)}"
       if end_date
-        uri += "&txnEndDate=#{end_date.strftime(DATE_FORMAT)}"
+        path += "&txnEndDate=#{end_date.strftime(DATE_FORMAT)}"
       end
-      get(uri)
+      get(path)
     end
 
     def update_login(institution_id, login_id, username, password)
@@ -72,27 +72,27 @@ module Aggcat
 
     protected
 
-    def get(uri, headers = {})
-      request(:get, uri, headers)
+    def get(path, headers = {})
+      request(:get, path, headers)
     end
 
-    def post(uri, body, headers = {})
-      request(:post, uri, body, headers.merge({'Content-Type' => 'application/xml'}))
+    def post(path, body, headers = {})
+      request(:post, path, body, headers.merge({'Content-Type' => 'application/xml'}))
     end
 
-    def put(uri, body, headers = {})
-      request(:put, uri, body, headers.merge({'Content-Type' => 'application/xml'}))
+    def put(path, body, headers = {})
+      request(:put, path, body, headers.merge({'Content-Type' => 'application/xml'}))
     end
 
-    def delete(uri, headers = {})
-      request(:delete, uri, headers.merge({'Content-Type' => 'application/xml'}))
+    def delete(path, headers = {})
+      request(:delete, path, headers.merge({'Content-Type' => 'application/xml'}))
     end
 
     private
 
-    def request(method, uri, *options)
-      response = oauth_client.send(method.to_sym, BASE_URL + uri, *options)
-      result = {:response_code => response.code, :response => parse_xml(response.body)}
+    def request(method, path, *options)
+      response = oauth_client.send(method.to_sym, BASE_URL + path, *options)
+      result = {:status_code => response.code, :result => parse_xml(response.body)}
       if response['challengeSessionId']
         result[:challenge_session_id] = response['challengeSessionId']
         result[:challenge_node_id] = response['challengeNodeId']
@@ -110,7 +110,7 @@ module Aggcat
 
     def credentials(institution_id, username, password)
       institution = institution(institution_id)
-      keys = institution[:response][:institution_detail][:keys][:key].sort { |a, b| a[:display_order] <=> b[:display_order] }
+      keys = institution[:result][:institution_detail][:keys][:key].sort { |a, b| a[:display_order] <=> b[:display_order] }
       hash = {
           keys[0][:name] => username,
           keys[1][:name] => password

data/lib/aggcat/version.rb

@@ -1,3 +1,3 @@
 module Aggcat
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/test/aggcat/aggcat_test.rb

@@ -49,6 +49,6 @@ class AggcatTest < Test::Unit::TestCase
     Aggcat.scope('1')
     stub_get('/institutions').to_return(:body => fixture('institutions.xml'), :headers => {:content_type => 'application/xml; charset=utf-8'})
     response = Aggcat.institutions
-    assert_equal response[:response][:institutions][:institution][0][:institution_id].to_i, 100000
+    assert_equal response[:result][:institutions][:institution][0][:institution_id].to_i, 100000
   end
 end

data/test/aggcat/client_test.rb

@@ -17,22 +17,21 @@ class ClientTest < Test::Unit::TestCase
   def test_institutions
     stub_get('/institutions').to_return(:body => fixture('institutions.xml'), :headers => {:content_type => 'application/xml; charset=utf-8'})
     response = @client.institutions
-    assert_equal response[:response][:institutions][:institution][0][:institution_id].to_i, 100000
+    assert_equal response[:result][:institutions][:institution][0][:institution_id].to_i, 100000
   end
 
   def test_institution
     institution_id = '100000'
     stub_get("/institutions/#{institution_id}").to_return(:body => fixture('institution.xml'), :headers => {:content_type => 'application/xml; charset=utf-8'})
     response = @client.institution(institution_id)
-    assert_equal institution_id, response[:response][:institution_detail][:institution_id]
+    assert_equal institution_id, response[:result][:institution_detail][:institution_id]
   end
 
   def test_institution_with_bad_args
-    exception = assert_raise(ArgumentError) { @client.institution(nil) }
-    assert_equal('institution_id is required', exception.message)
-
-    exception = assert_raise(ArgumentError) { @client.institution('') }
-    assert_equal('institution_id is required', exception.message)
+    [nil, ''].each do |arg|
+      exception = assert_raise(ArgumentError) { @client.institution(arg) }
+      assert_equal('institution_id is required', exception.message)
+    end
   end
 
   def test_discover_and_add_accounts
@@ -40,8 +39,8 @@ class ClientTest < Test::Unit::TestCase
     stub_get("/institutions/#{institution_id}").to_return(:body => fixture('institution.xml'), :headers => {:content_type => 'application/xml; charset=utf-8'})
     stub_post("/institutions/#{institution_id}/logins").to_return(:body => fixture('account.xml'), :headers => {:content_type => 'application/xml; charset=utf-8'})
     response = @client.discover_and_add_accounts(institution_id, 'username', 'password')
-    assert_equal institution_id, response[:response][:account_list][:banking_account][:institution_id]
-    assert_equal '000000000001', response[:response][:account_list][:banking_account][:account_id]
+    assert_equal institution_id, response[:result][:account_list][:banking_account][:institution_id]
+    assert_equal '000000000001', response[:result][:account_list][:banking_account][:account_id]
   end
 
   def test_discover_and_add_accounts_with_challenge
@@ -49,50 +48,42 @@ class ClientTest < Test::Unit::TestCase
     stub_get("/institutions/#{institution_id}").to_return(:body => fixture('institution.xml'), :headers => {:content_type => 'application/xml; charset=utf-8'})
     stub_post("/institutions/#{institution_id}/logins").to_return(:code => 401, :body => fixture('account.xml'), :headers => {:content_type => 'application/xml; charset=utf-8'})
     response = @client.discover_and_add_accounts(institution_id, 'username', 'password')
-    assert_equal institution_id, response[:response][:account_list][:banking_account][:institution_id]
-    assert_equal '000000000001', response[:response][:account_list][:banking_account][:account_id]
+    assert_equal institution_id, response[:result][:account_list][:banking_account][:institution_id]
+    assert_equal '000000000001', response[:result][:account_list][:banking_account][:account_id]
   end
 
   def test_discover_and_add_accounts_bad_args
-    exception = assert_raise(ArgumentError) { @client.discover_and_add_accounts(nil, 'username', 'password') }
-    assert_equal('institution_id is required', exception.message)
-
-    exception = assert_raise(ArgumentError) { @client.discover_and_add_accounts('', 'username', 'password') }
-    assert_equal('institution_id is required', exception.message)
-
-    exception = assert_raise(ArgumentError) { @client.discover_and_add_accounts(1, nil, 'password') }
-    assert_equal('username is required', exception.message)
-
-    exception = assert_raise(ArgumentError) { @client.discover_and_add_accounts(1, '', 'password') }
-    assert_equal('username is required', exception.message)
+    [nil, ''].each do |arg|
+      exception = assert_raise(ArgumentError) { @client.discover_and_add_accounts(arg, 'username', 'password') }
+      assert_equal('institution_id is required', exception.message)
 
-    exception = assert_raise(ArgumentError) { @client.discover_and_add_accounts(1, 'username', nil) }
-    assert_equal('password is required', exception.message)
+      exception = assert_raise(ArgumentError) { @client.discover_and_add_accounts(1, arg, 'password') }
+      assert_equal('username is required', exception.message)
 
-    exception = assert_raise(ArgumentError) { @client.discover_and_add_accounts(1, 'username', '') }
-    assert_equal('password is required', exception.message)
+      exception = assert_raise(ArgumentError) { @client.discover_and_add_accounts(1, 'username', arg) }
+      assert_equal('password is required', exception.message)
+    end
   end
 
   def test_account
     account_id = '000000000001'
     stub_get("/accounts/#{account_id}").to_return(:body => fixture('account.xml'), :headers => {:content_type => 'application/xml; charset=utf-8'})
     response = @client.account(account_id)
-    assert_equal account_id, response[:response][:account_list][:banking_account][:account_id]
+    assert_equal account_id, response[:result][:account_list][:banking_account][:account_id]
   end
 
   def test_account_bad_args
-    exception = assert_raise(ArgumentError) { @client.account(nil) }
-    assert_equal('account_id is required', exception.message)
-
-    exception = assert_raise(ArgumentError) { @client.account('') }
-    assert_equal('account_id is required', exception.message)
+    [nil, ''].each do |arg|
+      exception = assert_raise(ArgumentError) { @client.account(arg) }
+      assert_equal('account_id is required', exception.message)
+    end
   end
 
   def test_accounts
     stub_get('/accounts').to_return(:body => fixture('accounts.xml'), :headers => {:content_type => 'application/xml; charset=utf-8'})
     response = @client.accounts
-    assert_equal '11111', response[:response][:account_list][:banking_account][0][:institution_id]
-    assert_equal '75000033002', response[:response][:account_list][:banking_account][0][:account_id]
+    assert_equal '11111', response[:result][:account_list][:banking_account][0][:institution_id]
+    assert_equal '75000033002', response[:result][:account_list][:banking_account][0][:account_id]
   end
 
   def test_account_transactions
@@ -101,7 +92,7 @@ class ClientTest < Test::Unit::TestCase
     uri = "/accounts/#{account_id}/transactions?txnStartDate=#{start_date.strftime(Aggcat::Base::DATE_FORMAT)}"
     stub_get(uri).to_return(:body => fixture('transactions.xml'), :headers => {:content_type => 'application/xml; charset=utf-8'})
     response = @client.account_transactions(account_id, start_date)
-    assert_equal '75000088503', response[:response][:transaction_list][:credit_card_transaction][:id]
+    assert_equal '75000088503', response[:result][:transaction_list][:credit_card_transaction][:id]
   end
 
   def test_account_transactions_with_dates
@@ -113,44 +104,39 @@ class ClientTest < Test::Unit::TestCase
     uri = "/accounts/#{account_id}/transactions?txnStartDate=#{start_date.strftime(Aggcat::Base::DATE_FORMAT)}&txnEndDate=#{end_date.strftime(Aggcat::Base::DATE_FORMAT)}"
     stub_get(uri).to_return(:body => fixture('transactions.xml'), :headers => {:content_type => 'application/xml; charset=utf-8', :challengeSessionId => challenge_session_id, :challengeNodeId => challenge_node_id})
     response = @client.account_transactions(account_id, start_date, end_date)
-    assert_equal '75000088503', response[:response][:transaction_list][:credit_card_transaction][:id]
+    assert_equal '75000088503', response[:result][:transaction_list][:credit_card_transaction][:id]
     assert_equal response[:challenge_session_id], challenge_session_id
     assert_equal response[:challenge_node_id], challenge_node_id
   end
 
   def test_account_transactions_bad_args
-    exception = assert_raise(ArgumentError) { @client.account_transactions(nil, Date.today) }
-    assert_equal('account_id is required', exception.message)
-
-    exception = assert_raise(ArgumentError) { @client.account_transactions('', Date.today) }
-    assert_equal('account_id is required', exception.message)
+    [nil, ''].each do |arg|
+      exception = assert_raise(ArgumentError) { @client.account_transactions(arg, Date.today) }
+      assert_equal('account_id is required', exception.message)
 
-    exception = assert_raise(ArgumentError) { @client.account_transactions(1, nil) }
-    assert_equal('start_date is required', exception.message)
-
-    exception = assert_raise(ArgumentError) { @client.account_transactions(1, '') }
-    assert_equal('start_date is required', exception.message)
+      exception = assert_raise(ArgumentError) { @client.account_transactions(1, arg) }
+      assert_equal('start_date is required', exception.message)
+    end
   end
 
   def test_delete_account
     account_id = '000000000001'
     stub_delete("/accounts/#{account_id}").to_return(:status => 200)
     response = @client.delete_account(account_id)
-    assert_equal '200', response[:response_code]
+    assert_equal '200', response[:status_code]
   end
 
   def test_delete_account_bad_args
-    exception = assert_raise(ArgumentError) { @client.delete_account(nil) }
-    assert_equal('account_id is required', exception.message)
-
-    exception = assert_raise(ArgumentError) { @client.delete_account('') }
-    assert_equal('account_id is required', exception.message)
+    [nil, ''].each do |arg|
+      exception = assert_raise(ArgumentError) { @client.delete_account(arg) }
+      assert_equal('account_id is required', exception.message)
+    end
   end
 
   def test_delete_customer
     stub_delete('/customers').to_return(:status => 200)
     response = @client.delete_customer
-    assert_equal '200', response[:response_code]
+    assert_equal '200', response[:status_code]
   end
 
   def test_update_login
@@ -159,33 +145,23 @@ class ClientTest < Test::Unit::TestCase
     stub_get("/institutions/#{institution_id}").to_return(:body => fixture('institution.xml'), :headers => {:content_type => 'application/xml; charset=utf-8'})
     stub_put("/logins/#{login_id}?refresh=true").to_return(:status => 200)
     response = @client.update_login(institution_id, login_id, 'usename', 'password')
-    assert_equal '200', response[:response_code]
+    assert_equal '200', response[:status_code]
   end
 
   def test_update_login_bad_args
-    exception = assert_raise(ArgumentError) { @client.update_login(nil, 1, 'username', 'password') }
-    assert_equal('institution_id is required', exception.message)
-
-    exception = assert_raise(ArgumentError) { @client.update_login('', 1, 'username', 'password') }
-    assert_equal('institution_id is required', exception.message)
+    [nil, ''].each do |arg|
+      exception = assert_raise(ArgumentError) { @client.update_login(arg, 1, 'username', 'password') }
+      assert_equal('institution_id is required', exception.message)
 
-    exception = assert_raise(ArgumentError) { @client.update_login(1, nil, 'username', 'password') }
-    assert_equal('login_id is required', exception.message)
+      exception = assert_raise(ArgumentError) { @client.update_login(1, arg, 'username', 'password') }
+      assert_equal('login_id is required', exception.message)
 
-    exception = assert_raise(ArgumentError) { @client.update_login(1, '', 'username', 'password') }
-    assert_equal('login_id is required', exception.message)
+      exception = assert_raise(ArgumentError) { @client.update_login(1, 1, arg, 'password') }
+      assert_equal('username is required', exception.message)
 
-    exception = assert_raise(ArgumentError) { @client.update_login(1, 1, nil, 'password') }
-    assert_equal('username is required', exception.message)
-
-    exception = assert_raise(ArgumentError) { @client.update_login(1, 1, '', 'password') }
-    assert_equal('username is required', exception.message)
-
-    exception = assert_raise(ArgumentError) { @client.update_login(1, 1, 'username', nil) }
-    assert_equal('password is required', exception.message)
-
-    exception = assert_raise(ArgumentError) { @client.update_login(1, 1, 'username', '') }
-    assert_equal('password is required', exception.message)
+      exception = assert_raise(ArgumentError) { @client.update_login(1, 1, 'username', arg) }
+      assert_equal('password is required', exception.message)
+    end
   end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aggcat
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors: