finicity 0.1.0

data/lib/finicity/v1/request/interactive_refresh_account_with_mfa.rb

@@ -0,0 +1,74 @@
+module Finicity::V1
+  module Request
+    class InteractiveRefreshAccountWithMfa
+      include ::Finicity::Logger
+      extend ::HTTPClient::IncludeClient
+      include_http_client do |client|
+        client.cookie_manager = nil
+      end
+
+      ##
+      # Attributes
+      #
+      attr_accessor :account_id,
+        :customer_id,
+        :mfa_credentials,
+        :mfa_session,
+        :token
+
+      ##
+      # Instance Methods
+      #
+      def initialize(token, mfa_session, customer_id, account_id, mfa_credentials)
+        @account_id = account_id
+        @customer_id = customer_id
+        @mfa_credentials = mfa_credentials
+        @mfa_session = mfa_session
+        @token = token
+      end
+
+      def interactive_refresh_account_with_mfa
+        http_client.post(url, body, headers)
+      end
+
+      def body
+        builder = ::Nokogiri::XML::Builder.new do |xml|
+          xml.mfaChallenges {
+            xml.questions {
+              mfa_credentials.each do |mfa_credential|
+                xml.question {
+                  xml.text_(mfa_credential[:text])
+                  xml.answer(mfa_credential[:answer])
+                }
+              end
+            }
+          }
+        end
+
+        builder.to_xml
+      end
+
+      def headers
+        {
+          'Finicity-App-Key' => ::Finicity.config.app_key,
+          'Finicity-App-Token' => token,
+          'MFA-Session' => mfa_session,
+          'Content-Type' => 'application/xml'
+        }
+      end
+
+      def url
+        ::URI.join(
+          ::Finicity.config.base_url,
+          'v1/',
+          'customers/',
+          "#{customer_id}/",
+          'accounts/',
+          "#{account_id}/",
+          'mfa'
+        )
+      end
+
+    end
+  end
+end

data/lib/finicity/v1/request/refresh_accounts.rb

@@ -0,0 +1,47 @@
+module Finicity::V1
+  module Request
+    class RefreshAccounts
+      include ::Finicity::Logger
+      extend ::HTTPClient::IncludeClient
+      include_http_client do |client|
+        client.cookie_manager = nil
+      end
+
+      ##
+      # Attributes
+      #
+      attr_accessor :customer_id,
+        :token
+
+      ##
+      # Instance Methods
+      #
+      def initialize(token, customer_id)
+        @customer_id = customer_id
+        @token = token
+      end
+
+      def refresh_accounts
+        http_client.post(url, nil, headers)
+      end
+
+      def headers
+        {
+          'Finicity-App-Key' => ::Finicity.config.app_key,
+          'Finicity-App-Token' => token
+        }
+      end
+
+      def url
+        ::URI.join(
+          ::Finicity.config.base_url,
+          'v1/',
+          'customers/',
+          "#{customer_id}/",
+          'accounts'
+        )
+      end
+
+    end
+  end
+end

data/lib/finicity/v1/response/accounts.rb

@@ -0,0 +1,75 @@
+module Finicity::V1
+  module Response
+    class Account
+      include ::Saxomattic
+
+      ##
+      # Saxomattic Attributes
+      #
+      attribute :id
+      attribute :number, :type => ::Integer
+      attribute :name
+      attribute :balance, :type => ::Float
+      attribute :type
+      attribute :aggregationStatusCode, :type => ::Integer, :as => :aggregation_status_code
+      attribute :status, :type => ::Integer
+      attribute :customerId, :as => :customer_id
+      attribute :institutionId, :as => :institution_id
+      attribute :balanceDate, :type => ::Integer
+      attribute :aggregationSuccessDate, :type => ::Integer
+      attribute :aggregationAttemptDate, :type => ::Integer
+      attribute :createdDate, :type => ::Integer
+      attribute :paymentMinAmount, :type => ::Float, :as => :payment_min_amount
+      attribute :paymentDueDate, :type => ::Integer
+      attribute :statementCloseBalance, :type => ::Float, :as => :statement_close_balance
+      attribute :statementEndDate, :type => ::Integer
+
+      ##
+      # Instance Methods
+      #
+      def aggregation_success_date
+        aggreagtionSuccessDate ? ::Time.at(aggregationSuccessDate).utc : nil
+      end
+
+      def aggregation_attempt_date
+        aggreagtionAttemptDate ? ::Time.at(aggregationAttemptDate).utc : nil
+      end
+
+      def balance_date
+        balanceDate ? ::Time.at(balanceDate).utc : nil
+      end
+
+      def created_date
+        createdDate ? ::Time.at(createdDate).utc : nil
+      end
+
+      def payment_due_date
+        paymentDueDate ? ::Time.at(paymentDueDate).utc : nil
+      end
+
+      def statement_end_date
+        statementEndDate ? ::Time.at(statementEndDate).utc : nil
+      end
+
+      def validate_aggregation_status!
+        case aggregation_status_code
+        when 0
+          true
+        when 103, 108, 109, 185, 187
+          fail ::Finicity::InvalidCredentialsError.new(aggregation_status_code)
+        else
+          fail ::Finicity::FinicityAggregationError.new(aggregation_status_code)
+        end
+      end
+    end
+
+    class Accounts
+      include ::Saxomattic
+
+      ##
+      # Saxomattic Attributes
+      #
+      attribute :account, :elements => true, :class => ::Finicity::V1::Response::Account, :as => :accounts
+    end
+  end
+end

data/lib/finicity/v1/response/customers.rb

@@ -0,0 +1,36 @@
+module Finicity::V1
+  module Response
+    class Customer
+      include ::Saxomattic
+
+      ##
+      # Saxomattic Attributes
+      #
+      attribute :username
+      attribute :email
+      attribute :firstName, :as => :first_name
+      attribute :lastName, :as => :last_name
+      attribute :id
+    end
+
+    class Customers
+      include ::Saxomattic
+
+      ##
+      # Saxomattic Attributes
+      #
+      attribute :customers
+      attribute :moreAvailable, :attribute => true, :as => :more_available
+      attribute :found, :attribute => true, :type => ::Integer
+      attribute :displaying, :attribute => true, :type => ::Integer
+      attribute :customer, :elements => true, :class => ::Finicity::V1::Response::Customer, :as => :customers
+
+      ##
+      # Instance Methods
+      #
+      def more_available?
+        more_available == 'true'
+      end
+    end
+  end
+end

data/lib/finicity/v1/response/error.rb

@@ -0,0 +1,13 @@
+module Finicity::V1
+  module Response
+    class Error
+      include ::Saxomattic
+
+      ##
+      # Saxomattic Attributes
+      #
+      attribute :code, :type => ::Integer
+      attribute :message
+    end
+  end
+end

data/lib/finicity/v1/response/institutions.rb

@@ -0,0 +1,38 @@
+module Finicity::V1
+  module Response
+    class Institution
+      include ::Saxomattic
+
+      ##
+      # Saxomattic Attributes
+      #
+      attribute :id
+      attribute :name
+      attribute :accountTypeDescription, :as => :account_type_description
+      attribute :totalAccounts, :type => ::Integer, :as => :total_accounts
+      attribute :discovery
+      attribute :urlHomeApp, :as => :url_home_app
+      attribute :urlLogonApp, :as => :url_logon_app
+    end
+
+    class Institutions
+      include ::Saxomattic
+
+      ##
+      # Saxomattic Attributes
+      #
+      attribute :institutions
+      attribute :moreAvailable, :attribute => true, :as => :more_available
+      attribute :found, :attribute => true, :type => ::Integer
+      attribute :displaying, :attribute => true, :type => ::Integer
+      attribute :institution, :elements => true, :class => ::Finicity::V1::Response::Institution, :as => :institutions
+
+      ##
+      # Instance Methods
+      #
+      def more_available?
+        more_available == 'true'
+      end
+    end
+  end
+end

data/lib/finicity/v1/response/login_form.rb

@@ -0,0 +1,29 @@
+module Finicity::V1
+  module Response
+    class LoginField
+      include ::Saxomattic
+
+      ##
+      # Saxomattic Attributes
+      #
+      attribute :description
+      attribute :displayOrder, :type => ::Integer, :as => :display_order
+      attribute :id
+      attribute :name
+      attribute :mask
+
+      def mask?
+        mask == 'true'
+      end
+    end
+
+    class LoginForm
+      include ::Saxomattic
+
+      ##
+      # Saxomattic Attributes
+      #
+      attribute :loginField, :elements => true, :class => ::Finicity::V1::Response::LoginField, :as => :login_fields
+    end
+  end
+end

data/lib/finicity/v1/response/mfa.rb

@@ -0,0 +1,22 @@
+module Finicity::V1
+  module Response
+    class Question
+      include ::Saxomattic
+
+      ##
+      # Saxomattic Attributes
+      #
+      attribute :text
+      attribute :choice, :elements => true, :as => :choices
+    end
+
+    class Mfa
+      include ::Saxomattic
+
+      ##
+      # Saxomattic Attributes
+      #
+      attribute :questions, :elements => true, :class => ::Finicity::V1::Response::Question
+    end
+  end
+end

data/lib/finicity/v1/response/transactions.rb

@@ -0,0 +1,28 @@
+module Finicity::V1
+  module Response
+    class Transaction
+      include ::Saxomattic
+
+      ##
+      # Saxomattic Attributes
+      #
+      attribute :id
+      attribute :amount, :type => ::Float
+      attribute :accountId, :as => :account_id
+      attribute :customerId, :as => :customer_id
+      attribute :description
+      attribute :memo
+      attribute :postedDate, :type => ::Integer, :as => :posted_date
+      attribute :status
+    end
+
+    class Transactions
+      include ::Saxomattic
+
+      ##
+      # Saxomattic Attributes
+      #
+      attribute :transaction, :elements => true, :class => ::Finicity::V1::Response::Transaction, :as => :transactions
+    end
+  end
+end

data/lib/finicity/v2.rb

@@ -0,0 +1,7 @@
+require 'finicity/v2/request/partner_authentication'
+require 'finicity/v2/response/partner_authentication'
+
+module Finicity
+  module V2
+  end
+end

data/lib/finicity/v2/request/partner_authentication.rb

@@ -0,0 +1,39 @@
+module Finicity::V2
+  module Request
+    class PartnerAuthentication
+      extend ::HTTPClient::IncludeClient
+      include_http_client do |client|
+        client.cookie_manager = nil
+      end
+
+      ##
+      # Instance Methods
+      #
+      def authenticate
+        http_client.post(url, body, headers)
+      end
+
+      def body
+        builder = ::Nokogiri::XML::Builder.new do |xml|
+          xml.credentials do
+            xml.partnerId(::Finicity.config.partner_id)
+            xml.partnerSecret(::Finicity.config.partner_secret)
+          end
+        end
+
+        builder.doc.root.to_s
+      end
+
+      def headers
+        {
+          'Finicity-App-Key' => ::Finicity.config.app_key,
+          'Content-Type' => 'application/xml'
+        }
+      end
+
+      def url
+        ::URI.join(::Finicity.config.base_url, 'v2/partners/authentication')
+      end
+    end
+  end
+end

data/lib/finicity/v2/response/partner_authentication.rb

@@ -0,0 +1,12 @@
+module Finicity::V2
+  module Response
+    class PartnerAuthentication
+      include ::Saxomattic
+
+      ##
+      # Saxomattic Attributes
+      #
+      attribute :token
+    end
+  end
+end

data/lib/finicity/version.rb

@@ -0,0 +1,3 @@
+module Finicity
+  VERSION = "0.1.0"
+end

data/spec/finicity/client_spec.rb

@@ -0,0 +1,527 @@
+require 'spec_helper'
+
+describe ::Finicity::Client do
+  let(:mfa_session_token) { 'mfa-123' }
+  let(:response) { instance_double(::HTTP::Message, :ok? => true, :status_code => 200, :body => "hello") }
+  let(:mfa) {
+    instance_double(
+      ::HTTP::Message,
+      :ok? => true,
+      :status_code => 203,
+      :body => "challenge",
+      :headers => { 'MFA-Session' => mfa_session_token }
+    )
+  }
+  let(:error) {
+    instance_double(
+      ::HTTP::Message,
+      :ok? => false,
+      :status_code => 400,
+      :body => "fail",
+      :content_type => "text/plain"
+    )
+  }
+
+  describe "#activate_accounts" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::ActivateAccounts).to(
+          receive(:activate_accounts).and_return(response)
+        )
+        response = subject.activate_accounts(123, 1, [])
+        response.should eq([])
+      end
+    end
+
+    context "when the response is mfa" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::ActivateAccounts).to(
+          receive(:activate_accounts).and_return(mfa)
+        )
+        response = subject.activate_accounts(123, 1, [])
+        response.should eq([])
+      end
+
+      it "sets the mfa session token" do
+        allow_any_instance_of(::Finicity::V1::Request::ActivateAccounts).to(
+          receive(:activate_accounts).and_return(mfa)
+        )
+        response = subject.activate_accounts(123, 1, [])
+        subject.mfa_session.should eq(mfa_session_token)
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::ActivateAccounts).to(
+          receive(:activate_accounts).and_return(error)
+        )
+        expect { subject.activate_accounts(123, 1, []) }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#activate_accounts_with_mfa" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::ActivateAccountsWithMfa).to(
+          receive(:activate_accounts_with_mfa).and_return(response)
+        )
+        response = subject.activate_accounts_with_mfa(123, 1, [], [])
+        response.should eq([])
+      end
+    end
+
+    context "when the response is mfa" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::ActivateAccountsWithMfa).to(
+          receive(:activate_accounts_with_mfa).and_return(mfa)
+        )
+        response = subject.activate_accounts_with_mfa(123, 1, [], [])
+        response.should eq([])
+      end
+
+      it "sets the mfa session token" do
+        allow_any_instance_of(::Finicity::V1::Request::ActivateAccountsWithMfa).to(
+          receive(:activate_accounts_with_mfa).and_return(mfa)
+        )
+        response = subject.activate_accounts_with_mfa(123, 1, [], [])
+        subject.mfa_session.should eq(mfa_session_token)
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::ActivateAccountsWithMfa).to(
+          receive(:activate_accounts_with_mfa).and_return(error)
+        )
+        expect { subject.activate_accounts_with_mfa(123, 1, [], []) }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#add_customer" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::AddCustomer).to(
+          receive(:add_customer).and_return(response)
+        )
+        response = subject.add_customer('USR-123')
+        response.id.should be_nil
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::AddCustomer).to(
+          receive(:add_customer).and_return(error)
+        )
+        expect { subject.add_customer('USR-123') }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#authenticate!" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V2::Request::PartnerAuthentication).to(
+          receive(:authenticate).and_return(response)
+        )
+        response = subject.authenticate!
+        response.token.should be_nil
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V2::Request::PartnerAuthentication).to(
+          receive(:authenticate).and_return(error)
+        )
+        expect { subject.authenticate! }.to raise_error(::Finicity::AuthenticationError)
+      end
+    end
+  end
+
+  describe "#delete_customer" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::DeleteCustomer).to(
+          receive(:delete_customer).and_return(response)
+        )
+        response = subject.delete_customer(123)
+        response.should eq({})
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::DeleteCustomer).to(
+          receive(:delete_customer).and_return(error)
+        )
+        expect { subject.delete_customer(123) }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#discover_accounts" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::DiscoverAccounts).to(
+          receive(:discover_accounts).and_return(response)
+        )
+        response = subject.discover_accounts(123, 1, [])
+        response.should eq([])
+      end
+    end
+
+    context "when the response is mfa" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::DiscoverAccounts).to(
+          receive(:discover_accounts).and_return(mfa)
+        )
+        response = subject.discover_accounts(123, 1, [])
+        response.should eq([])
+      end
+
+      it "sets the mfa session token" do
+        allow_any_instance_of(::Finicity::V1::Request::DiscoverAccounts).to(
+          receive(:discover_accounts).and_return(mfa)
+        )
+        response = subject.discover_accounts(123, 1, [])
+        subject.mfa_session.should eq(mfa_session_token)
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::DiscoverAccounts).to(
+          receive(:discover_accounts).and_return(error)
+        )
+        expect { subject.discover_accounts(123, 1, []) }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#discover_accounts_with_mfa" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::DiscoverAccountsWithMfa).to(
+          receive(:discover_accounts_with_mfa).and_return(response)
+        )
+        response = subject.discover_accounts_with_mfa(123, 1, [], [])
+        response.should eq([])
+      end
+    end
+
+    context "when the response is mfa" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::DiscoverAccountsWithMfa).to(
+          receive(:discover_accounts_with_mfa).and_return(mfa)
+        )
+        response = subject.discover_accounts_with_mfa(123, 1, [], [])
+        response.should eq([])
+      end
+
+      it "sets the mfa session token" do
+        allow_any_instance_of(::Finicity::V1::Request::DiscoverAccountsWithMfa).to(
+          receive(:discover_accounts_with_mfa).and_return(mfa)
+        )
+        response = subject.discover_accounts_with_mfa(123, 1, [], [])
+        subject.mfa_session.should eq(mfa_session_token)
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::DiscoverAccountsWithMfa).to(
+          receive(:discover_accounts_with_mfa).and_return(error)
+        )
+        expect { subject.discover_accounts_with_mfa(123, 1, [], []) }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#get_accounts" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::GetAccounts).to(
+          receive(:get_accounts).and_return(response)
+        )
+        response = subject.get_accounts(1, 2)
+        response.should eq([])
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::GetAccounts).to(
+          receive(:get_accounts).and_return(error)
+        )
+        expect { subject.get_accounts(1, 2) }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#get_customer_by_username" do
+    context "when the response is successful" do
+      let(:single_customer) { ::Finicity::V1::Response::Customers.new(:found => 1) }
+
+      it "returns the parsed response" do
+        allow(::Finicity::V1::Response::Customers).to receive(:parse).and_return(single_customer)
+        allow_any_instance_of(::Finicity::V1::Request::GetCustomersByUsername).to(
+          receive(:get_customers_by_username).and_return(response)
+        )
+        response = subject.get_customer_by_username("USR-123")
+        response.should be_nil
+      end
+    end
+
+    context "response contains multiple customers" do
+      let(:multiple_customers) { ::Finicity::V1::Response::Customers.new(:found => 2) }
+
+      it "raises an error" do
+        allow(::Finicity::V1::Response::Customers).to receive(:parse).and_return(multiple_customers)
+        allow_any_instance_of(::Finicity::V1::Request::GetCustomersByUsername).to(
+          receive(:get_customers_by_username).and_return(response)
+        )
+        expect { subject.get_customer_by_username("USR-123") }.to raise_error(
+          ::Finicity::DuplicateCustomerError
+        )
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::GetCustomersByUsername).to(
+          receive(:get_customers_by_username).and_return(error)
+        )
+        expect { subject.get_customer_by_username("USR-123") }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#get_customers_by_username" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::GetCustomersByUsername).to(
+          receive(:get_customers_by_username).and_return(response)
+        )
+        response = subject.get_customers_by_username(1, 1, 25)
+        response.should eq([])
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::GetCustomersByUsername).to(
+          receive(:get_customers_by_username).and_return(error)
+        )
+        expect { subject.get_customers_by_username(1, 1, 25) }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#get_customers" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::GetCustomers).to(
+          receive(:get_customers).and_return(response)
+        )
+        response = subject.get_customers
+        response.should eq([])
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::GetCustomers).to(
+          receive(:get_customers).and_return(error)
+        )
+        expect { subject.get_customers }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#get_institution" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::GetInstitution).to(
+          receive(:get_institution).and_return(response)
+        )
+        response = subject.get_institution(1)
+        response.should be_a(::Finicity::V1::Response::Institution)
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::GetInstitution).to(
+          receive(:get_institution).and_return(error)
+        )
+        expect { subject.get_institution(1) }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#get_institutions" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::GetInstitutions).to(
+          receive(:get_institutions).and_return(response)
+        )
+        response = subject.get_institutions("chase")
+        response.should eq([])
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::GetInstitutions).to(
+          receive(:get_institutions).and_return(error)
+        )
+        expect { subject.get_institutions("chase") }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#get_login_form" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::GetLoginForm).to(
+          receive(:get_login_form).and_return(response)
+        )
+        response = subject.get_login_form(1234)
+        response.should eq([])
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::GetLoginForm).to(
+          receive(:get_login_form).and_return(error)
+        )
+        expect { subject.get_login_form(1234) }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#get_transactions" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::GetTransactions).to(
+          receive(:get_transactions).and_return(response)
+        )
+        response = subject.get_transactions(123, 1, 1, 2)
+        response.should eq([])
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::GetTransactions).to(
+          receive(:get_transactions).and_return(error)
+        )
+        expect { subject.get_transactions(123, 1, 1 ,2) }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#interactive_refresh_account" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::InteractiveRefreshAccount).to(
+          receive(:interactive_refresh_account).and_return(response)
+        )
+        response = subject.interactive_refresh_account(123, 1)
+        response.should eq([])
+      end
+    end
+
+    context "when the response is mfa" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::InteractiveRefreshAccount).to(
+          receive(:interactive_refresh_account).and_return(mfa)
+        )
+        response = subject.interactive_refresh_account(123, 1)
+        response.should eq([])
+      end
+
+      it "sets the mfa session token" do
+        allow_any_instance_of(::Finicity::V1::Request::InteractiveRefreshAccount).to(
+          receive(:interactive_refresh_account).and_return(mfa)
+        )
+        response = subject.interactive_refresh_account(123, 1)
+        subject.mfa_session.should eq(mfa_session_token)
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::InteractiveRefreshAccount).to(
+          receive(:interactive_refresh_account).and_return(error)
+        )
+        expect { subject.interactive_refresh_account(123, 1) }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#interactive_refresh_account_with_mfa" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::InteractiveRefreshAccountWithMfa).to(
+          receive(:interactive_refresh_account_with_mfa).and_return(response)
+        )
+        response = subject.interactive_refresh_account_with_mfa(123, 1, [])
+        response.should eq([])
+      end
+    end
+
+    context "when the response is mfa" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::InteractiveRefreshAccountWithMfa).to(
+          receive(:interactive_refresh_account_with_mfa).and_return(mfa)
+        )
+        response = subject.interactive_refresh_account_with_mfa(123, 1, [])
+        response.should eq([])
+      end
+
+      it "sets the mfa session token" do
+        allow_any_instance_of(::Finicity::V1::Request::InteractiveRefreshAccountWithMfa).to(
+          receive(:interactive_refresh_account_with_mfa).and_return(mfa)
+        )
+        response = subject.interactive_refresh_account_with_mfa(123, 1, [])
+        subject.mfa_session.should eq(mfa_session_token)
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::InteractiveRefreshAccountWithMfa).to(
+          receive(:interactive_refresh_account_with_mfa).and_return(error)
+        )
+        expect { subject.interactive_refresh_account_with_mfa(123, 1, []) }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+
+  describe "#refresh_accounts" do
+    context "when the response is successful" do
+      it "returns the parsed response" do
+        allow_any_instance_of(::Finicity::V1::Request::RefreshAccounts).to(
+          receive(:refresh_accounts).and_return(response)
+        )
+        response = subject.refresh_accounts(1)
+        response.should eq([])
+      end
+    end
+
+    context "when the response is an error" do
+      it "fails" do
+        allow_any_instance_of(::Finicity::V1::Request::RefreshAccounts).to(
+          receive(:refresh_accounts).and_return(error)
+        )
+        expect { subject.refresh_accounts(1) }.to raise_error(::Finicity::GenericError)
+      end
+    end
+  end
+end