vmware-vra 2.1.0 → 2.1.1

data/spec/catalog_request_spec.rb

@@ -17,143 +17,143 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+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')
+    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')
+    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
+  context "when no subtenant ID is provided" do
     let(:request) do
-      client.catalog.request('catalog-12345',
+      client.catalog.request("catalog-12345",
                              cpus: 2,
                              memory: 1024,
                              lease_days: 15,
-                             requested_for: 'tester@corp.local',
-                             notes: 'test notes')
+                             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'
+    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
+  context "when subtenant is provided, and all shared tests" do
     let(:request) do
-      client.catalog.request('catalog-12345',
+      client.catalog.request("catalog-12345",
                              cpus: 2,
                              memory: 1024,
                              lease_days: 15,
-                             requested_for: 'tester@corp.local',
-                             notes: 'test notes',
-                             subtenant_id: 'user_subtenant')
+                             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'
+    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'
+        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
+    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
+      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 '#merge_payload' do
-      it 'properly handles additional parameters' do
-        request.set_parameter('param1', 'string', 'my string')
-        request.set_parameter('param2', 'integer', '2468')
+    describe "#merge_payload" do
+      it "properly handles additional parameters" do
+        request.set_parameter("param1", "string", "my string")
+        request.set_parameter("param2", "integer", "2468")
 
-        template = File.read('spec/fixtures/resource/catalog_request.json')
+        template = File.read("spec/fixtures/resource/catalog_request.json")
         payload = JSON.parse(request.merge_payload(template))
-        param1 = payload['data']['my_blueprint']['data']['param1']
-        param2 = payload['data']['my_blueprint']['data']['param2']
+        param1 = payload["data"]["my_blueprint"]["data"]["param1"]
+        param2 = payload["data"]["my_blueprint"]["data"]["param2"]
 
         expect(param1).to be_a(String)
         expect(param2).to be_a(String)
-        expect(param1).to eq 'my string'
-        expect(param2).to eq '2468'
+        expect(param1).to eq "my string"
+        expect(param2).to eq "2468"
       end
     end
 
-    describe '#submit' do
+    describe "#submit" do
       before do
         allow(request).to receive(:request_payload).and_return({})
-        response = double('response', location: '/requests/request-12345')
-        allow(client).to receive(:http_post).with('/catalog-service/api/consumer/requests', '{}').and_return(response)
+        response = double("response", 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
-        skip 'broken and needs to be updated per changes -JJ 2017-04-14'
-        expect(client).to receive(:http_post).with('/catalog-service/api/consumer/requests', '{}')
+      it "calls http_post" do
+        skip "broken and needs to be updated per changes -JJ 2017-04-14"
+        expect(client).to receive(:http_post).with("/catalog-service/api/consumer/requests", "{}")
 
         request.submit
       end
 
-      it 'returns a Vra::Request object' do
-        skip 'broken and needs to be updated per changes -JJ 2017-04-14'
+      it "returns a Vra::Request object" do
+        skip "broken and needs to be updated per changes -JJ 2017-04-14"
         expect(request.submit).to be_an_instance_of(Vra::Request)
       end
     end
   end
 
   let(:client_without_ssl) do
-    Vra::Client.new(username: 'user@corp.local',
-                    password: 'password',
-                    tenant: 'tenant',
-                    base_url: 'https://vra.corp.local',
+    Vra::Client.new(username: "user@corp.local",
+                    password: "password",
+                    tenant: "tenant",
+                    base_url: "https://vra.corp.local",
                     verify_ssl: false)
   end
 
-  context 'when ssl is not verified by the client' do
+  context "when ssl is not verified by the client" do
     let(:request) do
-      client_without_ssl.catalog.request('catalog-12345',
+      client_without_ssl.catalog.request("catalog-12345",
                                          cpus: 2,
                                          memory: 1024,
                                          lease_days: 15,
-                                         requested_for: 'tester@corp.local',
-                                         notes: 'test notes',
-                                         subtenant_id: 'user_subtenant')
+                                         requested_for: "tester@corp.local",
+                                         notes: "test notes",
+                                         subtenant_id: "user_subtenant")
     end
 
     describe do
-      it 'passes verify_false to Vra::Http' do
-        skip 'broken and needs to be updated per changes -JJ 2017-04-14'
+      it "passes verify_false to Vra::Http" do
+        skip "broken and needs to be updated per changes -JJ 2017-04-14"
         allow(request.client).to receive(:authorized?).and_return(true)
-        expect(request.client.instance_variable_get('@verify_ssl')).to eq false
+        expect(request.client.instance_variable_get("@verify_ssl")).to eq false
 
         expect(Vra::Http).to receive(:execute).and_wrap_original do |_http, *args|
           expect(*args).to include(verify_ssl: false)
-          double(location: 'auth/request_id')
+          double(location: "auth/request_id")
         end
 
         request.submit

data/spec/catalog_spec.rb

@@ -17,78 +17,78 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+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')
+    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
+      "@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",
+        },
       },
-      '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
+      "@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'
-          }
-        }
-      }
+        "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')
+  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')
+    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
@@ -97,16 +97,16 @@ describe Vra::Catalog do
     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')
+  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')
+    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
@@ -115,10 +115,10 @@ describe Vra::Catalog do
     end
   end
 
-  describe '#request' do
-    it 'returns a new Vra::CatalogRequest object' do
+  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)
+      request = client.catalog.request("blueprint-1", cpus: 2)
       expect(request).to be_an_instance_of(Vra::CatalogRequest)
     end
   end

data/spec/client_spec.rb

@@ -17,65 +17,65 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+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')
+    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
+  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')
+      client.send(:initialize, username: "user@corp.local",
+                               password: "password",
+                               tenant: "tenant",
+                               base_url: "https://vra.corp.local")
     end
   end
 
-  describe '#bearer_token_request_body' do
-    it 'gets the correct password from the PasswordMasker object' do
-      expect(client.bearer_token_request_body['password']).to eq('password')
+  describe "#bearer_token_request_body" do
+    it "gets the correct password from the PasswordMasker object" do
+      expect(client.bearer_token_request_body["password"]).to eq("password")
     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
+  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
+    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
+  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
+      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
+      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)
 
@@ -83,8 +83,8 @@ describe Vra::Client do
       end
     end
 
-    context 'when a token is authorized' do
-      it 'does not generate a new token' do
+    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)
 
@@ -93,27 +93,27 @@ describe Vra::Client do
     end
   end
 
-  describe '#authorized?' do
-    context 'when token does not exist' do
-      it 'returns false' do
+  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
+    context "when token exists" do
       before(:each) do
-        client.bearer_token = '12345'
+        client.bearer_token = "12345"
       end
 
-      it 'returns true if the token validates successfully' do
-        response = double('response', success_no_content?: true, code: 204)
+      it "returns true if the token validates successfully" do
+        response = double("response", success_no_content?: true, code: 204)
         allow(Vra::Http).to receive(:execute).and_return(response)
 
         expect(client.authorized?).to be true
       end
 
-      it 'returns false if the token validates unsuccessfully' do
-        response = double('response', success_no_content?: false, code: 500)
+      it "returns false if the token validates unsuccessfully" do
+        response = double("response", success_no_content?: false, code: 500)
         allow(Vra::Http).to receive(:execute).and_return(response)
 
         expect(client.authorized?).to be false
@@ -121,18 +121,18 @@ describe Vra::Client do
     end
   end
 
-  describe '#generate_bearer_token' do
+  describe "#generate_bearer_token" do
     payload = {
-      'username' => 'user@corp.local',
-      'password' => 'password',
-      'tenant'   => 'tenant'
+      "username" => "user@corp.local",
+      "password" => "password",
+      "tenant"   => "tenant",
     }.to_json
 
-    it 'posts to the tokens API endpoint' do
-      response = double('response', code: 200, body: '{"id":"12345"}', success_ok?: true)
+    it "posts to the tokens API endpoint" do
+      response = double("response", code: 200, body: '{"id":"12345"}', success_ok?: true)
       expect(Vra::Http).to receive(:execute)
         .with(method: :post,
-              url: client.full_url('/identity/api/tokens'),
+              url: client.full_url("/identity/api/tokens"),
               payload: payload,
               headers: anything,
               verify_ssl: true)
@@ -141,20 +141,20 @@ describe Vra::Client do
       client.generate_bearer_token
     end
 
-    context 'when token is generated successfully' do
-      it 'sets the token' do
-        response = double('response', code: 200, body: '{"id":"12345"}', success_ok?: true)
+    context "when token is generated successfully" do
+      it "sets the token" do
+        response = double("response", code: 200, body: '{"id":"12345"}', success_ok?: true)
         allow(Vra::Http).to receive(:execute).and_return(response)
 
         client.generate_bearer_token
 
-        expect(client.bearer_token).to eq '12345'
+        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', code: 500, body: 'error string', success_ok?: false)
+    context "when token is not generated successfully" do
+      it "raises an exception" do
+        response = double("response", code: 500, body: "error string", success_ok?: false)
         allow(Vra::Http).to receive(:execute).and_return(response)
 
         expect { client.generate_bearer_token }.to raise_error(Vra::Exception::Unauthorized)
@@ -162,38 +162,38 @@ describe Vra::Client do
     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'
+  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')
+  describe "#http_head" do
+    context "when skip_auth is nil" do
+      it "authorizes before proceeding" do
+        response = double("response")
         allow(Vra::Http).to receive(:execute).and_return(response)
         expect(client).to receive(:authorize!)
 
-        client.http_head('/test')
+        client.http_head("/test")
       end
     end
 
-    context 'when skip_auth is not nil' do
-      it 'does not authorize before proceeding' do
-        response = double('response')
+    context "when skip_auth is not nil" do
+      it "does not authorize before proceeding" do
+        response = double("response")
         allow(Vra::Http).to receive(:execute).and_return(response)
         expect(client).to_not receive(:authorize!)
 
-        client.http_head('/test', :skip_auth)
+        client.http_head("/test", :skip_auth)
       end
     end
 
-    it 'calls Vra::Http.execute' do
-      response   = double('response')
-      path       = '/test'
-      full_url   = 'https://vra.corp.local/test'
-      headers    = { 'Accept' => 'application/json', 'Content-Type' => 'application/json' }
+    it "calls Vra::Http.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!)
@@ -206,41 +206,41 @@ describe Vra::Client do
       client.http_head(path)
     end
 
-    it 'raises an HTTPNotFound on a 404 error' do
+    it "raises an HTTPNotFound on a 404 error" do
       allow(client).to receive(:authorize!)
       allow(Vra::Http).to receive(:execute)
-        .and_raise(Vra::Http::Error.new('message', 404, 'Not Found'))
+        .and_raise(Vra::Http::Error.new("message", 404, "Not Found"))
 
-      expect { client.http_head('/404') }.to raise_error(Vra::Exception::HTTPNotFound)
+      expect { client.http_head("/404") }.to raise_error(Vra::Exception::HTTPNotFound)
     end
   end
 
-  describe '#http_get' do
-    context 'when skip_auth is nil' do
-      it 'authorizes before proceeding' do
-        response = double('response')
+  describe "#http_get" do
+    context "when skip_auth is nil" do
+      it "authorizes before proceeding" do
+        response = double("response")
         allow(Vra::Http).to receive(:execute).and_return(response)
         expect(client).to receive(:authorize!)
 
-        client.http_get('/test')
+        client.http_get("/test")
       end
     end
 
-    context 'when skip_auth is not nil' do
-      it 'does not authorize before proceeding' do
-        response = double('response')
+    context "when skip_auth is not nil" do
+      it "does not authorize before proceeding" do
+        response = double("response")
         allow(Vra::Http).to receive(:execute).and_return(response)
         expect(client).to_not receive(:authorize!)
 
-        client.http_get('/test', :skip_auth)
+        client.http_get("/test", :skip_auth)
       end
     end
 
-    it 'calls Vra::Http.execute' do
-      response   = double('response')
-      path       = '/test'
-      full_url   = 'https://vra.corp.local/test'
-      headers    = { 'Accept' => 'application/json', 'Content-Type' => 'application/json' }
+    it "calls Vra::Http.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!)
@@ -253,93 +253,93 @@ describe Vra::Client do
       client.http_get(path)
     end
 
-    it 'raises an HTTPNotFound on a 404 error' do
+    it "raises an HTTPNotFound on a 404 error" do
       allow(client).to receive(:authorize!)
       allow(Vra::Http).to receive(:execute)
-        .and_raise(Vra::Http::Error.new('message', 404, 'Not Found'))
+        .and_raise(Vra::Http::Error.new("message", 404, "Not Found"))
 
-      expect { client.http_get('/404') }.to raise_error(Vra::Exception::HTTPNotFound)
+      expect { client.http_get("/404") }.to raise_error(Vra::Exception::HTTPNotFound)
     end
   end
 
-  describe '#http_get_paginated_array!' do
-    it 'allows a limit override' do
+  describe "#http_get_paginated_array!" do
+    it "allows a limit override" do
       client.page_size = 10
       expect(client).to receive(:get_parsed)
-        .with('/test?limit=10&page=1')
-        .and_return('content' => [], 'metadata' => { 'totalPages' => 1 })
+        .with("/test?limit=10&page=1")
+        .and_return("content" => [], "metadata" => { "totalPages" => 1 })
 
-      client.http_get_paginated_array!('/test')
+      client.http_get_paginated_array!("/test")
     end
 
-    it 'only calls get_parsed once when total pages is 0 (no items)' do
+    it "only calls get_parsed once when total pages is 0 (no items)" do
       expect(client).to receive(:get_parsed)
         .once
-        .with('/test?limit=20&page=1')
-        .and_return('content' => [], 'metadata' => { 'totalPages' => 0 })
+        .with("/test?limit=20&page=1")
+        .and_return("content" => [], "metadata" => { "totalPages" => 0 })
 
-      client.http_get_paginated_array!('/test')
+      client.http_get_paginated_array!("/test")
     end
 
-    it 'only calls get_parsed once when total pages is 1' do
+    it "only calls get_parsed once when total pages is 1" do
       expect(client).to receive(:get_parsed)
         .once
-        .with('/test?limit=20&page=1')
-        .and_return('content' => [], 'metadata' => { 'totalPages' => 1 })
+        .with("/test?limit=20&page=1")
+        .and_return("content" => [], "metadata" => { "totalPages" => 1 })
 
-      client.http_get_paginated_array!('/test')
+      client.http_get_paginated_array!("/test")
     end
 
-    it 'calls get_parsed 3 times if there are 3 pages of response' do
+    it "calls get_parsed 3 times if there are 3 pages of response" do
       expect(client).to receive(:get_parsed)
-        .with('/test?limit=20&page=1')
-        .and_return('content' => [], 'metadata' => { 'totalPages' => 3 })
+        .with("/test?limit=20&page=1")
+        .and_return("content" => [], "metadata" => { "totalPages" => 3 })
       expect(client).to receive(:get_parsed)
-        .with('/test?limit=20&page=2')
-        .and_return('content' => [], 'metadata' => { 'totalPages' => 3 })
+        .with("/test?limit=20&page=2")
+        .and_return("content" => [], "metadata" => { "totalPages" => 3 })
       expect(client).to receive(:get_parsed)
-        .with('/test?limit=20&page=3')
-        .and_return('content' => [], 'metadata' => { 'totalPages' => 3 })
+        .with("/test?limit=20&page=3")
+        .and_return("content" => [], "metadata" => { "totalPages" => 3 })
 
-      client.http_get_paginated_array!('/test')
+      client.http_get_paginated_array!("/test")
     end
 
-    it 'raises an exception if duplicate items are returned by the API' do
+    it "raises an exception if duplicate items are returned by the API" do
       allow(client).to receive(:get_parsed)
-        .with('/test?limit=20&page=1')
-        .and_return('content' => [ 1, 2, 3, 1 ], 'metadata' => { 'totalPages' => 1 })
+        .with("/test?limit=20&page=1")
+        .and_return("content" => [ 1, 2, 3, 1 ], "metadata" => { "totalPages" => 1 })
 
-      expect { client.http_get_paginated_array!('/test') }.to raise_error(Vra::Exception::DuplicateItemsDetected)
+      expect { client.http_get_paginated_array!("/test") }.to raise_error(Vra::Exception::DuplicateItemsDetected)
     end
   end
 
-  describe '#http_post' do
-    context 'when skip_auth is nil' do
-      it 'authorizes before proceeding' do
-        response = double('response')
+  describe "#http_post" do
+    context "when skip_auth is nil" do
+      it "authorizes before proceeding" do
+        response = double("response")
         allow(Vra::Http).to receive(:execute).and_return(response)
         expect(client).to receive(:authorize!)
 
-        client.http_post('/test', 'some payload')
+        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')
+    context "when skip_auth is not nil" do
+      it "does not authorize before proceeding" do
+        response = double("response")
         allow(Vra::Http).to receive(:execute).and_return(response)
         expect(client).to_not receive(:authorize!)
 
-        client.http_post('/test', 'some payload', :skip_auth)
+        client.http_post("/test", "some payload", :skip_auth)
       end
     end
 
-    it 'calls Vra::Http.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'
+    it "calls Vra::Http.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!)
@@ -353,12 +353,12 @@ describe Vra::Client do
       client.http_post(path, payload)
     end
 
-    context 'when not verifying ssl' do
+    context "when not verifying ssl" do
       let(:unverified_client) do
-        Vra::Client.new(username: 'user@corp.local',
-                        password: 'password',
-                        tenant: 'tenant',
-                        base_url: 'https://vra.corp.local',
+        Vra::Client.new(username: "user@corp.local",
+                        password: "password",
+                        tenant: "tenant",
+                        base_url: "https://vra.corp.local",
                         verify_ssl: false)
       end
 
@@ -366,130 +366,130 @@ describe Vra::Client do
         allow(unverified_client).to receive(:authorized?).and_return(true)
       end
 
-      it 'configures Net::HTTP with VERIFY_NONE' do
+      it "configures Net::HTTP with VERIFY_NONE" do
         allow(Net::HTTP).to receive(:start).and_wrap_original do |_http, *args|
           expect(args.last).to include(verify_mode: OpenSSL::SSL::VERIFY_NONE)
-          double('response', final?: true, success?: true)
+          double("response", final?: true, success?: true)
         end
 
-        unverified_client.http_post('/path', 'payload')
+        unverified_client.http_post("/path", "payload")
 
         [:head, :get].each do |method|
-          unverified_client.http_fetch(method, '/test', true)
+          unverified_client.http_fetch(method, "/test", true)
         end
       end
     end
 
-    it 'calls raise_http_exception upon error' do
+    it "calls raise_http_exception upon error" do
       allow(client).to receive(:authorize!)
       allow(Vra::Http).to receive(:execute).and_raise(StandardError)
       expect(client).to receive(:raise_http_exception)
 
-      client.http_post('/404', 'test payload')
+      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)
+  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'
+      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
+  describe "#raise_http_exception" do
+    context "when a 404 is received" do
       let(:exception) do
-        double('RestClient::ResourceNotFound',
+        double("RestClient::ResourceNotFound",
                http_code: 404,
-               message: 'Not Found',
-               response: '404 Not Found')
+               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)
+      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
+    context "when an unspecified http error is received" do
       let(:exception) do
-        double('RestClient::BadRequest',
+        double("RestClient::BadRequest",
                http_code: 400,
-               message: 'Bad Request',
-               response: '400 Bad Request')
+               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)
+      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
+  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
       end
     end
 
-    context 'when username is missing' do
+    context "when username is missing" do
       let(:client) do
-        Vra::Client.new(password: 'password',
-                        tenant: 'tenant',
-                        base_url: 'https://vra.corp.local')
+        Vra::Client.new(password: "password",
+                        tenant: "tenant",
+                        base_url: "https://vra.corp.local")
       end
 
-      it 'raises an exception' do
+      it "raises an exception" do
         expect { client.validate_client_options! }.to raise_error(ArgumentError)
       end
     end
 
-    context 'when password is missing' do
+    context "when password is missing" do
       let(:client) do
-        Vra::Client.new(username: 'username',
-                        tenant: 'tenant',
-                        base_url: 'https://vra.corp.local')
+        Vra::Client.new(username: "username",
+                        tenant: "tenant",
+                        base_url: "https://vra.corp.local")
       end
 
-      it 'raises an exception' do
+      it "raises an exception" do
         expect { client.validate_client_options! }.to raise_error(ArgumentError)
       end
     end
 
-    context 'when tenant is missing' do
+    context "when tenant is missing" do
       let(:client) do
-        Vra::Client.new(username: 'username',
-                        password: 'password',
-                        base_url: 'https://vra.corp.local')
+        Vra::Client.new(username: "username",
+                        password: "password",
+                        base_url: "https://vra.corp.local")
       end
 
-      it 'raises an exception' do
+      it "raises an exception" do
         expect { client.validate_client_options! }.to raise_error(ArgumentError)
       end
     end
 
-    context 'when base URL is missing' do
+    context "when base URL is missing" do
       let(:client) do
-        Vra::Client.new(username: 'username',
-                        password: 'password',
-                        tenant: 'tenant')
+        Vra::Client.new(username: "username",
+                        password: "password",
+                        tenant: "tenant")
       end
 
-      it 'raises an exception' do
+      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
+    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')
+        Vra::Client.new(username: "username",
+                        password: "password",
+                        tenant: "tenant",
+                        base_url: "something-that-is-not-a-HTTP-URI")
       end
 
-      it 'raises an exception' do
+      it "raises an exception" do
         expect { client.validate_client_options! }.to raise_error(ArgumentError)
       end
     end