vmware-vra 3.1.2 → 3.2.0

data/spec/catalog_item_spec.rb

@@ -17,142 +17,142 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Vra::CatalogItem 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",
+      domain: "domain",
+      base_url: "https://vra.corp.local"
     )
   end
 
-  let(:catalog_id) { '123456' }
+  let(:catalog_id) { "123456" }
 
   let(:catalog_item_payload) 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(:other_catalog_item_payload) 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
 
-  describe '#initialize' do
-    it 'raises an error if no ID or catalog item data have been provided' do
+  describe "#initialize" do
+    it "raises an error if no ID or catalog item data have been provided" do
       expect { Vra::CatalogItem.new(client) }.to raise_error(ArgumentError)
     end
 
-    it 'raises an error if an ID and catalog item data have both been provided' do
-      expect { Vra::CatalogItem.new(client, id: 123, data: 'foo') }.to raise_error(ArgumentError)
+    it "raises an error if an ID and catalog item data have both been provided" do
+      expect { Vra::CatalogItem.new(client, id: 123, data: "foo") }.to raise_error(ArgumentError)
     end
 
-    context 'when an ID is provided' do
-      it 'fetches the catalog_item record' do
+    context "when an ID is provided" do
+      it "fetches the catalog_item record" do
         catalog_item = Vra::CatalogItem.allocate
         expect(catalog_item).to receive(:fetch_catalog_item)
         catalog_item.send(:initialize, client, id: catalog_id)
       end
     end
 
-    context 'when catalog item data is provided' do
-      it 'populates the ID correctly' do
+    context "when catalog item data is provided" do
+      it "populates the ID correctly" do
         catalog_item = Vra::CatalogItem.new(client, data: catalog_item_payload)
         expect(catalog_item.id).to eq catalog_id
       end
     end
   end
 
-  describe '#fetch_catalog_item' do
-    context 'when the catalog item exists' do
-      let(:response) { double('response', code: 200, body: catalog_item_payload.to_json) }
+  describe "#fetch_catalog_item" do
+    context "when the catalog item exists" do
+      let(:response) { double("response", code: 200, body: catalog_item_payload.to_json) }
 
-      it 'calls http_get against the catalog_service' do
-        expect(client).to receive(:http_get).with('/catalog/api/admin/items/catalog-12345').and_return(response)
-        Vra::CatalogItem.new(client, id: 'catalog-12345')
+      it "calls http_get against the catalog_service" do
+        expect(client).to receive(:http_get).with("/catalog/api/items/catalog-12345").and_return(response)
+        Vra::CatalogItem.new(client, id: "catalog-12345")
       end
     end
 
-    context 'when the catalog item does not exist' do
-      it 'raises an exception' do
+    context "when the catalog item does not exist" do
+      it "raises an exception" do
         allow(client)
           .to receive(:http_get)
-          .with('/catalog/api/admin/items/catalog-12345')
+          .with("/catalog/api/items/catalog-12345")
           .and_raise(Vra::Exception::HTTPNotFound)
 
-        expect { Vra::CatalogItem.new(client, id: 'catalog-12345') }
+        expect { Vra::CatalogItem.new(client, id: "catalog-12345") }
           .to raise_error(Vra::Exception::NotFound)
-          .with_message('catalog ID catalog-12345 does not exist')
+          .with_message("catalog ID catalog-12345 does not exist")
       end
     end
   end
 
-  describe '#entitle!' do
-    it 'should entitle the catalog item' do
+  describe "#entitle!" do
+    it "should entitle the catalog item" do
       allow(client).to receive(:authorized?).and_return(true)
-      stub_request(:get, client.full_url('/catalog/api/admin/items/123456'))
+      stub_request(:get, client.full_url("/catalog/api/items/123456"))
         .to_return(status: 200, body: catalog_item_payload.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
 
-  describe '#attributes' do
-    it 'should have the correct attributes' do
+  describe "#attributes" do
+    it "should have the correct attributes" do
       allow(client).to receive(:authorized?).and_return(true)
-      stub_request(:get, client.full_url('/catalog/api/admin/sources/source-123456'))
+      stub_request(:get, client.full_url("/catalog/api/admin/sources/source-123456"))
         .to_return(
           status: 200,
-          body: File.read('spec/fixtures/resource/sample_catalog_source.json'),
+          body: File.read("spec/fixtures/resource/sample_catalog_source.json"),
           headers: {}
         )
       catalog_item = described_class.new(client, data: catalog_item_payload)
 
-      expect(catalog_item.name).to eq('centos')
-      expect(catalog_item.description).to eq('Centos Cat')
-      expect(catalog_item.source_id).to eq('source-123456')
-      expect(catalog_item.source_name).to eq('Source 123')
-      expect(catalog_item.icon_id).to eq('1495b8d9')
+      expect(catalog_item.name).to eq("centos")
+      expect(catalog_item.description).to eq("Centos Cat")
+      expect(catalog_item.source_id).to eq("source-123456")
+      expect(catalog_item.source_name).to eq("Source 123")
+      expect(catalog_item.icon_id).to eq("1495b8d9")
       expect(catalog_item.source).to be_a(Vra::CatalogSource)
       expect(catalog_item.type).to be_a(Vra::CatalogType)
     end
   end
 
-  describe '#versions' do
+  describe "#versions" do
     let(:versions_response) do
-      [{ id: '2', description: 'v2.0' }, { id: '1', description: 'v1.0' }]
+      [{ id: "2", description: "v2.0" }, { id: "1", description: "v1.0" }]
     end
 
     before do
       allow(client).to receive(:authorized?).and_return(true)
     end
 
-    it 'should call the api to fetch the versions' do
+    it "should call the api to fetch the versions" do
       expect(client)
         .to receive(:http_get_paginated_array!)
-        .with('/catalog/api/items/catalog-12345/versions')
+        .with("/catalog/api/items/catalog-12345/versions")
         .and_return(versions_response)
 
-      described_class.fetch_latest_version(client, 'catalog-12345')
+      described_class.fetch_latest_version(client, "catalog-12345")
     end
 
-    it 'should return the correct version' do
-      stub_request(:get, client.full_url('/catalog/api/items/catalog-12345/versions?$skip=0&$top=20'))
+    it "should return the correct version" do
+      stub_request(:get, client.full_url("/catalog/api/items/catalog-12345/versions?$skip=0&$top=20"))
         .to_return(
           status: 200,
           body: {
             content: versions_response,
-            totalPages: 1
+            totalPages: 1,
           }.to_json,
           headers: {}
         )
 
-      expect(described_class.fetch_latest_version(client, 'catalog-12345')).to eq('2')
+      expect(described_class.fetch_latest_version(client, "catalog-12345")).to eq("2")
     end
   end
 end

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",
+      domain: "domain",
+      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",
+      domain: "domain",
+      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