vmware-vra 3.1.0 → 3.1.3

data/spec/deployment_request_spec.rb

@@ -17,69 +17,69 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Vra::DeploymentRequest do
   let(:client) do
     Vra::Client.new(
-      username: 'user@corp.local',
-      password: 'password',
-      tenant: 'tenant',
-      base_url: 'https://vra.corp.local'
+      username: "user@corp.local",
+      password: "password",
+      tenant: "tenant",
+      base_url: "https://vra.corp.local"
     )
   end
 
-  let(:catalog_id) { 'cat-123456' }
+  let(:catalog_id) { "cat-123456" }
 
   let(:request_payload) do
     {
-      image_mapping: 'Centos Image',
-      name: 'test deployment',
-      flavor_mapping: 'Small',
-      version: '1',
-      project_id: 'pro-123'
+      image_mapping: "Centos Image",
+      name: "test deployment",
+      flavor_mapping: "Small",
+      version: "1",
+      project_id: "pro-123",
     }
   end
 
-  describe '#initialize' do
-    it 'should raise errors for missing arguments' do
+  describe "#initialize" do
+    it "should raise errors for missing arguments" do
       request = described_class.new(
         client,
         catalog_id,
         request_payload
       )
 
-      expect(request.name).to eq('test deployment')
-      expect(request.image_mapping).to eq('Centos Image')
-      expect(request.flavor_mapping).to eq('Small')
-      expect(request.version).to eq('1')
+      expect(request.name).to eq("test deployment")
+      expect(request.image_mapping).to eq("Centos Image")
+      expect(request.flavor_mapping).to eq("Small")
+      expect(request.version).to eq("1")
       expect(request.count).to eq(1)
     end
   end
 
-  describe '#validate!' do
-    it 'should return error if params are missing' do
+  describe "#validate!" do
+    it "should return error if params are missing" do
       request = described_class.new(client, catalog_id)
       expect { request.send(:validate!) }.to raise_error(ArgumentError)
 
-      request.image_mapping  = 'Centos Image'
-      request.name           = 'test deployment'
-      request.flavor_mapping = 'Small'
-      request.version        = '1'
-      request.project_id     = 'pro-123'
+      request.image_mapping  = "Centos Image"
+      request.name           = "test deployment"
+      request.flavor_mapping = "Small"
+      request.version        = "1"
+      request.project_id     = "pro-123"
 
       expect { request.send(:validate!) }.not_to raise_error(ArgumentError)
     end
 
-    context 'versions' do
+    context "versions" do
       let(:dep_request) do
         described_class.new(
           client,
           catalog_id,
-          image_mapping: 'centos',
-          name: 'sample dep',
-          flavor_mapping: 'small',
-          project_id: 'pro-123'
+          image_mapping: "centos",
+          name: "sample dep",
+          flavor_mapping: "small",
+          project_id: "pro-123"
         )
       end
 
@@ -87,83 +87,83 @@ describe Vra::DeploymentRequest do
         allow(client).to receive(:authorized?).and_return(true)
       end
 
-      it 'should not call the api to fetch versions if provided in the params' do
+      it "should not call the api to fetch versions if provided in the params" do
         expect(client).not_to receive(:http_get_paginated_array!)
 
-        dep_request.version = '1'
+        dep_request.version = "1"
         dep_request.send(:validate!)
       end
 
-      it 'should fetch version from api if version is blank' do
-        expect(client).to receive(:http_get_paginated_array!).and_return([{ 'id' => '2', 'description' => 'v2.0' }])
+      it "should fetch version from api if version is blank" do
+        expect(client).to receive(:http_get_paginated_array!).and_return([{ "id" => "2", "description" => "v2.0" }])
 
         dep_request.send(:validate!)
-        expect(dep_request.version).to eq('2')
+        expect(dep_request.version).to eq("2")
       end
 
-      it 'should raise an exception if no valid versions found' do
+      it "should raise an exception if no valid versions found" do
         expect(client).to receive(:http_get_paginated_array!).and_return([])
 
         expect { dep_request.send(:validate!) }
           .to raise_error(ArgumentError)
-          .with_message('Unable to fetch a valid catalog version')
+          .with_message("Unable to fetch a valid catalog version")
       end
     end
   end
 
-  describe '#additional parameters' do
+  describe "#additional parameters" do
     let(:request) do
       described_class.new(client, catalog_id, request_payload)
     end
 
-    context 'set_parameter' do
-      it 'should set the parameter' do
-        request.set_parameter('hardware-config', 'stirng', 'Small')
+    context "set_parameter" do
+      it "should set the parameter" do
+        request.set_parameter("hardware-config", "stirng", "Small")
 
-        expect(request.parameters).to eq({ inputs: { 'hardware-config' => 'Small' } })
+        expect(request.parameters).to eq({ inputs: { "hardware-config" => "Small" } })
         expect(request.parameters[:inputs].count).to be(1)
       end
     end
 
-    context 'set_parameters' do
-      it 'should be able to set multiple parameters' do
-        request.set_parameters('test-parent', { 'param1' => { type: 'string', value: 1234 } })
+    context "set_parameters" do
+      it "should be able to set multiple parameters" do
+        request.set_parameters("test-parent", { "param1" => { type: "string", value: 1234 } })
 
         expect(request.parameters)
-          .to eq({ inputs: { 'test-parent' => { 'inputs' => { 'param1' => 1234 } } } })
+          .to eq({ inputs: { "test-parent" => { "inputs" => { "param1" => 1234 } } } })
       end
 
-      it 'should set multiple parameters with different data types' do
-        request.set_parameters('param1', { key1: { type: 'string', value: 'data' } })
-        request.set_parameters('param2', { key2: { type: 'boolean', value: false } })
-        request.set_parameters('param3', { key3: { type: 'integer', value: 100 } })
+      it "should set multiple parameters with different data types" do
+        request.set_parameters("param1", { key1: { type: "string", value: "data" } })
+        request.set_parameters("param2", { key2: { type: "boolean", value: false } })
+        request.set_parameters("param3", { key3: { type: "integer", value: 100 } })
 
         expect(request.parameters[:inputs].count).to be 3
       end
     end
 
-    context 'delete_parameter' do
+    context "delete_parameter" do
       before(:each) do
-        request.set_parameter('hardware-config', 'string', 'small')
+        request.set_parameter("hardware-config", "string", "small")
       end
 
-      it 'should delete the existing parameter' do
+      it "should delete the existing parameter" do
         expect(request.parameters[:inputs].count).to be(1)
-        request.delete_parameter('hardware-config')
+        request.delete_parameter("hardware-config")
         expect(request.parameters[:inputs].count).to be(0)
       end
     end
 
-    context '#hash_parameters' do
-      it 'should have the correct representation' do
-        request.set_parameters(:param1, { key1: { type: 'string', value: 'data' } })
+    context "#hash_parameters" do
+      it "should have the correct representation" do
+        request.set_parameters(:param1, { key1: { type: "string", value: "data" } })
 
-        expect(request.hash_parameters).to eq({ param1: { :key1 => 'data' } })
+        expect(request.hash_parameters).to eq({ param1: { key1: "data" } })
       end
     end
   end
 
-  describe '#submit' do
+  describe "#submit" do
     let(:request) do
       described_class.new(client, catalog_id, request_payload)
     end
@@ -172,30 +172,30 @@ describe Vra::DeploymentRequest do
       allow(client).to receive(:authorized?).and_return(true)
     end
 
-    it 'should call the validate before submit' do
+    it "should call the validate before submit" do
       expect(request).to receive(:validate!)
-      stub_request(:post, client.full_url('/catalog/api/items/cat-123456/request'))
+      stub_request(:post, client.full_url("/catalog/api/items/cat-123456/request"))
         .to_return(status: 200, body: '[{"deploymentId": "123"}]', headers: {})
       allow(Vra::Deployment).to receive(:new)
 
       request.submit
     end
 
-    it 'should call the api to submit the deployment request' do
-      response = double('response', body: '[{"deploymentId": "123"}]', success?: true)
+    it "should call the api to submit the deployment request" do
+      response = double("response", body: '[{"deploymentId": "123"}]', success?: true)
       allow(client)
         .to receive(:http_post)
         .with(
           "/catalog/api/items/#{catalog_id}/request",
           {
-            deploymentName: 'test deployment',
-            projectId: 'pro-123',
-            version: '1',
+            deploymentName: "test deployment",
+            projectId: "pro-123",
+            version: "1",
             inputs: {
               count: 1,
-              image: 'Centos Image',
-              flavor: 'Small'
-            }
+              image: "Centos Image",
+              flavor: "Small",
+            },
           }.to_json
         )
         .and_return(response)
@@ -204,25 +204,25 @@ describe Vra::DeploymentRequest do
       request.submit
     end
 
-    it 'should return a deployment object' do
-      response = double('response', body: '[{"deploymentId": "123"}]', success?: true)
+    it "should return a deployment object" do
+      response = double("response", body: '[{"deploymentId": "123"}]', success?: true)
       allow(client).to receive(:http_post).and_return(response)
       allow(client)
         .to receive(:get_parsed)
-        .and_return(JSON.parse(File.read('spec/fixtures/resource/sample_deployment.json')))
+        .and_return(JSON.parse(File.read("spec/fixtures/resource/sample_deployment.json")))
 
       dep = request.submit
       expect(dep).to be_an_instance_of(Vra::Deployment)
-      expect(dep.id).to eq('123')
+      expect(dep.id).to eq("123")
     end
 
-    it 'should handle the VRA Errors' do
+    it "should handle the VRA Errors" do
       allow(request).to receive(:send_request!).and_raise(Vra::Exception::HTTPError)
 
       expect { request.submit }.to raise_error(Vra::Exception::RequestError)
     end
 
-    it 'should handle the generic errors' do
+    it "should handle the generic errors" do
       allow(request).to receive(:send_request!).and_raise(ArgumentError)
 
       expect { request.submit }.to raise_error(ArgumentError)

data/spec/deployment_spec.rb

@@ -17,20 +17,20 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+require "spec_helper"
 
 describe ::Vra::Deployment do
   let(:client) do
     Vra::Client.new(
-      username: 'user@corp.local',
-      password: 'password',
-      tenant: 'tenant',
-      base_url: 'https://vra.corp.local'
+      username: "user@corp.local",
+      password: "password",
+      tenant: "tenant",
+      base_url: "https://vra.corp.local"
     )
   end
 
   let(:sample_data) do
-    JSON.parse(File.read('spec/fixtures/resource/sample_deployment.json'))
+    JSON.parse(File.read("spec/fixtures/resource/sample_deployment.json"))
   end
 
   let(:deployment) do
@@ -41,7 +41,7 @@ describe ::Vra::Deployment do
     allow(client).to receive(:authorized?).and_return(true)
   end
 
-  describe '#initialize' do
+  describe "#initialize" do
     let(:deployment) do
       described_class.allocate
     end
@@ -50,171 +50,171 @@ describe ::Vra::Deployment do
       allow(client).to receive(:get_parsed).and_return(sample_data)
     end
 
-    it 'should validate the attributes' do
+    it "should validate the attributes" do
       expect(deployment).to receive(:validate!)
 
-      deployment.send(:initialize, client, id: 'dep-123')
+      deployment.send(:initialize, client, id: "dep-123")
     end
 
-    it 'should fetch data when id is passed' do
-      deployment.send(:initialize, client, id: 'dep-123')
+    it "should fetch data when id is passed" do
+      deployment.send(:initialize, client, id: "dep-123")
 
       expect(deployment.send(:data)).not_to be_nil
     end
 
-    it 'should set id when data is passed' do
+    it "should set id when data is passed" do
       deployment.send(:initialize, client, data: sample_data)
 
-      expect(deployment.id).to eq('dep-123')
+      expect(deployment.id).to eq("dep-123")
     end
   end
 
-  describe '#refresh' do
-    it 'should refresh the data correctly' do
+  describe "#refresh" do
+    it "should refresh the data correctly" do
       expect(client).to receive(:get_parsed).and_return(sample_data)
 
       deployment.refresh
     end
 
-    it 'should raise an exception if record not found' do
+    it "should raise an exception if record not found" do
       expect(client).to receive(:get_parsed).and_raise(Vra::Exception::HTTPNotFound)
 
       expect { deployment.refresh }.to raise_error(Vra::Exception::NotFound)
     end
   end
 
-  describe '#attributes' do
-    it 'should have the correct attributes' do
-      expect(deployment.name).to eq('win-DCI')
-      expect(deployment.description).to eq('win-dci deployment')
-      expect(deployment.org_id).to eq('origin-123')
-      expect(deployment.blueprint_id).to eq('blueprint-123')
-      expect(deployment.owner).to eq('administrator')
-      expect(deployment.status).to eq('CREATE_SUCCESSFUL')
+  describe "#attributes" do
+    it "should have the correct attributes" do
+      expect(deployment.name).to eq("win-DCI")
+      expect(deployment.description).to eq("win-dci deployment")
+      expect(deployment.org_id).to eq("origin-123")
+      expect(deployment.blueprint_id).to eq("blueprint-123")
+      expect(deployment.owner).to eq("administrator")
+      expect(deployment.status).to eq("CREATE_SUCCESSFUL")
       expect(deployment.successful?).to be_truthy
       expect(deployment.completed?).to be_truthy
       expect(deployment.failed?).to be_falsey
     end
   end
 
-  describe '#requests' do
+  describe "#requests" do
     let(:request_data) do
-      JSON.parse(File.read('spec/fixtures/resource/sample_dep_request.json'))
+      JSON.parse(File.read("spec/fixtures/resource/sample_dep_request.json"))
     end
 
-    it 'should call the api to fetch the requests' do
+    it "should call the api to fetch the requests" do
       expect(client)
         .to receive(:get_parsed)
-        .with('/deployment/api/deployments/dep-123/requests')
-        .and_return({ 'content' => [request_data] })
+        .with("/deployment/api/deployments/dep-123/requests")
+        .and_return({ "content" => [request_data] })
 
       deployment.requests
     end
 
-    it 'should return the Vra::Request object' do
-      stub_request(:get, client.full_url('/deployment/api/deployments/dep-123/requests'))
-        .to_return(status: 200, body: { 'content' => [request_data] }.to_json, headers: {})
+    it "should return the Vra::Request object" do
+      stub_request(:get, client.full_url("/deployment/api/deployments/dep-123/requests"))
+        .to_return(status: 200, body: { "content" => [request_data] }.to_json, headers: {})
 
       res = deployment.requests.first
       expect(res).to be_an_instance_of(Vra::Request)
     end
 
-    it 'should return the correct request data' do
+    it "should return the correct request data" do
       allow(client)
         .to receive(:get_parsed)
-        .with('/deployment/api/deployments/dep-123/requests')
-        .and_return({ 'content' => [request_data] })
+        .with("/deployment/api/deployments/dep-123/requests")
+        .and_return({ "content" => [request_data] })
 
       res = deployment.requests.first
-      expect(res.status).to eq('SUCCESSFUL')
-      expect(res.name).to eq('Create')
-      expect(res.requested_by).to eq('admin')
+      expect(res.status).to eq("SUCCESSFUL")
+      expect(res.name).to eq("Create")
+      expect(res.requested_by).to eq("admin")
     end
   end
 
-  describe '#resources' do
+  describe "#resources" do
     let(:resource_data) do
-      JSON.parse(File.read('spec/fixtures/resource/sample_dep_resource.json'))
+      JSON.parse(File.read("spec/fixtures/resource/sample_dep_resource.json"))
     end
 
-    it 'should call the api to fetch the resources' do
+    it "should call the api to fetch the resources" do
       expect(client)
         .to receive(:get_parsed)
-        .with('/deployment/api/deployments/dep-123/resources')
-        .and_return({ 'content' => [resource_data] })
+        .with("/deployment/api/deployments/dep-123/resources")
+        .and_return({ "content" => [resource_data] })
 
       res = deployment.resources.first
       expect(res).to be_an_instance_of(Vra::Resource)
     end
 
-    it 'should have the correct resource data' do
-      expect(client).to receive(:get_parsed).and_return({ 'content' => [resource_data] })
+    it "should have the correct resource data" do
+      expect(client).to receive(:get_parsed).and_return({ "content" => [resource_data] })
 
       res = deployment.resources.first
-      expect(res.name).to eq('Cloud_vSphere_Machine_1')
-      expect(res.status).to eq('SUCCESS')
+      expect(res.name).to eq("Cloud_vSphere_Machine_1")
+      expect(res.status).to eq("SUCCESS")
       expect(res.vm?).to be_truthy
-      expect(res.owner_names).to eq('admin')
+      expect(res.owner_names).to eq("admin")
     end
   end
 
-  describe '#actions' do
+  describe "#actions" do
     let(:actions_data) do
-      JSON.parse(File.read('spec/fixtures/resource/sample_dep_actions.json'))
+      JSON.parse(File.read("spec/fixtures/resource/sample_dep_actions.json"))
     end
 
     def action_req(action)
       {
         actionId: "Deployment.#{camelize(action)}",
         inputs: {},
-        reason: "Testing the #{action}"
+        reason: "Testing the #{action}",
       }.to_json
     end
 
     def action_response(action)
       {
-        'id' => 'req-123',
-        'name' => camelize(action),
-        'requestedBy' => 'admin',
-        'blueprintId' => 'blueprint-123',
-        'inputs' => {
-          'flag' => 'false',
-          'count' => '1',
-          'hardware-config' => 'Medium'
+        "id" => "req-123",
+        "name" => camelize(action),
+        "requestedBy" => "admin",
+        "blueprintId" => "blueprint-123",
+        "inputs" => {
+          "flag" => "false",
+          "count" => "1",
+          "hardware-config" => "Medium",
         },
-        'status' => 'SUCCESSFUL'
+        "status" => "SUCCESSFUL",
       }.to_json
     end
 
     def camelize(action_name)
-      action_name.split('_').map(&:capitalize).join
+      action_name.split("_").map(&:capitalize).join
     end
 
-    it 'should call the api to fetch the actions' do
+    it "should call the api to fetch the actions" do
       expect(client)
         .to receive(:get_parsed)
-        .with('/deployment/api/deployments/dep-123/actions')
+        .with("/deployment/api/deployments/dep-123/actions")
         .and_return(actions_data)
 
       actions = deployment.actions
       expect(actions).to be_an_instance_of(Array)
     end
 
-    it 'should return the correct actions' do
+    it "should return the correct actions" do
       allow(client).to receive(:get_parsed).and_return(actions_data)
 
-      action_names = deployment.actions.map { |a| a['name'] }
-      expect(action_names).to eq(%w[ChangeLease ChangeOwner Delete EditTags PowerOff PowerOn Update])
+      action_names = deployment.actions.map { |a| a["name"] }
+      expect(action_names).to eq(%w{ChangeLease ChangeOwner Delete EditTags PowerOff PowerOn Update})
     end
 
     {
-      destroy: 'delete',
-      power_on: 'power_on',
-      power_off: 'power_off'
+      destroy: "delete",
+      power_on: "power_on",
+      power_off: "power_off",
     }.each do |method, action|
       it "should perform the action: #{action} correctly" do
         allow(client).to receive(:get_parsed).and_return(actions_data)
-        stub_request(:post, client.full_url('/deployment/api/deployments/dep-123/requests'))
+        stub_request(:post, client.full_url("/deployment/api/deployments/dep-123/requests"))
           .with(body: action_req(action))
           .to_return(status: 200, body: action_response(action), headers: {})
 

data/spec/deployments_spec.rb

@@ -17,54 +17,54 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+require "spec_helper"
 
 describe ::Vra::Deployments do
   let(:client) do
     Vra::Client.new(
-      username: 'user@corp.local',
-      password: 'password',
-      tenant: 'tenant',
-      base_url: 'https://vra.corp.local'
+      username: "user@corp.local",
+      password: "password",
+      tenant: "tenant",
+      base_url: "https://vra.corp.local"
     )
   end
 
   let(:deployment_response) do
-    JSON.parse(File.read('spec/fixtures/resource/sample_deployment.json'))
+    JSON.parse(File.read("spec/fixtures/resource/sample_deployment.json"))
   end
 
   before(:each) do
     allow(client).to receive(:authorized?).and_return(true)
   end
 
-  describe '#by_id' do
-    it 'should call the api to fetch the deployments' do
+  describe "#by_id" do
+    it "should call the api to fetch the deployments" do
       expect(client).to receive(:get_parsed).and_return(deployment_response)
 
-      described_class.by_id(client, 'dep-123')
+      described_class.by_id(client, "dep-123")
     end
 
-    it 'should return the deployment by id' do
-      stub_request(:get, client.full_url('/deployment/api/deployments/dep-123'))
+    it "should return the deployment by id" do
+      stub_request(:get, client.full_url("/deployment/api/deployments/dep-123"))
         .to_return(status: 200, body: deployment_response.to_json, headers: {})
 
-      deployment = described_class.by_id(client, 'dep-123')
+      deployment = described_class.by_id(client, "dep-123")
       expect(deployment).to be_an_instance_of(Vra::Deployment)
     end
   end
 
-  describe '#all' do
-    it 'should call the api to fetch all deployments' do
+  describe "#all" do
+    it "should call the api to fetch all deployments" do
       expect(client)
         .to receive(:http_get_paginated_array!)
-        .with('/deployment/api/deployments')
+        .with("/deployment/api/deployments")
         .and_return([deployment_response])
 
       described_class.all(client)
     end
 
-    it 'should return the Vra::Deployment object' do
-      stub_request(:get, client.full_url('/deployment/api/deployments?$skip=0&$top=20'))
+    it "should return the Vra::Deployment object" do
+      stub_request(:get, client.full_url("/deployment/api/deployments?$skip=0&$top=20"))
         .to_return(status: 200, body: { content: [deployment_response], totalPages: 1 }.to_json, headers: {})
 
       deployment = described_class.all(client).first
@@ -72,8 +72,8 @@ describe ::Vra::Deployments do
     end
   end
 
-  describe 'called with client' do
-    it 'should return the class object' do
+  describe "called with client" do
+    it "should return the class object" do
       expect(client.deployments).to be_an_instance_of described_class
     end
   end