vmware-vra 1.0.0.rc1

data/lib/vra/version.rb

@@ -0,0 +1,21 @@
+#
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Vra
+  VERSION = '1.0.0.rc1'
+end

data/spec/catalog_item_spec.rb

@@ -0,0 +1,98 @@
+#
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Vra::CatalogRequest do
+  let(:client) do
+    Vra::Client.new(username: 'user@corp.local',
+                    password: 'password',
+                    tenant: 'tenant',
+                    base_url: 'https://vra.corp.local')
+  end
+
+  let(:catalog_id) { '9e98042e-5443-4082-afd5-ab5a32939bbc' }
+
+  let(:catalog_item_payload) do
+    {
+      '@type' => 'CatalogItem',
+      'id' => '9e98042e-5443-4082-afd5-ab5a32939bbc',
+      'version' => 2,
+      'name' => 'CentOS 6.6',
+      'description' => 'Blueprint for deploying a CentOS Linux development server',
+      'status' => 'PUBLISHED',
+      'statusName' => 'Published',
+      'organization' => {
+        'tenantRef' => 'vsphere.local',
+        'tenantLabel' => 'vsphere.local',
+        'subtenantRef' => '962ab3f9-858c-4483-a49f-fa97392c314b',
+        'subtenantLabel' => 'catalog_subtenant'
+      },
+      'providerBinding' => {
+        'bindingId' => '33af5413-4f20-4b3b-8268-32edad434dfb',
+        'providerRef' => {
+          'id' => 'c3b2bc30-47b0-454f-b57d-df02a7356fe6',
+          'label' => 'iaas-service'
+        }
+      }
+    }
+  end
+
+  describe '#initialize' do
+    it 'raises an error if no ID or catalog item data have been provided' do
+      expect { Vra::CatalogItem.new }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an error if an ID and catalog item data have both been provided' do
+      expect { Vra::CatalogItem.new(id: 123, data: 'foo') }.to raise_error(ArgumentError)
+    end
+
+    context 'when an ID is provided' do
+      it 'fetches the catalog_item record' do
+        catalog_item = Vra::CatalogItem.allocate
+        expect(catalog_item).to receive(:fetch_catalog_item)
+        catalog_item.send(:initialize, client, id: catalog_id)
+      end
+    end
+
+    context 'when catalog item data is provided' do
+      it 'populates the ID correctly' do
+        catalog_item = Vra::Resource.new(client, data: catalog_item_payload)
+        expect(catalog_item.id).to eq catalog_id
+      end
+    end
+  end
+
+  describe '#fetch_catalog_item' do
+    context 'when the catalog item exists' do
+      let(:response) { double('response', code: 200, body: catalog_item_payload.to_json) }
+
+      it 'calls http_get against the catalog_service' do
+        expect(client).to receive(:http_get).with('/catalog-service/api/consumer/catalogItems/catalog-12345').and_return(response)
+        Vra::CatalogItem.new(client, id: 'catalog-12345')
+      end
+    end
+
+    context 'when the catalog item does not exist' do
+      it 'raises an exception' do
+        allow(client).to receive(:http_get).with('/catalog-service/api/consumer/catalogItems/catalog-12345').and_raise(Vra::Exception::HTTPNotFound)
+        expect { Vra::CatalogItem.new(client, id: 'catalog-12345') }.to raise_error(Vra::Exception::NotFound)
+      end
+    end
+  end
+end

data/spec/catalog_request_spec.rb

@@ -0,0 +1,124 @@
+#
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Vra::CatalogRequest do
+  before(:each) do
+    catalog_item = double('catalog_item')
+    allow(catalog_item).to receive(:blueprint_id).and_return('catalog_blueprint')
+    allow(catalog_item).to receive(:tenant_id).and_return('catalog_tenant')
+    allow(catalog_item).to receive(:subtenant_id).and_return('catalog_subtenant')
+    allow(Vra::CatalogItem).to receive(:new).and_return(catalog_item)
+  end
+
+  let(:client) do
+    Vra::Client.new(username: 'user@corp.local',
+                    password: 'password',
+                    tenant: 'tenant',
+                    base_url: 'https://vra.corp.local')
+  end
+
+  context 'when no subtenant ID is provided' do
+    let(:request) do
+      client.catalog.request('catalog-12345',
+                             cpus: 2,
+                             memory: 1024,
+                             lease_days: 15,
+                             requested_for: 'tester@corp.local',
+                             notes: 'test notes')
+    end
+
+    it 'uses the subtenant ID from the catalog item' do
+      expect(request.subtenant_id).to eq 'catalog_subtenant'
+    end
+  end
+
+  context 'when subtenant is provided, and all shared tests' do
+    let(:request) do
+      client.catalog.request('catalog-12345',
+                             cpus: 2,
+                             memory: 1024,
+                             lease_days: 15,
+                             requested_for: 'tester@corp.local',
+                             notes: 'test notes',
+                             subtenant_id: 'user_subtenant')
+    end
+
+    describe '#initialize' do
+      it 'sets the appropriate instance vars' do
+        expect(request.catalog_id).to eq 'catalog-12345'
+        expect(request.cpus).to eq 2
+        expect(request.memory).to eq 1024
+        expect(request.lease_days).to eq 15
+        expect(request.requested_for).to eq 'tester@corp.local'
+        expect(request.notes).to eq 'test notes'
+        expect(request.subtenant_id).to eq 'user_subtenant'
+      end
+    end
+
+    describe '#validate_params!' do
+      context 'when all required params are provided' do
+        it 'does not raise an exception' do
+          expect { request.validate_params! }.to_not raise_error
+        end
+      end
+
+      context 'when a required parameter is not provided' do
+        it 'raises an exception' do
+          request.cpus = nil
+          expect { request.validate_params! }.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    describe '#request_payload' do
+      it 'properly handles additional parameters' do
+        request.set_parameter('param1', 'string', 'my string')
+        request.set_parameter('param2', 'integer', '2468')
+
+        payload = request.request_payload
+        param1 = payload['requestData']['entries'].find { |x| x['key'] == 'param1' }
+        param2 = payload['requestData']['entries'].find { |x| x['key'] == 'param2' }
+
+        expect(param1).to be_a(Hash)
+        expect(param2).to be_a(Hash)
+        expect(param1['value']['value']).to eq 'my string'
+        expect(param2['value']['value']).to eq 2468
+      end
+    end
+
+    describe '#submit' do
+      before do
+        allow(request).to receive(:request_payload).and_return({})
+        response = double('response', code: 200, headers: { location: '/requests/request-12345' })
+        allow(client).to receive(:http_post).with('/catalog-service/api/consumer/requests', '{}').and_return(response)
+      end
+
+      it 'calls http_post' do
+        expect(client).to receive(:http_post).with('/catalog-service/api/consumer/requests', '{}')
+
+        request.submit
+      end
+
+      it 'returns a Vra::Request object' do
+        expect(request.submit).to be_an_instance_of(Vra::Request)
+      end
+    end
+  end
+end

data/spec/catalog_spec.rb

@@ -0,0 +1,124 @@
+#
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Vra::Catalog do
+  let(:client) do
+    Vra::Client.new(username: 'user@corp.local',
+                    password: 'password',
+                    tenant: 'tenant',
+                    base_url: 'https://vra.corp.local')
+  end
+
+  let(:catalog_item) do
+    {
+      '@type' => 'CatalogItem',
+      'id' => 'a9cd6148-6e0b-4a80-ac47-f5255c52b43d',
+      'version' => 2,
+      'name' => 'CentOS 6.6',
+      'description' => 'Blueprint for deploying a CentOS Linux development server',
+      'status' => 'PUBLISHED',
+      'statusName' => 'Published',
+      'organization' => {
+        'tenantRef' => 'vsphere.local',
+        'tenantLabel' => 'vsphere.local',
+        'subtenantRef' => nil,
+        'subtenantLabel' => nil
+      },
+      'providerBinding' => {
+        'bindingId' => '33af5413-4f20-4b3b-8268-32edad434dfb',
+        'providerRef' => {
+          'id' => 'c3b2bc30-47b0-454f-b57d-df02a7356fe6',
+          'label' => 'iaas-service'
+        }
+      }
+    }
+  end
+
+  let(:entitled_catalog_item) do
+    {
+      '@type' => 'ConsumerEntitledCatalogItem',
+      'catalogItem' => {
+        'id' => 'd29efd6b-3cd6-4f8d-b1d8-da4ddd4e52b1',
+        'version' => 2,
+        'name' => 'WindowsServer2012',
+        'description' => 'Windows Server 2012 with the latest updates and patches.',
+        'status' => 'PUBLISHED',
+        'statusName' => 'Published',
+        'organization' => {
+          'tenantRef' => 'vsphere.local',
+          'tenantLabel' => 'vsphere.local',
+          'subtenantRef' => nil,
+          'subtenantLabel' => nil
+        },
+        'providerBinding' => {
+          'bindingId' => '59fd02a1-acca-4918-9d3d-2298d310caef',
+          'providerRef' => {
+            'id' => 'c3b2bc30-47b0-454f-b57d-df02a7356fe6',
+            'label' => 'iaas-service'
+          }
+        }
+      }
+    }
+  end
+
+  describe '#all_items' do
+    it 'calls the catalogItems endpoint' do
+      expect(client).to receive(:http_get_paginated_array!).with('/catalog-service/api/consumer/catalogItems')
+        .and_return([ catalog_item ])
+
+      client.catalog.all_items
+    end
+
+    it 'returns a Vra::CatalogItem object' do
+      allow(client).to receive(:http_get_paginated_array!).with('/catalog-service/api/consumer/catalogItems')
+        .and_return([ catalog_item ])
+
+      items = client.catalog.all_items
+
+      expect(items.first).to be_an_instance_of(Vra::CatalogItem)
+    end
+  end
+
+  describe '#entitled_items' do
+    it 'calls the entitledCatalogItems endpoint' do
+      expect(client).to receive(:http_get_paginated_array!).with('/catalog-service/api/consumer/entitledCatalogItems')
+        .and_return([ entitled_catalog_item ])
+
+      client.catalog.entitled_items
+    end
+
+    it 'returns a Vra::CatalogItem object' do
+      allow(client).to receive(:http_get_paginated_array!).with('/catalog-service/api/consumer/entitledCatalogItems')
+        .and_return([ entitled_catalog_item ])
+
+      items = client.catalog.entitled_items
+
+      expect(items.first).to be_an_instance_of(Vra::CatalogItem)
+    end
+  end
+
+  describe '#request' do
+    it 'returns a new Vra::CatalogRequest object' do
+      allow(Vra::CatalogItem).to receive(:new)
+      request = client.catalog.request('blueprint-1', cpus: 2)
+      expect(request).to be_an_instance_of(Vra::CatalogRequest)
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,466 @@
+#
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Vra::Client do
+  let(:client) do
+    Vra::Client.new(username: 'user@corp.local',
+                    password: 'password',
+                    tenant: 'tenant',
+                    base_url: 'https://vra.corp.local')
+  end
+
+  describe '#initialize' do
+    it 'calls validate_client_options!' do
+      client = Vra::Client.allocate
+      expect(client).to receive(:validate_client_options!)
+      client.send(:initialize, username: 'user@corp.local',
+                               password: 'password',
+                               tenant: 'tenant',
+                               base_url: 'https://vra.corp.local')
+    end
+  end
+
+  describe '#request_headers' do
+    context 'when bearer token exists' do
+      it 'has an Authorization header' do
+        client.bearer_token = '12345'
+        expect(client.request_headers.key?('Authorization')).to be true
+      end
+    end
+
+    context 'when bearer token does not exist' do
+      it 'has an Authorization header' do
+        expect(client.request_headers.key?('Authorization')).to be false
+      end
+    end
+  end
+
+  describe '#authorize!' do
+    context 'when a token is not authorized or no token exists' do
+      it 'generates a token successfully' do
+        allow(client).to receive(:authorized?).twice.and_return(false, true)
+        expect(client).to receive(:generate_bearer_token)
+
+        client.authorize!
+      end
+
+      it 'raises an exception if token generation fails' do
+        allow(client).to receive(:authorized?).and_return(false)
+        allow(client).to receive(:generate_bearer_token).and_raise(Vra::Exception::Unauthorized)
+
+        expect { client.authorize! }.to raise_error(Vra::Exception::Unauthorized)
+      end
+
+      it 'raises an exception if a generated token is unauthorized' do
+        allow(client).to receive(:authorized).twice.and_return(false, false)
+        allow(client).to receive(:generate_bearer_token)
+
+        expect { client.authorize! }.to raise_error(Vra::Exception::Unauthorized)
+      end
+    end
+
+    context 'when a token is authorized' do
+      it 'does not generate a new token' do
+        allow(client).to receive(:authorized?).and_return(true)
+        expect(client).to_not receive(:generate_bearer_token)
+
+        client.authorize!
+      end
+    end
+  end
+
+  describe '#authorized?' do
+    context 'when token does not exist' do
+      it 'returns false' do
+        expect(client.authorized?).to be false
+      end
+    end
+
+    context 'when token exists' do
+      before(:each) do
+        client.bearer_token = '12345'
+      end
+
+      url = '/identity/api/tokens/12345'
+
+      it 'returns true if the token validates successfully' do
+        response = double('response')
+        allow(response).to receive(:code).and_return(204)
+        allow(client).to receive(:http_head).with(url, :skip_auth).and_return(response)
+
+        expect(client.authorized?).to be true
+      end
+
+      it 'returns false if the token validates unsuccessfully' do
+        response = double('response')
+        allow(response).to receive(:code).and_return(500)
+        allow(client).to receive(:http_head).with(url, :skip_auth).and_return(response)
+
+        expect(client.authorized?).to be false
+      end
+    end
+  end
+
+  describe '#generate_bearer_token' do
+    payload = {
+      'username' => 'user@corp.local',
+      'password' => 'password',
+      'tenant'   => 'tenant'
+    }.to_json
+
+    it 'posts to the tokens API endpoint' do
+      response = double('response')
+      allow(response).to receive(:code).and_return(200)
+      allow(response).to receive(:body).and_return('{"id":"12345"}')
+      expect(client).to receive(:http_post).with('/identity/api/tokens',
+                                                 payload,
+                                                 :skip_auth).and_return(response)
+
+      client.generate_bearer_token
+    end
+
+    context 'when token is generated successfully' do
+      it 'sets the token' do
+        response = double('response')
+        allow(response).to receive(:code).and_return(200)
+        allow(response).to receive(:body).and_return('{"id":"12345"}')
+        allow(client).to receive(:http_post).with('/identity/api/tokens',
+                                                  payload,
+                                                  :skip_auth).and_return(response)
+
+        client.generate_bearer_token
+
+        expect(client.bearer_token).to eq '12345'
+      end
+    end
+
+    context 'when token is not generated successfully' do
+      it 'raises an exception' do
+        response = double('response')
+        allow(response).to receive(:code).and_return(500)
+        allow(response).to receive(:body).and_return('error string')
+        allow(client).to receive(:http_post).with('/identity/api/tokens',
+                                                  payload,
+                                                  :skip_auth)
+          .and_return(response)
+
+        expect { client.generate_bearer_token }.to raise_error(Vra::Exception::Unauthorized)
+      end
+    end
+  end
+
+  describe '#full_url' do
+    it 'returns a properly formatted url' do
+      expect(client.full_url('/mypath')).to eq 'https://vra.corp.local/mypath'
+    end
+  end
+
+  describe '#http_head' do
+    context 'when skip_auth is nil' do
+      it 'authorizes before proceeding' do
+        response = double('response')
+        allow(RestClient::Request).to receive(:execute).and_return(response)
+        expect(client).to receive(:authorize!)
+
+        client.http_head('/test')
+      end
+    end
+
+    context 'when skip_auth is not nil' do
+      it 'does not authorize before proceeding' do
+        response = double('response')
+        allow(RestClient::Request).to receive(:execute).and_return(response)
+        expect(client).to_not receive(:authorize!)
+
+        client.http_head('/test', :skip_auth)
+      end
+    end
+
+    it 'calls RestClient::Request#execute' do
+      response   = double('response')
+      path       = '/test'
+      full_url   = 'https://vra.corp.local/test'
+      headers    = { 'Accept' => 'application/json', 'Content-Type' => 'application/json' }
+      verify_ssl = true
+
+      allow(client).to receive(:authorize!)
+      expect(RestClient::Request).to receive(:execute).with(method: :head,
+                                                            url: full_url,
+                                                            headers: headers,
+                                                            verify_ssl: verify_ssl)
+        .and_return(response)
+
+      client.http_head(path)
+    end
+  end
+
+  describe '#http_get' do
+    context 'when skip_auth is nil' do
+      it 'authorizes before proceeding' do
+        response = double('response')
+        allow(RestClient::Request).to receive(:execute).and_return(response)
+        expect(client).to receive(:authorize!)
+
+        client.http_get('/test')
+      end
+    end
+
+    context 'when skip_auth is not nil' do
+      it 'does not authorize before proceeding' do
+        response = double('response')
+        allow(RestClient::Request).to receive(:execute).and_return(response)
+        expect(client).to_not receive(:authorize!)
+
+        client.http_get('/test', :skip_auth)
+      end
+    end
+
+    it 'calls RestClient::Request#execute' do
+      response   = double('response')
+      path       = '/test'
+      full_url   = 'https://vra.corp.local/test'
+      headers    = { 'Accept' => 'application/json', 'Content-Type' => 'application/json' }
+      verify_ssl = true
+
+      allow(client).to receive(:authorize!)
+      expect(RestClient::Request).to receive(:execute).with(method: :get,
+                                                            url: full_url,
+                                                            headers: headers,
+                                                            verify_ssl: verify_ssl)
+        .and_return(response)
+
+      client.http_get(path)
+    end
+
+    it 'calls raise_http_exception upon a RestClient error' do
+      allow(client).to receive(:authorize!)
+      allow(RestClient::Request).to receive(:execute).and_raise(RestClient::ResourceNotFound)
+      expect(client).to receive(:raise_http_exception)
+
+      client.http_get('/404')
+    end
+  end
+
+  describe '#http_get!' do
+    it 'returns the response body' do
+      response = double('response', body: 'body text')
+      allow(client).to receive(:http_get).with('/test').and_return(response)
+
+      expect(client.http_get!('/test')).to eq 'body text'
+    end
+  end
+
+  describe '#http_get_paginated_array!' do
+    it 'allows a limit override' do
+      expect(client).to receive(:http_get!)
+        .with('/test?limit=10&page=1')
+        .and_return({ 'content' => [], 'metadata' => { 'totalPages' => 1 } }.to_json)
+
+      client.http_get_paginated_array!('/test', 10)
+    end
+
+    it 'only calls http_get! once when total pages is 0 (no items)' do
+      expect(client).to receive(:http_get!)
+        .once
+        .with('/test?limit=20&page=1')
+        .and_return({ 'content' => [], 'metadata' => { 'totalPages' => 0 } }.to_json)
+
+      client.http_get_paginated_array!('/test')
+    end
+
+    it 'only calls http_get! once when total pages is 1' do
+      expect(client).to receive(:http_get!)
+        .once
+        .with('/test?limit=20&page=1')
+        .and_return({ 'content' => [], 'metadata' => { 'totalPages' => 1 } }.to_json)
+
+      client.http_get_paginated_array!('/test')
+    end
+
+    it 'calls http_get! 3 times if there are 3 pages of response' do
+      expect(client).to receive(:http_get!)
+        .with('/test?limit=20&page=1')
+        .and_return({ 'content' => [], 'metadata' => { 'totalPages' => 3 } }.to_json)
+      expect(client).to receive(:http_get!)
+        .with('/test?limit=20&page=2')
+        .and_return({ 'content' => [], 'metadata' => { 'totalPages' => 3 } }.to_json)
+      expect(client).to receive(:http_get!)
+        .with('/test?limit=20&page=3')
+        .and_return({ 'content' => [], 'metadata' => { 'totalPages' => 3 } }.to_json)
+
+      client.http_get_paginated_array!('/test')
+    end
+  end
+
+  describe '#http_post' do
+    context 'when skip_auth is nil' do
+      it 'authorizes before proceeding' do
+        response = double('response')
+        allow(RestClient::Request).to receive(:execute).and_return(response)
+        expect(client).to receive(:authorize!)
+
+        client.http_post('/test', 'some payload')
+      end
+    end
+
+    context 'when skip_auth is not nil' do
+      it 'does not authorize before proceeding' do
+        response = double('response')
+        allow(RestClient::Request).to receive(:execute).and_return(response)
+        expect(client).to_not receive(:authorize!)
+
+        client.http_post('/test', 'some payload', :skip_auth)
+      end
+    end
+
+    it 'calls RestClient::Request#execute' do
+      response   = double('response')
+      path       = '/test'
+      full_url   = 'https://vra.corp.local/test'
+      headers    = { 'Accept' => 'application/json', 'Content-Type' => 'application/json' }
+      payload    = 'some payload'
+      verify_ssl = true
+
+      allow(client).to receive(:authorize!)
+      expect(RestClient::Request).to receive(:execute).with(method: :post,
+                                                            url: full_url,
+                                                            headers: headers,
+                                                            payload: payload,
+                                                            verify_ssl: verify_ssl)
+        .and_return(response)
+
+      client.http_post(path, payload)
+    end
+
+    it 'calls raise_http_exception upon a RestClient error' do
+      allow(client).to receive(:authorize!)
+      allow(RestClient::Request).to receive(:execute).and_raise(RestClient::ResourceNotFound)
+      expect(client).to receive(:raise_http_exception)
+
+      client.http_post('/404', 'test payload')
+    end
+  end
+
+  describe '#http_post!' do
+    it 'returns the response body' do
+      response = double('response', body: 'body text')
+      allow(client).to receive(:http_post).with('/test', 'test payload').and_return(response)
+
+      expect(client.http_post!('/test', 'test payload')).to eq 'body text'
+    end
+  end
+
+  describe '#raise_http_exception' do
+    context 'when a 404 is received' do
+      let(:exception) do
+        double('RestClient::ResourceNotFound',
+               http_code: 404,
+               message: 'Not Found',
+               response: '404 Not Found')
+      end
+
+      it 'raises a Vra::Exception::HTTPNotFound exception' do
+        expect { client.raise_http_exception(exception, '/test') }.to raise_error(Vra::Exception::HTTPNotFound)
+      end
+    end
+
+    context 'when an unspecified http error is received' do
+      let(:exception) do
+        double('RestClient::BadRequest',
+               http_code: 400,
+               message: 'Bad Request',
+               response: '400 Bad Request')
+      end
+
+      it 'raises a Vra::Exception::HTTPError exception' do
+        expect { client.raise_http_exception(exception, '/test') }.to raise_error(Vra::Exception::HTTPError)
+      end
+    end
+  end
+
+  describe '#validate_client_options!' do
+    context 'when all required options are supplied' do
+      it 'does not raise an exception' do
+        expect { client.validate_client_options! }.not_to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when username is missing' do
+      let(:client) do
+        Vra::Client.new(password: 'password',
+                        tenant: 'tenant',
+                        base_url: 'https://vra.corp.local')
+      end
+
+      it 'raises an exception' do
+        expect { client.validate_client_options! }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when password is missing' do
+      let(:client) do
+        Vra::Client.new(username: 'username',
+                        tenant: 'tenant',
+                        base_url: 'https://vra.corp.local')
+      end
+
+      it 'raises an exception' do
+        expect { client.validate_client_options! }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when tenant is missing' do
+      let(:client) do
+        Vra::Client.new(username: 'username',
+                        password: 'password',
+                        base_url: 'https://vra.corp.local')
+      end
+
+      it 'raises an exception' do
+        expect { client.validate_client_options! }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when base URL is missing' do
+      let(:client) do
+        Vra::Client.new(username: 'username',
+                        password: 'password',
+                        tenant: 'tenant')
+      end
+
+      it 'raises an exception' do
+        expect { client.validate_client_options! }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when base URL is not a valid HTTP URL' do
+      let(:client) do
+        Vra::Client.new(username: 'username',
+                        password: 'password',
+                        tenant: 'tenant',
+                        base_url: 'something-that-is-not-a-HTTP-URI')
+      end
+
+      it 'raises an exception' do
+        expect { client.validate_client_options! }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end