vmware-vra 2.1.0 → 2.1.1

data/spec/http_spec.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'webmock'
+require "spec_helper"
+require "webmock"
 
 describe Vra::Http do
-  def expecting_request(method, url, with=nil)
+  def expecting_request(method, url, with = nil)
     stub = stub_request(method, url)
     stub.with(with) if with
     yield if block_given?
@@ -26,114 +26,114 @@ describe Vra::Http do
     execute :head, params
   end
 
-  describe '#execute' do
-    it 'makes a HEAD request' do
-      headers = { 'X-Made-Up-Header' => 'Foo AND bar?  Are you sure?' }
+  describe "#execute" do
+    it "makes a HEAD request" do
+      headers = { "X-Made-Up-Header" => "Foo AND bar?  Are you sure?" }
 
-      expecting_request(:head, 'http://test.local', headers: headers) do
-        head url: 'http://test.local', headers: headers
+      expecting_request(:head, "http://test.local", headers: headers) do
+        head url: "http://test.local", headers: headers
       end
     end
 
-    it 'makes a GET request' do
-      headers = { 'X-Made-Up-Header' => 'Foo AND bar?  Are you sure?' }
+    it "makes a GET request" do
+      headers = { "X-Made-Up-Header" => "Foo AND bar?  Are you sure?" }
 
-      expecting_request(:get, 'http://test.local', headers: headers) do
-        get url: 'http://test.local', headers: headers
+      expecting_request(:get, "http://test.local", headers: headers) do
+        get url: "http://test.local", headers: headers
       end
     end
 
-    it 'makes a POST request' do
-      headers = { 'X-Made-Up-Header' => 'Foo AND bar?  Are you sure?' }
-      payload = 'withabodylikethis'
+    it "makes a POST request" do
+      headers = { "X-Made-Up-Header" => "Foo AND bar?  Are you sure?" }
+      payload = "withabodylikethis"
 
-      expecting_request(:post, 'http://test.local', headers: headers, body: payload) do
-        post url: 'http://test.local', headers: headers, payload: payload
+      expecting_request(:post, "http://test.local", headers: headers, body: payload) do
+        post url: "http://test.local", headers: headers, payload: payload
       end
     end
 
-    it 'preserves Location' do
-      stub_request(:head, 'http://test.local')
-        .to_return(headers: { 'Location' => 'http://test-location.local' })
+    it "preserves Location" do
+      stub_request(:head, "http://test.local")
+        .to_return(headers: { "Location" => "http://test-location.local" })
 
-      response = head(url: 'http://test.local')
+      response = head(url: "http://test.local")
 
-      expect(response.location).to eq 'http://test-location.local'
+      expect(response.location).to eq "http://test-location.local"
     end
 
-    it 'preserves status code' do
-      stub_request(:head, 'http://test.local')
-        .to_return(status: [204, 'No content'])
+    it "preserves status code" do
+      stub_request(:head, "http://test.local")
+        .to_return(status: [204, "No content"])
 
-      response = head(url: 'http://test.local')
+      response = head(url: "http://test.local")
 
       expect(response.code).to eq 204
     end
 
-    it 'configures ssl verification' do
+    it "configures ssl verification" 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
 
-      execute(:get, url: 'https://test.local', verify_ssl: false)
+      execute(:get, url: "https://test.local", verify_ssl: false)
     end
 
-    context 'when successful' do
-      it 'returns a successful response given a status 200' do
-        stub_request(:head, 'http://test.local')
-          .to_return(status: [200, 'Whatevs'])
+    context "when successful" do
+      it "returns a successful response given a status 200" do
+        stub_request(:head, "http://test.local")
+          .to_return(status: [200, "Whatevs"])
 
-        response = head(url: 'http://test.local')
+        response = head(url: "http://test.local")
 
         expect(response.success_ok?).to be_truthy
       end
 
-      it 'returns a successful response given a status 204' do
-        stub_request(:head, 'http://test.local')
-          .to_return(status: [204, 'Whatevs'])
+      it "returns a successful response given a status 204" do
+        stub_request(:head, "http://test.local")
+          .to_return(status: [204, "Whatevs"])
 
-        response = head(url: 'http://test.local')
+        response = head(url: "http://test.local")
 
         expect(response.success_no_content?).to be_truthy
       end
     end
 
-    context 'when unsuccessful' do
+    context "when unsuccessful" do
       (400..418).each do |status|
         it 'raises an exception given a status #{status}' do
-          stub_request(:get, 'http://test.local')
-            .to_return(status: [status, 'Whatevs'],
-                       body: 'Error body')
+          stub_request(:get, "http://test.local")
+            .to_return(status: [status, "Whatevs"],
+                       body: "Error body")
 
-          expect { get(url: 'http://test.local') }.to raise_error do |error|
+          expect { get(url: "http://test.local") }.to raise_error do |error|
             expect(error).to be_a(StandardError)
             expect(error.http_code).to eq status
-            expect(error.response).to eq 'Error body'
+            expect(error.response).to eq "Error body"
           end
         end
       end
     end
 
-    context 'when redirected' do
+    context "when redirected" do
       [301, 302, 307].each do |status|
         [:get, :head].each do |method|
           it "follows #{status} redirected #{method.to_s.upcase} requests" do
-            stub_request(method, 'http://test.local')
-              .to_return(status: [status, 'redirect'],
-                         headers: { 'Location' => 'http://test.local/redirect' })
-            expecting_request(method, 'http://test.local/redirect') do
-              execute(method, url: 'http://test.local')
+            stub_request(method, "http://test.local")
+              .to_return(status: [status, "redirect"],
+                         headers: { "Location" => "http://test.local/redirect" })
+            expecting_request(method, "http://test.local/redirect") do
+              execute(method, url: "http://test.local")
             end
           end
         end
 
         it "does not follow #{status} redirected POST requests" do
-          stub_request(:post, 'http://test.local')
-            .to_return(status: [status, 'redirect'],
-                       headers: { 'Location' => 'http://test.local/redirect' })
+          stub_request(:post, "http://test.local")
+            .to_return(status: [status, "redirect"],
+                       headers: { "Location" => "http://test.local/redirect" })
 
-          expect { post(url: 'http://test.local') }.to raise_error do |error|
+          expect { post(url: "http://test.local") }.to raise_error do |error|
             expect(error).to be_a(StandardError)
             expect(error.http_code).to eq status
           end
@@ -142,12 +142,12 @@ describe Vra::Http do
 
       [:head, :post].each do |method|
         it "converts #{method.to_s.upcase} to GET on 303 redirect" do
-          stub_request(method, 'http://test.local')
-            .to_return(status: [303, 'See Other'],
-                       headers: { 'Location' => 'http://test.local/redirect' })
+          stub_request(method, "http://test.local")
+            .to_return(status: [303, "See Other"],
+                       headers: { "Location" => "http://test.local/redirect" })
 
-          expecting_request(:get, 'http://test.local/redirect') do
-            execute method, url: 'http://test.local'
+          expecting_request(:get, "http://test.local/redirect") do
+            execute method, url: "http://test.local"
           end
         end
       end

data/spec/request_spec.rb

@@ -17,15 +17,15 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+require "spec_helper"
 
-shared_examples 'refresh_trigger_method' do |method|
-  it 'calls #refresh_if_needed' do
+shared_examples "refresh_trigger_method" do |method|
+  it "calls #refresh_if_needed" do
     expect(request).to receive(:refresh_if_empty)
     request.send(method)
   end
 
-  it 'returns nil if request data is empty' do
+  it "returns nil if request data is empty" do
     allow(request).to receive(:refresh_if_empty)
     allow(request).to receive(:request_empty?).and_return true
     expect(request.send(method)).to eq nil
@@ -34,44 +34,44 @@ end
 
 describe Vra::Request 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(:request_id) { '2c3df007-b1c4-4687-b332-310089c4851d' }
+  let(:request_id) { "2c3df007-b1c4-4687-b332-310089c4851d" }
 
   let(:in_progress_payload) do
     {
-      'phase' => 'IN_PROGRESS',
-      'requestCompletion' => {
-        'requestCompletionState' => nil,
-        'completionDetails' => nil
-      }
+      "phase" => "IN_PROGRESS",
+      "requestCompletion" => {
+        "requestCompletionState" => nil,
+        "completionDetails" => nil,
+      },
     }
   end
 
   let(:completed_payload) do
     {
-      'phase' => 'SUCCESSFUL',
-      'requestCompletion' => {
-        'requestCompletionState' => 'SUCCESSFUL',
-        'completionDetails' => 'Request succeeded. Created test-machine.'
-      }
+      "phase" => "SUCCESSFUL",
+      "requestCompletion" => {
+        "requestCompletionState" => "SUCCESSFUL",
+        "completionDetails" => "Request succeeded. Created test-machine.",
+      },
     }
   end
 
   let(:request) { Vra::Request.new(client, request_id) }
 
-  describe '#initialize' do
-    it 'sets the id' do
+  describe "#initialize" do
+    it "sets the id" do
       expect(request.id).to eq request_id
     end
   end
 
-  describe '#refresh' do
-    it 'calls the request API endpoint' do
+  describe "#refresh" do
+    it "calls the request API endpoint" do
       expect(client).to receive(:get_parsed)
         .with("/catalog-service/api/consumer/requests/#{request_id}")
         .and_return(in_progress_payload)
@@ -80,45 +80,45 @@ describe Vra::Request do
     end
   end
 
-  describe '#refresh_if_empty' do
-    context 'request data is empty' do
-      it 'calls #refresh' do
+  describe "#refresh_if_empty" do
+    context "request data is empty" do
+      it "calls #refresh" do
         expect(request).to receive(:refresh)
         request.refresh_if_empty
       end
     end
 
-    context 'request data is not empty' do
-      it 'does not call #refresh' do
+    context "request data is not empty" do
+      it "does not call #refresh" do
         allow(request).to receive(:request_empty?).and_return(false)
         expect(request).to_not receive(:refresh)
       end
     end
   end
 
-  describe '#status' do
-    it_behaves_like 'refresh_trigger_method', :status
+  describe "#status" do
+    it_behaves_like "refresh_trigger_method", :status
   end
 
-  describe '#completed?' do
-    context 'when the request is neither successful or failed yet' do
-      it 'returns false' do
+  describe "#completed?" do
+    context "when the request is neither successful or failed yet" do
+      it "returns false" do
         allow(request).to receive(:successful?).and_return(false)
         allow(request).to receive(:failed?).and_return(false)
         expect(request.completed?).to eq false
       end
     end
 
-    context 'when the request is successful' do
-      it 'returns true' do
+    context "when the request is successful" do
+      it "returns true" do
         allow(request).to receive(:successful?).and_return(true)
         allow(request).to receive(:failed?).and_return(false)
         expect(request.completed?).to eq true
       end
     end
 
-    context 'when the request failed' do
-      it 'returns true' do
+    context "when the request failed" do
+      it "returns true" do
         allow(request).to receive(:successful?).and_return(false)
         allow(request).to receive(:failed?).and_return(true)
         expect(request.completed?).to eq true
@@ -126,16 +126,16 @@ describe Vra::Request do
     end
   end
 
-  describe '#completion_state' do
-    it_behaves_like 'refresh_trigger_method', :completion_state
+  describe "#completion_state" do
+    it_behaves_like "refresh_trigger_method", :completion_state
   end
 
-  describe '#completion_details' do
-    it_behaves_like 'refresh_trigger_method', :completion_details
+  describe "#completion_details" do
+    it_behaves_like "refresh_trigger_method", :completion_details
   end
 
-  describe '#resources' do
-    it 'calls the requests resources API endpoint' do
+  describe "#resources" do
+    it "calls the requests resources API endpoint" do
       expect(client).to receive(:http_get_paginated_array!)
         .with("/catalog-service/api/consumer/requests/#{request_id}/resources")
         .and_return([])

data/spec/requests_spec.rb

@@ -17,31 +17,31 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Vra::Requests 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(:requests) { Vra::Requests.new(client) }
 
-  describe '#all_resources' do
-    it 'calls the requests API endpoint' do
+  describe "#all_resources" do
+    it "calls the requests API endpoint" do
       expect(client).to receive(:http_get_paginated_array!)
-        .with('/catalog-service/api/consumer/requests')
+        .with("/catalog-service/api/consumer/requests")
         .and_return([])
 
       requests.all_requests
     end
 
-    it 'returns an array of request objects' do
+    it "returns an array of request objects" do
       allow(client).to receive(:http_get_paginated_array!)
-        .with('/catalog-service/api/consumer/requests')
-        .and_return([ { 'id' => '1' }, { 'id' => '2' } ])
+        .with("/catalog-service/api/consumer/requests")
+        .and_return([ { "id" => "1" }, { "id" => "2" } ])
 
       items = requests.all_requests
 
@@ -50,11 +50,11 @@ describe Vra::Requests do
     end
   end
 
-  describe '#by_id' do
-    it 'returns a request object' do
-      expect(Vra::Request).to receive(:new).with(client, '12345')
+  describe "#by_id" do
+    it "returns a request object" do
+      expect(Vra::Request).to receive(:new).with(client, "12345")
 
-      requests.by_id('12345')
+      requests.by_id("12345")
     end
   end
 end

data/spec/resource_spec.rb

@@ -17,20 +17,20 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'ffi_yajl'
-
-shared_examples_for 'a resource action' do |action_method, action_name|
-  context 'when the action is available' do
-    it 'calls gets the action ID and submits the request' do
-      expect(resource).to receive(:action_id_by_name).with(action_name).and_return('action-123')
-      expect(resource).to receive(:submit_action_request).with('action-123')
+require "spec_helper"
+require "ffi_yajl"
+
+shared_examples_for "a resource action" do |action_method, action_name|
+  context "when the action is available" do
+    it "calls gets the action ID and submits the request" do
+      expect(resource).to receive(:action_id_by_name).with(action_name).and_return("action-123")
+      expect(resource).to receive(:submit_action_request).with("action-123")
       resource.send(action_method)
     end
   end
 
-  context 'when the action is not available' do
-    it 'raises an exception' do
+  context "when the action is not available" do
+    it "raises an exception" do
       expect(resource).to receive(:action_id_by_name).with(action_name).and_return nil
       expect { resource.send(action_method) }.to raise_error(Vra::Exception::NotFound)
     end
@@ -39,61 +39,61 @@ end
 
 describe Vra::Resource 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(:resource_id) { '31a7badc-6562-458d-84f3-ec58d74a6953' }
+  let(:resource_id) { "31a7badc-6562-458d-84f3-ec58d74a6953" }
   let(:vm_payload) do
     FFI_Yajl::Parser.parse(File.read(File.join(File.dirname(__FILE__),
-                                               'fixtures',
-                                               'resource',
-                                               'vm_resource.json')))
+                                               "fixtures",
+                                               "resource",
+                                               "vm_resource.json")))
   end
 
   let(:vm_payload_no_ops) do
     FFI_Yajl::Parser.parse(File.read(File.join(File.dirname(__FILE__),
-                                               'fixtures',
-                                               'resource',
-                                               'vm_resource_no_operations.json')))
+                                               "fixtures",
+                                               "resource",
+                                               "vm_resource_no_operations.json")))
   end
 
   let(:non_vm_payload) do
     FFI_Yajl::Parser.parse(File.read(File.join(File.dirname(__FILE__),
-                                               'fixtures',
-                                               'resource',
-                                               'non_vm_resource.json')))
+                                               "fixtures",
+                                               "resource",
+                                               "non_vm_resource.json")))
   end
 
-  describe '#initialize' do
-    it 'raises an error if no ID or resource data have been provided' do
+  describe "#initialize" do
+    it "raises an error if no ID or resource data have been provided" do
       expect { Vra::Resource.new }.to raise_error(ArgumentError)
     end
 
-    it 'raises an error if an ID and resource data have both been provided' do
-      expect { Vra::Resource.new(id: 123, data: 'foo') }.to raise_error(ArgumentError)
+    it "raises an error if an ID and resource data have both been provided" do
+      expect { Vra::Resource.new(id: 123, data: "foo") }.to raise_error(ArgumentError)
     end
 
-    context 'when an ID is provided' do
-      it 'calls fetch_resource_data' do
+    context "when an ID is provided" do
+      it "calls fetch_resource_data" do
         resource = Vra::Resource.allocate
         expect(resource).to receive(:fetch_resource_data)
         resource.send(:initialize, client, id: resource_id)
       end
     end
 
-    context 'when resource data is provided' do
-      it 'populates the ID correctly' do
+    context "when resource data is provided" do
+      it "populates the ID correctly" do
         resource = Vra::Resource.new(client, data: vm_payload)
         expect(resource.id).to eq resource_id
       end
     end
   end
 
-  describe '#fetch_resource_data' do
-    it 'calls get_parsed against the resources API endpoint' do
+  describe "#fetch_resource_data" do
+    it "calls get_parsed against the resources API endpoint" do
       expect(client).to receive(:get_parsed)
         .with("/catalog-service/api/consumer/resources/#{resource_id}")
         .and_return({})
@@ -102,297 +102,297 @@ describe Vra::Resource do
     end
   end
 
-  context 'when a valid VM resource instance has been created' do
+  context "when a valid VM resource instance has been created" do
     let(:resource) { Vra::Resource.new(client, data: vm_payload) }
 
-    describe '#name' do
-      it 'returns the correct name' do
-        expect(resource.name).to eq 'hol-dev-11'
+    describe "#name" do
+      it "returns the correct name" do
+        expect(resource.name).to eq "hol-dev-11"
       end
     end
 
-    describe '#description' do
-      it 'returns the correct description' do
-        expect(resource.description).to eq 'test-description'
+    describe "#description" do
+      it "returns the correct description" do
+        expect(resource.description).to eq "test-description"
       end
     end
 
-    describe '#status' do
-      it 'returns the correct status' do
-        expect(resource.status).to eq 'ACTIVE'
+    describe "#status" do
+      it "returns the correct status" do
+        expect(resource.status).to eq "ACTIVE"
       end
     end
 
-    describe '#vm?' do
-      context 'when the resource type is Infrastructure.Virtual' do
-        let(:resource_data) { { 'resourceTypeRef' => { 'id' => 'Infrastructure.Virtual' } } }
-        it 'returns true' do
+    describe "#vm?" do
+      context "when the resource type is Infrastructure.Virtual" do
+        let(:resource_data) { { "resourceTypeRef" => { "id" => "Infrastructure.Virtual" } } }
+        it "returns true" do
           allow(resource).to receive(:resource_data).and_return(resource_data)
           expect(resource.vm?).to eq(true)
         end
       end
 
-      context 'when the resource type is Infrastructure.Cloud' do
-        let(:resource_data) { { 'resourceTypeRef' => { 'id' => 'Infrastructure.Cloud' } } }
-        it 'returns true' do
+      context "when the resource type is Infrastructure.Cloud" do
+        let(:resource_data) { { "resourceTypeRef" => { "id" => "Infrastructure.Cloud" } } }
+        it "returns true" do
           allow(resource).to receive(:resource_data).and_return(resource_data)
           expect(resource.vm?).to eq(true)
         end
       end
 
-      context 'when the resource type is an unknown type' do
-        let(:resource_data) { { 'resourceTypeRef' => { 'id' => 'Infrastructure.Unknown' } } }
-        it 'returns false' do
+      context "when the resource type is an unknown type" do
+        let(:resource_data) { { "resourceTypeRef" => { "id" => "Infrastructure.Unknown" } } }
+        it "returns false" do
           allow(resource).to receive(:resource_data).and_return(resource_data)
           expect(resource.vm?).to eq(false)
         end
       end
     end
 
-    describe '#tenant_id' do
-      it 'returns the correct tenant ID' do
-        expect(resource.tenant_id).to eq 'vsphere.local'
+    describe "#tenant_id" do
+      it "returns the correct tenant ID" do
+        expect(resource.tenant_id).to eq "vsphere.local"
       end
     end
 
-    describe '#tenant_name' do
-      it 'returns the correct tenant name' do
-        expect(resource.tenant_name).to eq 'vsphere.local'
+    describe "#tenant_name" do
+      it "returns the correct tenant name" do
+        expect(resource.tenant_name).to eq "vsphere.local"
       end
     end
 
-    describe '#subtenant_id' do
-      it 'returns the correct subtenant ID' do
-        expect(resource.subtenant_id).to eq '5327ddd3-1a4e-4663-9e9d-63db86ffc8af'
+    describe "#subtenant_id" do
+      it "returns the correct subtenant ID" do
+        expect(resource.subtenant_id).to eq "5327ddd3-1a4e-4663-9e9d-63db86ffc8af"
       end
     end
 
-    describe '#subtenant_name' do
-      it 'returns the correct subtenant name' do
-        expect(resource.subtenant_name).to eq 'Rainpole Developers'
+    describe "#subtenant_name" do
+      it "returns the correct subtenant name" do
+        expect(resource.subtenant_name).to eq "Rainpole Developers"
       end
     end
 
-    describe '#owner_ids' do
-      it 'returns the correct owner IDs' do
-        expect(resource.owner_ids).to eq %w(user1@corp.local user2@corp.local)
+    describe "#owner_ids" do
+      it "returns the correct owner IDs" do
+        expect(resource.owner_ids).to eq %w{user1@corp.local user2@corp.local}
       end
     end
 
-    describe '#owner_names' do
-      it 'returns the correct owner names' do
-        expect(resource.owner_names).to eq [ 'Joe User', 'Jane User' ]
+    describe "#owner_names" do
+      it "returns the correct owner names" do
+        expect(resource.owner_names).to eq [ "Joe User", "Jane User" ]
       end
     end
 
-    describe '#machine_status' do
-      context 'when no MachineStatus exists' do
-        let(:resource_data) { { 'resourceData' => { 'entries' => [] } } }
+    describe "#machine_status" do
+      context "when no MachineStatus exists" do
+        let(:resource_data) { { "resourceData" => { "entries" => [] } } }
 
-        it 'raises an exception' do
+        it "raises an exception" do
           allow(resource).to receive(:resource_data).and_return(resource_data)
           expect { resource.machine_status }.to raise_error(RuntimeError)
         end
       end
 
-      context 'when MachineStatus Exists' do
+      context "when MachineStatus Exists" do
         let(:resource_data) do
           {
-            'resourceData' => {
-              'entries' => [
+            "resourceData" => {
+              "entries" => [
                 {
-                  'key' => 'MachineStatus',
-                  'value' => { 'type' => 'string', 'value' => 'Off' }
-                }
-              ]
-            }
+                  "key" => "MachineStatus",
+                  "value" => { "type" => "string", "value" => "Off" },
+                },
+              ],
+            },
           }
         end
 
-        it 'returns the correct status value' do
+        it "returns the correct status value" do
           allow(resource).to receive(:resource_data).and_return(resource_data)
-          expect(resource.machine_status).to eq('Off')
+          expect(resource.machine_status).to eq("Off")
         end
       end
     end
 
-    describe '#machine_on?' do
-      it 'returns true if the machine_status is On' do
-        allow(resource).to receive(:machine_status).and_return('On')
+    describe "#machine_on?" do
+      it "returns true if the machine_status is On" do
+        allow(resource).to receive(:machine_status).and_return("On")
         expect(resource.machine_on?).to eq(true)
       end
 
-      it 'returns false if the machine_status is not On' do
-        allow(resource).to receive(:machine_status).and_return('Off')
+      it "returns false if the machine_status is not On" do
+        allow(resource).to receive(:machine_status).and_return("Off")
         expect(resource.machine_on?).to eq(false)
       end
     end
 
-    describe '#machine_off?' do
-      it 'returns true if the machine_status is Off' do
-        allow(resource).to receive(:machine_status).and_return('Off')
+    describe "#machine_off?" do
+      it "returns true if the machine_status is Off" do
+        allow(resource).to receive(:machine_status).and_return("Off")
         expect(resource.machine_off?).to eq(true)
       end
 
-      it 'returns false if the machine_status is not Off' do
-        allow(resource).to receive(:machine_status).and_return('On')
+      it "returns false if the machine_status is not Off" do
+        allow(resource).to receive(:machine_status).and_return("On")
         expect(resource.machine_off?).to eq(false)
       end
     end
 
-    describe '#machine_turning_on?' do
-      it 'returns true if the machine_status is TurningOn' do
-        allow(resource).to receive(:machine_status).and_return('TurningOn')
+    describe "#machine_turning_on?" do
+      it "returns true if the machine_status is TurningOn" do
+        allow(resource).to receive(:machine_status).and_return("TurningOn")
         expect(resource.machine_turning_on?).to eq(true)
       end
 
-      it 'returns true if the machine_status is MachineActivated' do
-        allow(resource).to receive(:machine_status).and_return('MachineActivated')
+      it "returns true if the machine_status is MachineActivated" do
+        allow(resource).to receive(:machine_status).and_return("MachineActivated")
         expect(resource.machine_turning_on?).to eq(true)
       end
 
-      it 'returns false if the machine_status is not TurningOn' do
-        allow(resource).to receive(:machine_status).and_return('On')
+      it "returns false if the machine_status is not TurningOn" do
+        allow(resource).to receive(:machine_status).and_return("On")
         expect(resource.machine_turning_on?).to eq(false)
       end
     end
 
-    describe '#machine_turning_off?' do
-      it 'returns true if the machine_status is TurningOff' do
-        allow(resource).to receive(:machine_status).and_return('TurningOff')
+    describe "#machine_turning_off?" do
+      it "returns true if the machine_status is TurningOff" do
+        allow(resource).to receive(:machine_status).and_return("TurningOff")
         expect(resource.machine_turning_off?).to eq(true)
       end
 
-      it 'returns true if the machine_status is ShuttingDown' do
-        allow(resource).to receive(:machine_status).and_return('ShuttingDown')
+      it "returns true if the machine_status is ShuttingDown" do
+        allow(resource).to receive(:machine_status).and_return("ShuttingDown")
         expect(resource.machine_turning_off?).to eq(true)
       end
 
-      it 'returns false if the machine_status is not TurningOff or ShuttingDown' do
-        allow(resource).to receive(:machine_status).and_return('Off')
+      it "returns false if the machine_status is not TurningOff or ShuttingDown" do
+        allow(resource).to receive(:machine_status).and_return("Off")
         expect(resource.machine_turning_off?).to eq(false)
       end
     end
 
-    describe '#machine_in_provisioned_state?' do
-      it 'returns true if the machine_status is MachineProvisioned' do
-        allow(resource).to receive(:machine_status).and_return('MachineProvisioned')
+    describe "#machine_in_provisioned_state?" do
+      it "returns true if the machine_status is MachineProvisioned" do
+        allow(resource).to receive(:machine_status).and_return("MachineProvisioned")
         expect(resource.machine_in_provisioned_state?).to eq(true)
       end
 
-      it 'returns false if the machine_status is not MachineProvisioned' do
-        allow(resource).to receive(:machine_status).and_return('On')
+      it "returns false if the machine_status is not MachineProvisioned" do
+        allow(resource).to receive(:machine_status).and_return("On")
         expect(resource.machine_in_provisioned_state?).to eq(false)
       end
     end
 
-    describe '#network_interfaces' do
-      it 'returns an array of 2 elements' do
+    describe "#network_interfaces" do
+      it "returns an array of 2 elements" do
         expect(resource.network_interfaces.size).to be 2
       end
 
-      it 'contains the correct data' do
+      it "contains the correct data" do
         nic1, nic2 = resource.network_interfaces
 
-        expect(nic1['NETWORK_NAME']).to eq 'VM Network'
-        expect(nic1['NETWORK_ADDRESS']).to eq '192.168.110.200'
-        expect(nic1['NETWORK_MAC_ADDRESS']).to eq '00:50:56:ae:95:3c'
+        expect(nic1["NETWORK_NAME"]).to eq "VM Network"
+        expect(nic1["NETWORK_ADDRESS"]).to eq "192.168.110.200"
+        expect(nic1["NETWORK_MAC_ADDRESS"]).to eq "00:50:56:ae:95:3c"
 
-        expect(nic2['NETWORK_NAME']).to eq 'Management Network'
-        expect(nic2['NETWORK_ADDRESS']).to eq '192.168.220.200'
-        expect(nic2['NETWORK_MAC_ADDRESS']).to eq '00:50:56:ae:95:3d'
+        expect(nic2["NETWORK_NAME"]).to eq "Management Network"
+        expect(nic2["NETWORK_ADDRESS"]).to eq "192.168.220.200"
+        expect(nic2["NETWORK_MAC_ADDRESS"]).to eq "00:50:56:ae:95:3d"
       end
     end
 
-    describe '#ip_addresses' do
-      it 'returns the correct IP addresses' do
-        skip 'broken and needs to be updated per changes -JJ 2017-04-14'
-        stub_request(:post, 'https://vra.corp.local/identity/api/tokens')
+    describe "#ip_addresses" do
+      it "returns the correct IP addresses" do
+        skip "broken and needs to be updated per changes -JJ 2017-04-14"
+        stub_request(:post, "https://vra.corp.local/identity/api/tokens")
           .with(body: '{"username":"user@corp.local","password":"password","tenant":"tenant"}',
-                headers: { 'Accept' => 'application/json', 'Content-Type' => 'application/json' })
-          .to_return(status: 200, body: '', headers: {})
-        expect(resource.ip_addresses).to eq [ '192.168.110.200', '192.168.220.200' ]
+                headers: { "Accept" => "application/json", "Content-Type" => "application/json" })
+          .to_return(status: 200, body: "", headers: {})
+        expect(resource.ip_addresses).to eq [ "192.168.110.200", "192.168.220.200" ]
       end
 
-      it 'returns nil if there are no network interfaces' do
+      it "returns nil if there are no network interfaces" do
         allow(resource).to receive(:network_interfaces).and_return nil
         expect(resource.ip_addresses).to be_nil
       end
     end
 
-    describe '#actions' do
-      it 'does not call #fetch_resource_data' do
+    describe "#actions" do
+      it "does not call #fetch_resource_data" do
         expect(resource).not_to receive(:fetch_resource_data)
         resource.actions
       end
     end
 
-    describe '#action_id_by_name' do
-      it 'returns the correct action ID for the destroy action' do
-        expect(resource.action_id_by_name('Destroy')).to eq 'ace8ba42-e724-48d8-9614-9b3a62b5a464'
+    describe "#action_id_by_name" do
+      it "returns the correct action ID for the destroy action" do
+        expect(resource.action_id_by_name("Destroy")).to eq "ace8ba42-e724-48d8-9614-9b3a62b5a464"
       end
 
-      it 'returns nil if there are no resource operations' do
+      it "returns nil if there are no resource operations" do
         allow(resource).to receive(:actions).and_return nil
-        expect(resource.action_id_by_name('Destroy')).to be_nil
+        expect(resource.action_id_by_name("Destroy")).to be_nil
       end
 
-      it 'returns nil if there are actions, but none with the right name' do
-        allow(resource).to receive(:actions).and_return([ { 'name' => 'some action' }, { 'name' => 'another action' } ])
-        expect(resource.action_id_by_name('Destroy')).to be_nil
+      it "returns nil if there are actions, but none with the right name" do
+        allow(resource).to receive(:actions).and_return([ { "name" => "some action" }, { "name" => "another action" } ])
+        expect(resource.action_id_by_name("Destroy")).to be_nil
       end
     end
 
-    describe '#destroy' do
-      it_behaves_like 'a resource action', :destroy, 'Destroy'
+    describe "#destroy" do
+      it_behaves_like "a resource action", :destroy, "Destroy"
     end
 
-    describe '#shutdown' do
-      it_behaves_like 'a resource action', :shutdown, 'Shutdown'
+    describe "#shutdown" do
+      it_behaves_like "a resource action", :shutdown, "Shutdown"
     end
 
-    describe '#poweroff' do
-      it_behaves_like 'a resource action', :poweroff, 'Power Off'
+    describe "#poweroff" do
+      it_behaves_like "a resource action", :poweroff, "Power Off"
     end
 
-    describe '#poweron' do
-      it_behaves_like 'a resource action', :poweron, 'Power On'
+    describe "#poweron" do
+      it_behaves_like "a resource action", :poweron, "Power On"
     end
 
-    describe '#submit_action_request' do
+    describe "#submit_action_request" do
       before do
         allow(resource).to receive(:action_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
-        expect(client).to receive(:http_post).with('/catalog-service/api/consumer/requests', '{}')
+      it "calls http_post" do
+        expect(client).to receive(:http_post).with("/catalog-service/api/consumer/requests", "{}")
 
-        resource.submit_action_request('action-123')
+        resource.submit_action_request("action-123")
       end
 
-      it 'returns a Vra::Request object' do
-        expect(resource.submit_action_request('action-123')).to be_an_instance_of(Vra::Request)
+      it "returns a Vra::Request object" do
+        expect(resource.submit_action_request("action-123")).to be_an_instance_of(Vra::Request)
       end
     end
   end
 
-  context 'when a valid VM resource instance with no operations is created' do
+  context "when a valid VM resource instance with no operations is created" do
     let(:resource) { Vra::Resource.new(client, data: vm_payload_no_ops) }
 
-    describe '#actions' do
-      it 'calls #fetch_resource_data' do
+    describe "#actions" do
+      it "calls #fetch_resource_data" do
         expect(resource).to receive(:fetch_resource_data)
         resource.actions
       end
     end
   end
 
-  context 'when a valid non-VM resource instance has been created' do
+  context "when a valid non-VM resource instance has been created" do
     let(:resource) { Vra::Resource.new(client, data: non_vm_payload) }
 
-    it 'returns nil for network_interfaces and ip_addresses' do
+    it "returns nil for network_interfaces and ip_addresses" do
       expect(resource.network_interfaces).to be_nil
       expect(resource.ip_addresses).to be_nil
     end