vmware-vra 3.1.2 → 3.1.3

data/spec/catalog_source_spec.rb

@@ -16,23 +16,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-require 'spec_helper'
+require "spec_helper"
 
 describe Vra::CatalogSource 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_catalog_source.json'))
+    JSON.parse(File.read("spec/fixtures/resource/sample_catalog_source.json"))
   end
 
-  describe '#initialize' do
+  describe "#initialize" do
     let(:source) do
       described_class.allocate
     end
@@ -41,89 +41,89 @@ describe Vra::CatalogSource do
       allow(client).to receive(:get_parsed).and_return(sample_data)
     end
 
-    it 'should validate and fetch data' do
+    it "should validate and fetch data" do
       expect(source).to receive(:validate!)
       expect(source).to receive(:fetch_data)
 
-      source.send(:initialize, client, id: '123456')
+      source.send(:initialize, client, id: "123456")
     end
 
-    it 'should fetch data when id is passed' do
-      source.send(:initialize, client, id: '123456')
+    it "should fetch data when id is passed" do
+      source.send(:initialize, client, id: "123456")
 
       expect(source.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
       source.send(:initialize, client, data: sample_data)
 
-      expect(source.id).to eq('123456')
+      expect(source.id).to eq("123456")
     end
   end
 
-  describe '#validate' do
+  describe "#validate" do
     let(:source) do
       described_class.allocate
     end
 
-    it 'should raise exception when neither id nor data passed' do
+    it "should raise exception when neither id nor data passed" do
       expect { source.send(:initialize, client) }.to raise_error(ArgumentError)
     end
 
-    it 'should raise exception when both id and data is passed' do
-      params = [client, { id: 'com.vmw.vra.workflow', data: sample_data }]
+    it "should raise exception when both id and data is passed" do
+      params = [client, { id: "com.vmw.vra.workflow", data: sample_data }]
       expect { source.send(:initialize, *params) }.to raise_error(ArgumentError)
     end
   end
 
-  describe '#fetch_data' do
+  describe "#fetch_data" do
     let(:source) do
       described_class.allocate
     end
 
-    it 'should fetch the data correctly' do
+    it "should fetch the data correctly" do
       allow(client).to receive(:get_parsed).and_return(sample_data)
-      source.send(:initialize, client, id: '123456')
+      source.send(:initialize, client, id: "123456")
 
       data = source.send(:data)
       expect(data).to be(sample_data)
-      expect(source.id).to eq(data['id'])
-      expect(data['name']).to eq('Devops')
+      expect(source.id).to eq(data["id"])
+      expect(data["name"]).to eq("Devops")
     end
 
-    it 'should raise when catalog with id not found' do
+    it "should raise when catalog with id not found" do
       allow(client).to receive(:get_parsed).and_raise(Vra::Exception::HTTPNotFound)
 
-      expect { source.send(:initialize, client, id: sample_data['id']) }
+      expect { source.send(:initialize, client, id: sample_data["id"]) }
         .to raise_error(Vra::Exception::NotFound)
-        .with_message("catalog source ID #{sample_data['id']} does not exist")
+        .with_message("catalog source ID #{sample_data["id"]} does not exist")
     end
   end
 
-  describe 'attributes' do
+  describe "attributes" do
     let(:sample_type_data) do
-      JSON.parse(File.read('spec/fixtures/resource/sample_catalog_type.json'))
+      JSON.parse(File.read("spec/fixtures/resource/sample_catalog_type.json"))
     end
 
-    it 'should have the correct attributes' do
+    it "should have the correct attributes" do
       allow(client).to receive(:get_parsed).twice.and_return(sample_data, sample_type_data)
 
-      source = described_class.new(client, id: sample_data['id'])
-      expect(source.name).to eq('Devops')
-      expect(source.catalog_type_id).to eq('com.vmw.blueprint')
+      source = described_class.new(client, id: sample_data["id"])
+      expect(source.name).to eq("Devops")
+      expect(source.catalog_type_id).to eq("com.vmw.blueprint")
       expect(source.catalog_type).to be_a(Vra::CatalogType)
-      expect(source.config).to eq({ 'sourceProjectId' => 'pro-123456'})
+      expect(source.config).to eq({ "sourceProjectId" => "pro-123456" })
       expect(source.global?).to be_falsey
-      expect(source.project_id).to eq('pro-123456')
+      expect(source.project_id).to eq("pro-123456")
     end
   end
 
-  describe '#create' do
+  describe "#create" do
     let(:create_params) do
       {
-        name: 'Devops',
-        catalog_type_id: 'com.vmw.blueprint',
-        project_id: 'pro-123456'
+        name: "Devops",
+        catalog_type_id: "com.vmw.blueprint",
+        project_id: "pro-123456",
       }
     end
 
@@ -131,17 +131,17 @@ describe Vra::CatalogSource do
       allow(client).to receive(:authorized?).and_return(true)
     end
 
-    it 'should call the create api' do
-      response = double('response', code: 200, body: sample_data.to_json, success?: true)
+    it "should call the create api" do
+      response = double("response", code: 200, body: sample_data.to_json, success?: true)
       expect(Vra::Http).to receive(:execute)
         .with(method: :post,
-              url: client.full_url('/catalog/api/admin/sources'),
+              url: client.full_url("/catalog/api/admin/sources"),
               payload: {
-                name: 'Devops',
-                typeId: 'com.vmw.blueprint',
+                name: "Devops",
+                typeId: "com.vmw.blueprint",
                 config: {
-                  sourceProjectId: 'pro-123456'
-                }
+                  sourceProjectId: "pro-123456",
+                },
               }.to_json,
               headers: anything,
               verify_ssl: true)
@@ -150,28 +150,28 @@ describe Vra::CatalogSource do
       described_class.create(client, create_params)
     end
 
-    it 'should create a new source' do
-      response = double('response', code: 200, body: sample_data.to_json, success?: true)
+    it "should create a new source" do
+      response = double("response", code: 200, body: sample_data.to_json, success?: true)
       allow(Vra::Http).to receive(:execute).and_return(response)
 
       new_source = described_class.create(client, create_params)
 
       expect(new_source).to be_a(described_class)
-      expect(new_source.name).to eq('Devops')
-      expect(new_source.project_id).to eq('pro-123456')
+      expect(new_source.name).to eq("Devops")
+      expect(new_source.project_id).to eq("pro-123456")
     end
   end
 
-  describe '#entitle!' do
-    it 'should entitle the source' do
+  describe "#entitle!" do
+    it "should entitle the source" do
       allow(client).to receive(:authorized?).and_return(true)
-      stub_request(:get, client.full_url('/catalog/api/admin/sources/123456'))
+      stub_request(:get, client.full_url("/catalog/api/admin/sources/123456"))
         .to_return(status: 200, body: sample_data.to_json, headers: {})
 
-      response = double('response', body: '{"message": "success"}', success?: true)
+      response = double("response", body: '{"message": "success"}', success?: true)
       allow(client).to receive(:http_post).and_return(response)
 
-      entitle_response = described_class.entitle!(client, '123456')
+      entitle_response = described_class.entitle!(client, "123456")
       expect(entitle_response).not_to be_nil
     end
   end

data/spec/catalog_spec.rb

@@ -17,42 +17,42 @@
 # 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'
+      username: "user@corp.local",
+      password: "password",
+      tenant: "tenant",
+      base_url: "https://vra.corp.local"
     )
   end
 
   let(:catalog_item) do
-    JSON.parse(File.read('spec/fixtures/resource/sample_catalog_item.json'))
+    JSON.parse(File.read("spec/fixtures/resource/sample_catalog_item.json"))
   end
 
   let(:entitled_catalog_item) do
-    JSON.parse(File.read('spec/fixtures/resource/sample_catalog_item_2.json'))
+    JSON.parse(File.read("spec/fixtures/resource/sample_catalog_item_2.json"))
   end
 
   before(:each) do
     allow(client).to receive(:authorized?).and_return(true)
   end
 
-  describe '#all_items' do
-    it 'calls the catalogItems endpoint' do
+  describe "#all_items" do
+    it "calls the catalogItems endpoint" do
       expect(client).to receive(:http_get_paginated_array!)
-        .with('/catalog/api/admin/items', nil)
+        .with("/catalog/api/items", nil)
         .and_return([catalog_item])
 
       client.catalog.all_items
     end
 
-    it 'returns a Vra::CatalogItem object' do
+    it "returns a Vra::CatalogItem object" do
       allow(client).to receive(:http_get_paginated_array!)
-        .with('/catalog/api/admin/items', nil)
+        .with("/catalog/api/items", nil)
         .and_return([catalog_item])
 
       items = client.catalog.all_items
@@ -61,60 +61,60 @@ describe Vra::Catalog do
     end
   end
 
-  describe '#entitled_items' do
-    it 'calls the entitledCatalogItems endpoint' do
+  describe "#entitled_items" do
+    it "calls the entitledCatalogItems endpoint" do
       expect(client).to receive(:get_parsed)
-        .with('/catalog/api/admin/entitlements?projectId=pro-123456')
-        .and_return(JSON.parse(File.read('spec/fixtures/resource/sample_entitlements.json')))
+        .with("/catalog/api/admin/entitlements?projectId=pro-123456")
+        .and_return(JSON.parse(File.read("spec/fixtures/resource/sample_entitlements.json")))
 
-      client.catalog.entitled_items('pro-123456')
+      client.catalog.entitled_items("pro-123456")
     end
 
-    it 'returns a Vra::CatalogItem object' do
+    it "returns a Vra::CatalogItem object" do
       allow(client).to receive(:get_parsed)
-        .with('/catalog/api/admin/entitlements?projectId=pro-123456')
-        .and_return(JSON.parse(File.read('spec/fixtures/resource/sample_entitlements.json')))
+        .with("/catalog/api/admin/entitlements?projectId=pro-123456")
+        .and_return(JSON.parse(File.read("spec/fixtures/resource/sample_entitlements.json")))
 
-      items = client.catalog.entitled_items('pro-123456')
+      items = client.catalog.entitled_items("pro-123456")
 
       expect(items.first).to be_an_instance_of(Vra::CatalogItem)
     end
 
-    it 'return a Vra::CatalogSource object on source entitlements' do
+    it "return a Vra::CatalogSource object on source entitlements" do
       allow(client).to receive(:get_parsed)
-        .with('/catalog/api/admin/entitlements?projectId=pro-123456')
-        .and_return(JSON.parse(File.read('spec/fixtures/resource/sample_entitlements.json')))
+        .with("/catalog/api/admin/entitlements?projectId=pro-123456")
+        .and_return(JSON.parse(File.read("spec/fixtures/resource/sample_entitlements.json")))
 
-      items = client.catalog.entitled_sources('pro-123456')
+      items = client.catalog.entitled_sources("pro-123456")
 
       expect(items.first).to be_an_instance_of(Vra::CatalogSource)
     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::DeploymentRequest)
     end
   end
 
-  describe '#sources' do
+  describe "#sources" do
     let(:source_data) do
-      JSON.parse(File.read('spec/fixtures/resource/sample_catalog_source.json'))
+      JSON.parse(File.read("spec/fixtures/resource/sample_catalog_source.json"))
     end
 
-    it 'should call the api to fetch the sources' do
+    it "should call the api to fetch the sources" do
       expect(client).to receive(:http_get_paginated_array!)
-        .with('/catalog/api/admin/sources', nil)
+        .with("/catalog/api/admin/sources", nil)
         .and_return([source_data])
 
       client.catalog.all_sources
     end
 
-    it 'should return the Vra::CatalogSource object' do
+    it "should return the Vra::CatalogSource object" do
       expect(client).to receive(:http_get_paginated_array!)
-        .with('/catalog/api/admin/sources', nil)
+        .with("/catalog/api/admin/sources", nil)
         .and_return([source_data])
 
       source = client.catalog.all_sources.first
@@ -123,22 +123,22 @@ describe Vra::Catalog do
     end
   end
 
-  describe '#types' do
+  describe "#types" do
     let(:type_data) do
-      JSON.parse(File.read('spec/fixtures/resource/sample_catalog_type.json'))
+      JSON.parse(File.read("spec/fixtures/resource/sample_catalog_type.json"))
     end
 
-    it 'should call the api to fetch the types' do
+    it "should call the api to fetch the types" do
       expect(client).to receive(:http_get_paginated_array!)
-        .with('/catalog/api/types', nil)
+        .with("/catalog/api/types", nil)
         .and_return([type_data])
 
       client.catalog.all_types
     end
 
-    it 'should return the Vra::CatalogType object' do
+    it "should return the Vra::CatalogType object" do
       expect(client).to receive(:http_get_paginated_array!)
-        .with('/catalog/api/types', nil)
+        .with("/catalog/api/types", nil)
         .and_return([type_data])
 
       source = client.catalog.all_types.first
@@ -147,17 +147,17 @@ describe Vra::Catalog do
     end
   end
 
-  describe '#fetch_catalog_by_name' do
+  describe "#fetch_catalog_by_name" do
     let(:catalog_item) do
-      JSON.parse(File.read('spec/fixtures/resource/sample_catalog_item.json'))
+      JSON.parse(File.read("spec/fixtures/resource/sample_catalog_item.json"))
     end
 
-    it 'returns the catalogs by name' do
+    it "returns the catalogs by name" do
       expect(client).to receive(:http_get_paginated_array!)
-        .with('/catalog/api/admin/items', 'search=centos')
+        .with("/catalog/api/items", "search=centos")
         .and_return([catalog_item])
 
-      cat = client.catalog.fetch_catalog_items('centos').first
+      cat = client.catalog.fetch_catalog_items("centos").first
 
       expect(cat).to be_an_instance_of(Vra::CatalogItem)
     end

data/spec/catalog_type_spec.rb

@@ -16,23 +16,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-require 'spec_helper'
+require "spec_helper"
 
 describe Vra::CatalogType 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_catalog_type.json'))
+    JSON.parse(File.read("spec/fixtures/resource/sample_catalog_type.json"))
   end
 
-  describe '#initialize' do
+  describe "#initialize" do
     let(:cat_type) do
       described_class.allocate
     end
@@ -41,74 +41,74 @@ describe Vra::CatalogType do
       allow(client).to receive(:get_parsed).and_return(sample_data)
     end
 
-    it 'should validate and fetch data' do
+    it "should validate and fetch data" do
       expect(cat_type).to receive(:validate!)
       expect(cat_type).to receive(:fetch_data)
 
-      cat_type.send(:initialize, client, id: 'com.vmw.vro.workflow')
+      cat_type.send(:initialize, client, id: "com.vmw.vro.workflow")
     end
 
-    it 'should fetch data when id is passed' do
-      cat_type.send(:initialize, client, id: 'com.vmw.vro.workflow')
+    it "should fetch data when id is passed" do
+      cat_type.send(:initialize, client, id: "com.vmw.vro.workflow")
 
       expect(cat_type.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
       cat_type.send(:initialize, client, data: sample_data)
 
-      expect(cat_type.id).to eq('com.vmw.vro.workflow')
+      expect(cat_type.id).to eq("com.vmw.vro.workflow")
     end
   end
 
-  describe '#validate' do
+  describe "#validate" do
     let(:cat_type) do
       described_class.allocate
     end
 
-    it 'should raise exception when neither id nor data passed' do
+    it "should raise exception when neither id nor data passed" do
       expect { cat_type.send(:initialize, client) }.to raise_error(ArgumentError)
     end
 
-    it 'should raise exception when both id and data is passed' do
-      params = [client, { id: 'com.vmw.vra.workflow', data: sample_data }]
+    it "should raise exception when both id and data is passed" do
+      params = [client, { id: "com.vmw.vra.workflow", data: sample_data }]
       expect { cat_type.send(:initialize, *params) }.to raise_error(ArgumentError)
     end
   end
 
-  describe '#fetch_data' do
+  describe "#fetch_data" do
     let(:cat_type) do
       described_class.allocate
     end
 
-    it 'should fetch the data correctly' do
+    it "should fetch the data correctly" do
       allow(client).to receive(:get_parsed).and_return(sample_data)
-      cat_type.send(:initialize, client, id: 'com.vmw.vro.workflow')
+      cat_type.send(:initialize, client, id: "com.vmw.vro.workflow")
 
       data = cat_type.send(:data)
       expect(data).not_to be_nil
-      expect(cat_type.id).to eq(data['id'])
-      expect(data['name']).to eq('vRealize Orchestrator Workflow')
+      expect(cat_type.id).to eq(data["id"])
+      expect(data["name"]).to eq("vRealize Orchestrator Workflow")
     end
 
-    it 'should raise when catalog with type not found' do
+    it "should raise when catalog with type not found" do
       allow(client).to receive(:get_parsed).and_raise(Vra::Exception::HTTPNotFound)
 
-      expect { cat_type.send(:initialize, client, id: sample_data['id']) }
+      expect { cat_type.send(:initialize, client, id: sample_data["id"]) }
         .to raise_error(Vra::Exception::NotFound)
-        .with_message("catalog type ID #{sample_data['id']} does not exist")
+        .with_message("catalog type ID #{sample_data["id"]} does not exist")
     end
   end
 
-  describe 'attributes' do
-    it 'should have the correct attributes' do
+  describe "attributes" do
+    it "should have the correct attributes" do
       allow(client).to receive(:get_parsed).and_return(sample_data)
 
-      cat_type = described_class.new(client, id: sample_data['id'])
-      expect(cat_type.name).to eq('vRealize Orchestrator Workflow')
-      expect(cat_type.base_url).to eq('https://vra.corp.local:8080/vro')
-      expect(cat_type.config_schema).to eq(sample_data['configSchema'])
-      expect(cat_type.icon_id).to eq('0616ff81-c13b-32fe-b3b9-de3c2edd85dd')
+      cat_type = described_class.new(client, id: sample_data["id"])
+      expect(cat_type.name).to eq("vRealize Orchestrator Workflow")
+      expect(cat_type.base_url).to eq("https://vra.corp.local:8080/vro")
+      expect(cat_type.config_schema).to eq(sample_data["configSchema"])
+      expect(cat_type.icon_id).to eq("0616ff81-c13b-32fe-b3b9-de3c2edd85dd")
     end
   end
 end