money_mover 0.0.3

data/spec/integration/money_mover/dwolla/funding-sources/micro-deposits/verification_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe MoneyMover::Dwolla::MicroDepositVerification do
+  let(:funding_source_token) { '9481924a-6795-4e7a-b436-a7a48a4141ca' }
+
+  describe '#save' do
+    context 'valid attributes' do
+      let(:amount1) { 0.01 }
+      let(:amount2) { 0.02 }
+
+      let(:attrs) {{
+        funding_source_id: funding_source_token,
+        amount1: amount1,
+        amount2: amount2
+      }}
+
+      subject { described_class.new(attrs) }
+
+      let(:create_params) {{
+        amount1: {
+          value: amount1,
+          currency: "USD"
+        },
+        amount2: {
+          value: amount2,
+          currency: "USD"
+        }
+      }}
+
+      before do
+        dwolla_helper.stub_funding_source_microdeposits_request funding_source_token, create_params, create_response
+      end
+
+      context 'success' do
+        let(:create_response) {{
+          status: 200,
+          body: ""
+        }}
+
+        it 'creates new resource in dwolla' do
+          expect(subject.save).to eq(true)
+        end
+      end
+
+      context 'fail' do
+        let(:create_response) { dwolla_helper.resource_create_error_response error_response }
+
+        let(:error_response) {{
+          code: "ValidationError",
+          message: "Validation error(s) present. See embedded errors list for more details.",
+          _embedded: {
+            errors: [
+              { code: "Invalid", message: "Invalid amount.", path: "/amount1/value" },
+              { code: "Invalid", message: "Invalid amount.", path: "/amount2/value" }
+            ]
+          }
+        }}
+
+        it 'returns errors' do
+          expect(subject.save).to eq(false)
+          expect(subject.errors[:amount1]).to eq(['Invalid amount.'])
+          expect(subject.errors[:amount2]).to eq(['Invalid amount.'])
+        end
+      end
+    end
+
+    context 'invalid attributes' do
+      let(:attrs) {{}}
+
+      it 'returns errors' do
+        expect(subject.save).to eq(false)
+        expect(subject.errors[:amount1]).to eq(["can't be blank", "is not a number"])
+        expect(subject.errors[:amount2]).to eq(["can't be blank", "is not a number"])
+      end
+    end
+  end
+end

data/spec/integration/money_mover/dwolla/transfers/create_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe MoneyMover::Dwolla::Transfer do
+  let(:funding_source_resource_location) { 'some-resource-location' }
+  let(:funding_destination_resource_location) { 'some-resource-location' }
+  let(:amount) { 10.0 }
+  let(:metadata) {{}}
+
+  #let(:attrs) {{
+    #funding_source_resource_location: funding_source_resource_location,
+    #funding_destination_resource_location: funding_destination_resource_location,
+    #amount: amount,
+    #metadata: metadata
+  #}}
+
+  let(:attrs) {{
+    sender_funding_source_token: funding_source_resource_location,
+    destination_funding_source_token: funding_destination_resource_location,
+    transfer_amount: amount,
+    metadata: metadata
+  }}
+
+  subject { described_class.new(attrs) }
+
+  let(:create_params) {{
+    _links: {
+      destination: {
+        href: dwolla_helper.build_dwolla_url("funding-sources/#{funding_source_resource_location}")
+      },
+      source: {
+        href: dwolla_helper.build_dwolla_url("funding-sources/#{funding_destination_resource_location}")
+      }
+    },
+    amount: {
+      value: amount.to_s,
+      currency: "USD"
+    },
+    metadata: metadata
+  }}
+
+  let(:resource_token) { 'some-token' }
+
+  before do
+    dwolla_helper.stub_create_transfer_request create_params, create_response
+  end
+
+  describe '#save' do
+    context 'success' do
+      let(:create_response) { dwolla_helper.transfer_created_response resource_token }
+
+      it 'creates new resource in dwolla' do
+        expect(subject.save).to eq(true)
+        expect(subject.id).to eq(resource_token)
+        expect(subject.resource_location).to eq(dwolla_helper.transfer_endpoint(resource_token))
+      end
+    end
+
+    context 'fail' do
+      let(:create_response) { dwolla_helper.resource_create_error_response error_response }
+
+      let(:error_response) {{
+        code: "ValidationError",
+        message: "Validation error(s) present. See embedded errors list for more details.",
+        _embedded: {
+          errors: [
+            { code: "Duplicate", message: "Invalid destination", path: "/_links/destination/href"
+          }
+          ]
+        }
+      }}
+
+      it 'returns errors' do
+        expect(subject.save).to eq(false)
+        expect(subject.errors[:_links]).to eq(['Invalid destination'])
+        expect(subject.id).to be_nil
+        expect(subject.resource_location).to be_nil
+      end
+    end
+  end
+end

data/spec/lib/money_mover/dwolla/client_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe MoneyMover::Dwolla::AccountClient do
+  let(:expected_response) { double 'expected response' }
+  let(:server_request) { double 'server request' }
+
+  let(:url_provider) { double 'url provider', api_url: api_url }
+  let(:api_url) { double' api url' }
+
+  subject { described_class.new }
+
+  let(:token) { double 'account token' }
+  let(:dwolla_token_provider) { double 'token provider', access_token: token }
+
+  let(:api_connection) { double 'api connection', connection: faraday_connection }
+  let(:faraday_connection) { double 'faraday connection' }
+
+  before do
+    allow(MoneyMover::Dwolla::ApiConnection).to receive(:new).with(token) { api_connection }
+    allow(MoneyMover::Dwolla::AccountToken).to receive(:new) { dwolla_token_provider }
+  end
+
+  let(:url) { double 'url' }
+  let(:params) { double 'params' }
+
+  describe '#post' do
+    let(:expected_response) { double 'expected response' }
+    let(:server_request) { double 'server request', response: expected_response }
+
+    before do
+      allow(faraday_connection).to receive(:post).with(url, params) { server_request }
+      allow(MoneyMover::Dwolla::ApiServerResponse).to receive(:new).with(server_request) { expected_response }
+    end
+
+    it 'returns success response' do
+      expect(subject.post(url, params)).to eq(expected_response)
+    end
+  end
+
+  describe '#delete' do
+    before do
+      allow(faraday_connection).to receive(:delete).with(url, params) { server_request }
+      allow(MoneyMover::Dwolla::ApiServerResponse).to receive(:new).with(server_request) { expected_response }
+    end
+
+    it 'returns SuccessResponse' do
+      expect(subject.delete(url, params)).to eq(expected_response)
+    end
+  end
+
+  describe '#get' do
+    before do
+      allow(faraday_connection).to receive(:get).with(url, params) { server_request }
+      allow(MoneyMover::Dwolla::ApiServerResponse).to receive(:new).with(server_request) { expected_response }
+    end
+
+    it 'returns response from token#get' do
+      expect(subject.get(url, params)).to eq(expected_response)
+    end
+  end
+end
+
+describe MoneyMover::Dwolla::AccountClient do
+  describe '#post' do
+    let(:url) { '/customers' }
+
+    let(:params) {{
+      firstName: 'someone first name',
+      lastName: 'someone last name',
+      email: 'email@example.com',
+      businessName: 'some company name',
+      type: 'receive-only'
+    }}
+
+    before do
+      dwolla_helper.stub_create_customer_request(params, create_response)
+    end
+
+    context 'success' do
+      let(:create_response) { dwolla_helper.create_customer_success_response(customer_token) }
+      let(:customer_token) { 'some-customer-token' }
+
+      it 'returns success response' do
+        response = subject.post(url, params)
+        expect(response.resource_id).to eq(customer_token)
+        expect(response.resource_location).to eq(dwolla_helper.customer_url(customer_token))
+      end
+    end
+
+    context 'error' do
+      let(:create_response) {
+        dwolla_helper.error_response :code=>"ValidationError", :message=>"Validation error(s) present. See embedded errors list for more details.", :_embedded=>{:errors=>[{:code=>"Duplicate", :message=>"A customer with the specified email already exists.", :path=>"/email"}]}
+      }
+
+      it 'returns error response' do
+        response = subject.post(url, params)
+        expect(response.errors[:email]).to eq(['A customer with the specified email already exists.'])
+      end
+    end
+  end
+end

data/spec/lib/money_mover/dwolla/config_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe MoneyMover::Dwolla::Config do
+  let(:webhook_secret_key) { double 'webhook secret key' }
+  let(:webhook_callback_url) { double 'webhook callback url' }
+  let(:api_key) { double 'api key' }
+  let(:api_secret_key) { double 'api secret key' }
+  let(:environment) { double 'environment' }
+  let(:ach_provider_config) { double 'configatron ach provider store', webhook_secret_key: webhook_secret_key, webhook_callback_url: webhook_callback_url, api_key: api_key, api_secret_key: api_secret_key, environment: environment }
+
+  subject { described_class.new(ach_provider_config) }
+
+  it 'returns expected values' do
+    expect(subject.webhook_secret_key).to eq(webhook_secret_key)
+    expect(subject.webhook_callback_url).to eq(webhook_callback_url)
+    expect(subject.api_key).to eq(api_key)
+    expect(subject.api_secret_key).to eq(api_secret_key)
+    expect(subject.environment).to eq(environment)
+  end
+end

data/spec/lib/money_mover/dwolla/error_handler_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe MoneyMover::Dwolla::ErrorHandler do
+  subject { described_class.new(server_error) }
+
+  describe '#errors' do
+    context 'no embedded errors' do
+      let(:server_error) {{
+          code: "DuplicateResource",
+          message: "Bank already exists: id=442efd3e-3f70-4cb1-a393-593dca3464b4",
+          _embedded: nil
+      }}
+
+      it 'sets error correctly' do
+        expect(subject.errors[:base]).to eq(["Bank already exists: id=442efd3e-3f70-4cb1-a393-593dca3464b4"])
+      end
+    end
+
+    context 'json pointer path is /routingNumber' do
+      let(:server_error) {{
+        code: "ValidationError",
+        message: "Validation error(s) present. See embedded errors list for more details.",
+        _embedded: {
+          errors: [
+            {
+              :code=>"Invalid",
+              :message=>"Invalid parameter.",
+              :path=>"/routingNumber"
+            }
+          ]
+        }
+      }}
+
+      it 'sets error correctly' do
+        expect(subject.errors[:routingNumber]).to eq(["Invalid parameter."])
+      end
+    end
+
+    context 'json pointer path is /amount2/value' do
+      let(:server_error) {{
+        code: "ValidationError",
+        message: "Validation error(s) present. See embedded errors list for more details.",
+        _embedded: {
+          errors: [
+            {
+              code: "Invalid",
+              message: "Invalid amount.",
+              path: "/amount2/value"
+            }
+          ]
+        }
+      }}
+
+      it 'sets error correctly' do
+        expect(subject.errors[:amount2]).to eq(["Invalid amount."])
+      end
+    end
+
+    context 'json pointer path is empty' do
+      let(:server_error) {{
+        code: "ValidationError",
+        message: "Validation error(s) present. See embedded errors list for more details.",
+        _embedded: {
+          errors: [
+            {
+              code: "Invalid",
+              message: "Invalid amount."
+            }
+          ]
+        }
+      }}
+
+      it 'sets error correctly' do
+        expect(subject.errors[:base]).to eq(["Invalid amount."])
+      end
+    end
+  end
+end

data/spec/lib/money_mover/dwolla/funding_source_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe MoneyMover::Dwolla::FundingSource do
+  let(:customer_id) { double 'customer id' }
+
+  let(:name) { 'some name' }
+  let(:type) { 'checking' }
+  let(:routingNumber) { 'routing number' }
+  let(:accountNumber) { 'account number' }
+
+  let(:attrs) {{
+    name: name,
+    type: type,
+    routingNumber: routingNumber,
+    accountNumber: accountNumber
+  }}
+
+  subject { described_class.new customer_id, attrs }
+
+  let(:dwolla_client) { double 'dwolla client' }
+
+  let(:dwolla_response) { double 'dwolla response', success?: save_success?, resource_location: resource_location, resource_id: resource_id, errors: dwolla_errors }
+  let(:dwolla_errors) { [ ['key1', 'error1'], ['key2', 'error2'] ] }
+
+  let(:resource_location) { double 'resource location' }
+  let(:resource_id) { double 'resource id' }
+
+  before do
+    allow(MoneyMover::Dwolla::AccountClient).to receive(:new) { dwolla_client }
+  end
+
+  it { should validate_presence_of(:name) }
+  it { should validate_presence_of(:type) }
+  it { should validate_presence_of(:routingNumber) }
+  it { should validate_presence_of(:accountNumber) }
+
+  describe '#save' do
+    let(:save_success?) { true }
+
+    let(:create_params) {{
+      name: name,
+      type: type,
+      routingNumber: routingNumber,
+      accountNumber: accountNumber
+    }}
+
+    let(:create_endpoint) { "/customers/#{customer_id}/funding-sources" }
+
+    context 'success' do
+      let(:save_success?) { true }
+
+      it 'returns true and sets resource_location and id' do
+        expect(dwolla_client).to receive(:post).with(create_endpoint, create_params) { dwolla_response }
+
+        expect(subject.save).to eq(true)
+
+        expect(subject.errors).to be_empty
+        expect(subject.resource_location).to eq(resource_location)
+        expect(subject.id).to eq(resource_id)
+      end
+    end
+
+    context 'validations fail' do
+      let(:name) { nil }
+      let(:type) { nil }
+      let(:routingNumber) { nil }
+      let(:accountNumber) { nil }
+
+      it 'does not attempt to create transfer and returns false with errors' do
+        expect(dwolla_client).to_not receive(:post)
+
+        expect(subject.save).to eq(false)
+
+        expect(subject.errors[:name]).to eq(["can't be blank"])
+        expect(subject.errors[:type]).to eq(["can't be blank", "is not included in the list"])
+        expect(subject.errors[:routingNumber]).to eq(["can't be blank"])
+        expect(subject.errors[:accountNumber]).to eq(["can't be blank"])
+      end
+    end
+
+    context 'dwolla error' do
+      let(:save_success?) { false }
+
+      it 'returns false and has errors' do
+        expect(dwolla_client).to receive(:post).with(create_endpoint, create_params) { dwolla_response }
+
+        expect(subject.save).to eq(false)
+
+        expect(subject.errors[:key1]).to eq(['error1'])
+        expect(subject.errors[:key2]).to eq(['error2'])
+      end
+    end
+  end
+end

data/spec/lib/money_mover/dwolla/microdeposits_initiation_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe MoneyMover::Dwolla::MicroDepositInitiation do
+  let(:response_errors) { { key1: 'Error1', key2: 'Error2' } }
+  let(:ach_response) { double 'ach response', success?: response_success?, resource_location: resource_location, resource_id: resource_id, errors: response_errors}
+  let(:resource_location) { double 'resource location' }
+  let(:resource_id) { double 'resource id' }
+  let(:ach_client) { double 'Dwolla Client', post: ach_response }
+
+  let(:funding_source_id) { 'some_funding_source_id_token' }
+
+  subject { described_class.new(funding_source_id: funding_source_id) }
+
+  before do
+    allow(MoneyMover::Dwolla::AccountClient).to receive(:new) { ach_client }
+  end
+
+  context 'success' do
+    let(:response_success?) { true }
+
+    it 'posts to ach provider and returns true' do
+      expect(ach_client).to receive(:post).with("/funding-sources/#{funding_source_id}/micro-deposits", {})
+      expect(subject.save).to eq(true)
+    end
+  end
+
+  context 'ach failure' do
+    let(:response_success?) { false }
+
+    it 'posts to ach provider and returns false and has errors' do
+      expect(ach_client).to receive(:post).with("/funding-sources/#{funding_source_id}/micro-deposits", {})
+      expect(subject.save).to eq(false)
+      expect(subject.errors.to_a).to eq(["Key1 Error1", "Key2 Error2"])
+    end
+  end
+end

data/spec/lib/money_mover/dwolla/root_account_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe MoneyMover::Dwolla::RootAccount do
+  let(:client) { double 'dwolla account client' }
+  let(:account_token) { "account_token_value" }
+  let(:bank_funding_source_token) { "bank_funding_source_token_value" }
+
+  let(:account_response) { double 'account response', success?: account_success?, body: account_response_body }
+  let(:account_success?) { true }
+
+  let(:account_response_body) do
+    {
+      :_links=>{
+        :account=>{
+          :href=>"https://api-uat.dwolla.com/accounts/#{account_token}"
+        },
+        :customers=>{:href=>"https://api-uat.dwolla.com/customers"}
+      }
+    }
+  end
+
+  let(:funding_response) { double 'funding response', body: funding_response_body }
+
+  let(:funding_response_body) do
+    {
+      :_links=>{
+        :self=>{
+          :href=>"https://api-uat.dwolla.com/accounts/#{account_token}/funding-sources"
+        }
+      },
+      :_embedded=>{
+        :"funding-sources"=>[
+          {
+            :_links=>{
+              :self=>{
+                :href=>"https://api-uat.dwolla.com/funding-sources/#{bank_funding_source_token}"
+              },
+              :account=>{
+                :href=>"https://api-uat.dwolla.com/accounts/#{account_token}"
+              }
+            },
+            :id=>bank_funding_source_token,
+            :status=>"verified",
+            :type=>"bank",
+            :name=>"Superhero Savings Bank",
+            :created=>'2016-03-08 17:43:43 UTC'
+          },
+          {
+            :_links=>{
+              :self=>{
+                :href=>"https://api-uat.dwolla.com/funding-sources/90fa0eff-8ea0-4cab-89eb-72a1f5d93c13"
+              },
+              :account=>{
+                :href=>"https://api-uat.dwolla.com/accounts/#{account_token}"
+              },
+              :"with-available-balance"=>{
+                :href=>"https://api-uat.dwolla.com/funding-sources/90fa0eff-8ea0-4cab-89eb-72a1f5d93c13"
+              }
+            },
+            :id=>"90fa0eff-8ea0-4cab-89eb-72a1f5d93c13",
+            :status=>"verified",
+            :type=>"balance",
+            :name=>"Balance",
+            :created=>'2016-03-08 17:43:42 UTC'
+          }
+        ]
+      }
+    }
+  end
+
+  before do
+    allow(MoneyMover::Dwolla::AccountClient).to receive(:new) { client }
+    allow(client).to receive(:get).with('/') { account_response }
+    allow(client).to receive(:get).with("/accounts/#{account_token}/funding-sources") { funding_response }
+  end
+
+  describe '.fetch' do
+    subject { described_class }
+
+    it 'returns expected token hash' do
+      account = subject.fetch
+      expect(account.account_resource_id).to eq(account_token)
+      expect(account.bank_account_funding_source.id).to eq(bank_funding_source_token)
+    end
+  end
+end

data/spec/lib/money_mover/dwolla/token_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe MoneyMover::Dwolla::AccountToken do
+  let(:ach_config) { double 'ach config', api_key: ach_config_api_key, api_secret_key: ach_config_api_secret_key, environment: ach_config_environment, account_token_provider: account_token_provider }
+  let(:ach_config_api_key) { double 'ach config api key' }
+  let(:ach_config_api_secret_key) { double 'ach config api secret' }
+  let(:ach_config_environment) { double 'ach config environment' }
+  let(:account_token_provider) { double 'account token provider', access_token: account_access_token, refresh_token: account_refresh_token }
+  let(:account_access_token) { double 'account access token' }
+  let(:account_refresh_token) { double 'account refresh token' }
+
+  let(:attrs) {{}}
+
+  subject { described_class.new attrs, ach_config }
+
+  describe '#access_token' do
+    it 'returns account token from account token provider' do
+      expect(subject.access_token).to eq(account_access_token)
+    end
+  end
+
+  describe '#refresh_token' do
+    it 'returns account token from account token provider' do
+      expect(subject.refresh_token).to eq(account_refresh_token)
+    end
+  end
+end
+
+# INTEGRATION TEST
+describe MoneyMover::Dwolla::AccountToken do
+  let(:invalid_refresh_token_response) {{
+    "error": "access_denied",
+    "error_description": "Invalid refresh token."
+  }}
+
+  let(:expired_refresh_token_error) {{
+    "error": "access_denied",
+    "error_description": "Expired refresh token."
+  }}
+
+  let(:refresh_token_request_params) {{
+    "client_id": "JCGQXLrlfuOqdUYdTcLz3rBiCZQDRvdWIUPkw++GMuGhkem9Bo",
+    "client_secret": "g7QLwvO37aN2HoKx1amekWi8a2g7AIuPbD5C/JSLqXIcDOxfTr",
+    "refresh_token": "Pgk+l9okjwTCfsvIvEDPrsomE1er1txeyoaAkTIBAuXza8WvZY",
+    "grant_type": "refresh_token"
+  }}
+
+  #let(:refresh_token_success_response) {{
+    #"_links": {
+      #"account": {
+        #"href": "https://api-uat.dwolla.com/accounts/ca32853c-48fa-40be-ae75-77b37504581b"
+      #}
+    #},
+    #"access_token": "F3jK4rg7FGlq4yRQ7vWECoXVD4zQq9Xg26VnxzMbHGusZqr7dF",
+    #"expires_in": 3600,
+    #"refresh_token": "DRlqGJ0IFsRK8xzjkKhjTOgz3meet6E91T2oacGCefHGU4h1hj",
+    #"refresh_expires_in": 5184000,
+    #"token_type": "bearer",
+    #"scope": "send|transactions|funding|managecustomers",
+    #"account_id": "ca32853c-48fa-40be-ae75-77b37504581b"
+  #}}
+
+
+  let(:account_id) { "7da912eb-5976-4e5c-b5ab-a5df35ac661b" }
+  let(:new_access_token) { "oNGSeXqucdVxTLAwSRNc1WjG5BTHWNS5z7hccJGUTGvCXusmbC" }
+  let(:new_refresh_token) { "Et380Ps1y9tyiW3A8yf0ws1lbfGUVXl5DLIHfDDELXC0ls7hie" }
+
+  let(:refresh_token_success_response) {{
+    "_links": {
+      "account": {
+        "href":"https://api-uat.dwolla.com/accounts/#{account_id}"
+      }
+    },
+    "access_token": new_access_token,
+    "expires_in":3600,
+    "refresh_token": new_refresh_token,
+    "refresh_expires_in":5184000,
+    "token_type":"bearer",
+    "scope":"accountinfofull|contacts|transactions|balance|send|request|funding|manageaccount|scheduled|email|managecustomers",
+    "account_id": account_id
+  }}
+
+  describe '#request_new_token!' do
+    let(:token_response) { refresh_token_success_response }
+
+    before do
+      dwolla_helper.stub_refresh_token_request(token_response)
+    end
+
+    context 'success' do
+      it 'updates tokens in db' do
+        new_token = subject.request_new_token!
+
+        expect(new_token.account_id).to eq(account_id)
+        expect(new_token.expires_in).to eq(3600)
+        expect(new_token.access_token).to eq(new_access_token)
+        expect(new_token.refresh_token).to eq(new_refresh_token)
+      end
+    end
+  end
+end