virtuous 0.0.1

data/spec/virtuous/client_spec.rb

@@ -0,0 +1,270 @@
+require 'spec_helper'
+
+RSpec.describe Virtuous::Client do
+  let(:attrs) { { api_key: 'test_api_key' } }
+  let(:attrs_without_authentication) { { api_key: nil } }
+
+  subject(:client) { described_class.new(**attrs) }
+
+  shared_examples 'param request' do |verb|
+    let(:endpoint) { "#{verb}_test" }
+    let(:url) { "https://api.virtuoussoftware.com/#{endpoint}" }
+
+    before do
+      stub_request(:any, /_test/).to_return(body: response_body.to_json)
+    end
+
+    it 'requests at `path` argument' do
+      client.public_send(verb, endpoint)
+
+      expect(WebMock).to have_requested(verb, url)
+    end
+
+    it 'passes request parameters' do
+      client.public_send(verb, endpoint, request_params)
+
+      expect(WebMock).to have_requested(verb, url).with(query: request_params)
+    end
+
+    it 'returns parsed response body' do
+      expect(client.public_send(verb, endpoint)).to eq(response_body)
+    end
+  end
+
+  shared_examples 'body request' do |verb|
+    let(:body) { { 'test' => 123 } }
+    let(:endpoint) { "#{verb}_test" }
+    let(:url) { "https://api.virtuoussoftware.com/#{endpoint}" }
+
+    let(:do_request) { client.public_send(verb, endpoint, body) }
+
+    before do
+      stub_request(:any, /_test/).to_return(body: body.to_json)
+    end
+
+    it 'requests at `path` argument' do
+      do_request
+
+      expect(WebMock).to have_requested(verb, url)
+    end
+
+    it 'passes request body' do
+      do_request
+
+      expect(WebMock)
+        .to have_requested(verb, url)
+        .with(body: body)
+    end
+
+    it 'returns parsed response body' do
+      expect(do_request).to eq(body)
+    end
+  end
+
+  shared_examples 'api key auth' do
+    let(:path) { '/api/Contact/1' }
+    let(:url) { "https://api.virtuoussoftware.com#{path}" }
+
+    it 'doesn\'t request an access token' do
+      client.get(path)
+
+      expect(WebMock).not_to have_requested(:post, 'https://api.virtuoussoftware.com/Token')
+    end
+
+    it 'uses the key in requests' do
+      client.get(path)
+
+      expect(WebMock).to have_requested(:get, url)
+        .with(headers: { 'Authorization' => "Bearer #{api_key}" })
+    end
+  end
+
+  shared_examples 'valid access token auth' do
+    let(:path) { '/api/Contact/1' }
+    let(:url) { "https://api.virtuoussoftware.com#{path}" }
+
+    it 'doesn\'t request an access token' do
+      client.get(path)
+
+      expect(WebMock).not_to have_requested(:post, 'https://api.virtuoussoftware.com/Token')
+    end
+
+    it 'uses the access token in requests' do
+      client.get(path)
+
+      expect(WebMock).to have_requested(:get, url)
+        .with(headers: { 'Authorization' => "Bearer #{access_token}" })
+    end
+  end
+
+  shared_examples 'expired access token auth' do
+    let(:path) { '/api/Contact/1' }
+    let(:url) { "https://api.virtuoussoftware.com#{path}" }
+
+    it 'doesn\'t request an access token before doing a request' do
+      client
+
+      expect(WebMock).not_to have_requested(:post, 'https://api.virtuoussoftware.com/Token')
+    end
+
+    it 'requests a new access token before doing a request' do
+      client.get(path)
+
+      body = URI.encode_www_form({ grant_type: 'refresh_token', refresh_token: refresh_token })
+
+      expect(WebMock).to have_requested(:post, 'https://api.virtuoussoftware.com/Token')
+        .with(body: body)
+
+      expect(client.refresh_token).to eq('new_refresh_token')
+      expect(client.access_token).to eq('new_access_token')
+      expect(client.expires_at).to be > Time.now
+    end
+
+    it 'doesn\'t request an access token a second time' do
+      client.get(path)
+
+      WebMock.reset_executed_requests!
+
+      client.get(path)
+
+      expect(WebMock).not_to have_requested(:post, 'https://api.virtuoussoftware.com/Token')
+    end
+
+    it 'uses the new access token in requests' do
+      client.get(path)
+
+      expect(WebMock).to have_requested(:get, url)
+        .with(headers: { 'Authorization' => 'Bearer new_access_token' })
+    end
+  end
+
+  context 'with api key' do
+    let(:api_key) { 'test_api_key' }
+    let(:attrs) { { api_key: api_key } }
+
+    it_behaves_like 'api key auth'
+  end
+
+  context 'with access token' do
+    let(:access_token) { 'test_access_token' }
+    let(:attrs) { { access_token: access_token } }
+
+    it_behaves_like 'valid access token auth'
+  end
+
+  context 'with non expired access token' do
+    let(:access_token) { 'test_access_token' }
+    let(:refresh_token) { 'test_refresh_token' }
+    let(:attrs) do
+      { access_token: access_token, refresh_token: refresh_token, expires_at: Time.now + 1_295_999 }
+    end
+
+    it_behaves_like 'valid access token auth'
+  end
+
+  context 'with expired access token' do
+    let(:access_token) { 'test_access_token' }
+    let(:refresh_token) { 'test_refresh_token' }
+    let(:attrs) do
+      {
+        access_token: access_token, refresh_token: refresh_token, expires_at: Time.new(2023, 12, 11)
+      }
+    end
+
+    it_behaves_like 'expired access token auth'
+  end
+
+  context 'with no access token' do
+    let(:refresh_token) { 'test_refresh_token' }
+    let(:attrs) { { refresh_token: refresh_token } }
+
+    it_behaves_like 'expired access token auth'
+  end
+
+  context 'with password auth' do
+    let(:attrs) { {} }
+    let(:access_token) { 'new_access_token' }
+
+    before :each do
+      client.authenticate('user@email.com', 'password')
+      WebMock.reset_executed_requests!
+    end
+
+    it_behaves_like 'valid access token auth'
+  end
+
+  describe '#authenticate(email, password, otp = nil)' do
+    let(:email) { 'user@email.com' }
+    let(:password) { 'test_password' }
+    let(:attrs) { {} }
+
+    it 'sends a request to retrieve a token' do
+      client.authenticate(email, password)
+
+      body = URI.encode_www_form({ grant_type: 'password', username: email, password: password })
+
+      expect(WebMock).to have_requested(:post, 'https://api.virtuoussoftware.com/Token')
+        .with(body: body)
+    end
+
+    it 'sets the new token' do
+      client.authenticate(email, password)
+
+      expect(client.refresh_token).to eq('new_refresh_token')
+      expect(client.access_token).to eq('new_access_token')
+      expect(client.expires_at).to be > Time.now
+    end
+
+    it 'returns the new token values' do
+      response = client.authenticate(email, password)
+
+      expect(response[:refresh_token]).to eq(client.refresh_token)
+      expect(response[:access_token]).to eq(client.access_token)
+      expect(response[:expires_at]).to eq(client.expires_at)
+    end
+
+    context 'with otp' do
+      let(:email) { 'otp@user.com' }
+
+      it 'returns requires_otp if otp is not set' do
+        response = client.authenticate(email, password)
+
+        expect(response[:requires_otp]).to eq(true)
+      end
+
+      it 'sets the new token' do
+        client.authenticate(email, password, '111111')
+
+        expect(client.refresh_token).to eq('new_refresh_token')
+        expect(client.access_token).to eq('new_access_token')
+        expect(client.expires_at).to be > Time.now
+      end
+    end
+  end
+
+  describe '#get(path, options = {})' do
+    let(:request_params) { { 'test' => 123 } }
+    let(:response_body) { request_params }
+
+    include_examples 'param request', :get
+  end
+
+  describe '#delete(path, options = {})' do
+    let(:request_params) { { 'test' => 123 } }
+    let(:response_body) { {} }
+
+    include_examples 'param request', :delete
+  end
+
+  describe '#patch(path, options = {})' do
+    include_examples 'body request', :patch
+  end
+
+  describe '#post(path, options = {})' do
+    include_examples 'body request', :post
+  end
+
+  describe '#put(path, options = {})' do
+    include_examples 'body request', :put
+  end
+end

data/spec/virtuous/error_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'rack/utils'
+
+CODES = Rack::Utils::HTTP_STATUS_CODES.keys.freeze
+
+RSpec.describe Virtuous::Error do
+  let(:client) do
+    Virtuous::Client.new(
+      base_url: 'http://some-virtuous-uri.com',
+      api_key: 'test_api_key'
+    )
+  end
+
+  def stub(code, body)
+    stub_request(:any, /virtuous/).to_return(status: code, body: body)
+  end
+
+  def expect_failure(code, body)
+    url = 'http://some-virtuous-uri.com/anything'
+
+    expect do
+      client.get('anything')
+    end.to raise_error(Virtuous::Error, /#{code}: #{url} #{body}/)
+  end
+
+  def expect_success
+    expect { client.get('anything') }.to_not raise_error
+  end
+
+  context 'informational responses' do
+    CODES.grep(100..199).each do |code|
+      it "does not raise error for #{code}" do
+        stub(code, '{}')
+        expect_success
+      end
+    end
+  end
+
+  context 'success responses' do
+    CODES.grep(200..299).each do |code|
+      it "does not raise error for #{code}" do
+        stub(code, '{}')
+        expect_success
+      end
+    end
+  end
+
+  context 'redirection responses' do
+    CODES.grep(300..399).each do |code|
+      it "does not raise error for #{code}" do
+        stub(code, '')
+        expect_success
+      end
+    end
+  end
+
+  context 'client error responses' do
+    CODES.grep(400..499).each do |code|
+      it "raises exception for #{code}" do
+        stub(code, 'test client error')
+        expect_failure(code, 'test client error')
+      end
+    end
+  end
+
+  context 'server error responses' do
+    CODES.grep(500..599).each do |code|
+      it "raises exception for #{code}" do
+        stub(code, 'test client error')
+        expect_failure(code, 'test client error')
+      end
+    end
+  end
+end

data/spec/virtuous/resources/contact_address_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+RSpec.describe Virtuous::Client::ContactAddress, type: :model do
+  include_context 'resource specs'
+
+  describe '#get_contact_addresses(contact_id)' do
+    subject(:resource) { client.get_contact_addresses(1) }
+
+    it 'returns a list of addresses' do
+      expect(subject).to be_a(Array)
+    end
+
+    it 'passes options' do
+      expect(client).to receive(:get)
+        .with('api/ContactAddress/ByContact/1')
+        .and_call_original
+      resource
+    end
+  end
+
+  describe '#create_contact_address(data)' do
+    subject(:resource) do
+      client.create_contact_address(
+        contact_id: 1, label: 'Home address', address1: '324 Frank Island',
+        address2: 'Apt. 366', city: 'Antonioborough', state: 'Massachusetts', postal: '27516',
+        country: 'USA'
+      )
+    end
+
+    it 'passes options' do
+      expect(client).to receive(:post)
+        .with(
+          'api/ContactAddress',
+          {
+            'contactId' => 1, 'label' => 'Home address', 'address1' => '324 Frank Island',
+            'address2' => 'Apt. 366', 'city' => 'Antonioborough', 'state' => 'Massachusetts',
+            'postal' => '27516', 'country' => 'USA'
+          }
+        )
+        .and_call_original
+      resource
+    end
+
+    it 'returns a hash' do
+      expect(resource).to be_a(Hash)
+    end
+  end
+
+  describe '#update_contact_address(id, data)' do
+    subject(:resource) do
+      client.update_contact_address(
+        1, label: 'Home address', address1: '324 Frank Island', address2: 'Apt. 366',
+           city: 'Antonioborough', state: 'Massachusetts', postal: '27516', country: 'USA'
+      )
+    end
+
+    it 'passes options' do
+      expect(client).to receive(:put)
+        .with(
+          'api/ContactAddress/1',
+          {
+            'label' => 'Home address', 'address1' => '324 Frank Island', 'address2' => 'Apt. 366',
+            'city' => 'Antonioborough', 'state' => 'Massachusetts', 'postal' => '27516',
+            'country' => 'USA'
+          }
+        )
+        .and_call_original
+      resource
+    end
+
+    it 'returns a hash' do
+      expect(resource).to be_a(Hash)
+    end
+  end
+end

data/spec/virtuous/resources/contact_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+RSpec.describe Virtuous::Client::Contact, type: :model do
+  include_context 'resource specs'
+
+  describe '#find_contact_by_email(email)' do
+    it 'returns a hash' do
+      expect(client.find_contact_by_email('email@test.com')).to be_a(Hash)
+    end
+
+    it 'queries contacts' do
+      expect(client).to receive(:get).with('api/Contact/Find',
+                                           { email: 'email@test.com' }).and_call_original
+
+      resource = client.find_contact_by_email('email@test.com')
+
+      expect(resource[:id]).to eq(1)
+    end
+  end
+
+  describe '#get_contact(id)' do
+    it 'returns a hash' do
+      expect(client.get_contact(1)).to be_a(Hash)
+    end
+
+    it 'queries contacts' do
+      expect(client).to receive(:get).with('api/Contact/1').and_call_original
+
+      resource = client.get_contact(1)
+
+      expect(resource[:id]).to eq(1)
+    end
+  end
+
+  describe '#import_contact(data)' do
+    subject(:resource) do
+      client.import_contact(
+        reference_source: 'Test source',
+        reference_id: 123,
+        contact_type: 'Organization',
+        name: 'Test Org',
+        title: 'Mr',
+        first_name: 'Test',
+        last_name: 'Individual',
+        email: 'test_individual@email.com'
+      )
+    end
+
+    it 'passes options' do
+      expect(client).to receive(:post)
+        .with(
+          'api/Contact/Transaction',
+          {
+            'referenceSource' => 'Test source',
+            'referenceId' => 123,
+            'contactType' => 'Organization',
+            'name' => 'Test Org',
+            'title' => 'Mr',
+            'firstName' => 'Test',
+            'lastName' => 'Individual',
+            'email' => 'test_individual@email.com'
+          }
+        )
+        .and_call_original
+      resource
+    end
+  end
+
+  describe '#create_contact(data)' do
+    subject(:resource) do
+      client.create_contact(
+        reference_source: 'Test source',
+        reference_id: 123,
+        contact_type: 'Organization',
+        name: 'Test Org',
+        contact_individuals: [{
+          first_name: 'Test',
+          last_name: 'Individual'
+        }]
+      )
+    end
+
+    it 'passes options' do
+      expect(client).to receive(:post)
+        .with(
+          'api/Contact',
+          {
+            'referenceSource' => 'Test source',
+            'referenceId' => 123,
+            'contactType' => 'Organization',
+            'name' => 'Test Org',
+            'contactIndividuals' => [{
+              'firstName' => 'Test',
+              'lastName' => 'Individual'
+            }]
+          }
+        )
+        .and_call_original
+      resource
+    end
+
+    it 'returns a hash' do
+      expect(resource).to be_a(Hash)
+    end
+  end
+
+  describe '#update_contact(id, data)' do
+    subject(:resource) do
+      client.update_contact(
+        1,
+        reference_source: 'Test source',
+        reference_id: 123,
+        contact_type: 'Organization',
+        name: 'Test Org'
+      )
+    end
+
+    it 'passes options' do
+      expect(client).to receive(:put)
+        .with(
+          'api/Contact/1',
+          {
+            'referenceSource' => 'Test source',
+            'referenceId' => 123,
+            'contactType' => 'Organization',
+            'name' => 'Test Org'
+          }
+        )
+        .and_call_original
+      resource
+    end
+
+    it 'returns a hash' do
+      expect(resource).to be_a(Hash)
+    end
+  end
+end

data/spec/virtuous/resources/gift_designation_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+RSpec.describe Virtuous::Client::Individual, type: :model do
+  include_context 'resource specs'
+
+  describe '#gift_designation_query_options' do
+    it 'returns a hash' do
+      expect(client.gift_designation_query_options).to be_a(Hash)
+    end
+
+    it 'queries options' do
+      expect(client).to receive(:get).with('api/GiftDesignation/QueryOptions').and_call_original
+
+      response = client.gift_designation_query_options
+
+      expect(response).to have_key(:options)
+    end
+  end
+
+  describe '#query_gift_designations(**options)' do
+    it 'returns a list of designations' do
+      response = client.query_gift_designations
+      expect(response).to be_a(Hash)
+
+      expect(response).to have_key(:list)
+      expect(response).to have_key(:total)
+    end
+
+    it 'sends take as a query param' do
+      expect(client).to receive(:post).with(URI('api/GiftDesignation/Query?take=12'),
+                                            {}).and_call_original
+
+      client.query_gift_designations(take: 12)
+    end
+
+    it 'sends skip as a query param' do
+      expect(client).to receive(:post).with(URI('api/GiftDesignation/Query?skip=12'),
+                                            {}).and_call_original
+
+      client.query_gift_designations(skip: 12)
+    end
+
+    it 'sends sort_by in the body' do
+      expect(client).to receive(:post).with(URI('api/GiftDesignation/Query'), { 'sortBy' => 'Id' })
+                                      .and_call_original
+
+      client.query_gift_designations(sort_by: 'Id')
+    end
+
+    it 'sends descending in the body' do
+      expect(client).to receive(:post).with(
+        URI('api/GiftDesignation/Query'), { 'descending' => true }
+      ).and_call_original
+
+      client.query_gift_designations(descending: true)
+    end
+
+    it 'sends conditions in the body' do
+      expect(client).to receive(:post).with(
+        URI('api/GiftDesignation/Query'), { 'groups' => [{ 'conditions' => [{
+          'parameter' => 'Gift Id', 'operator' => 'Is', 'value' => 102
+        }] }] }
+      ).and_call_original
+
+      client.query_gift_designations(conditions: [{
+                                       parameter: 'Gift Id', operator: 'Is', value: 102
+                                     }])
+    end
+  end
+end