vmware-vra 2.7.0 → 3.0.1

data/spec/catalog_item_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 #
 # Author:: Chef Partner Engineering (<partnereng@chef.io>)
-# Copyright:: Copyright (c) 2015 Chef Software, Inc.
+# Copyright:: Copyright (c) 2022 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,267 +17,109 @@
 # 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")
+    Vra::Client.new(
+      username: 'user@corp.local',
+      password: 'password',
+      tenant: 'tenant',
+      base_url: 'https://vra.corp.local'
+    )
   end
 
-  let(:catalog_id) { "9e98042e-5443-4082-afd5-ab5a32939bbc" }
+  let(:catalog_id) { '123456' }
 
   let(:catalog_item_payload) do
-    {
-      "@type" => "CatalogItem",
-      "id" => "9e98042e-5443-4082-afd5-ab5a32939bbc",
-      "version" => 2,
-      "name" => "CentOS 6.6",
-      "description" => "Blueprint for deploying a CentOS Linux development server",
-      "status" => "PUBLISHED",
-      "statusName" => "Published",
-      "organization" => {
-        "tenantRef" => "vsphere.local",
-        "tenantLabel" => "vsphere.local",
-        "subtenantRef" => "962ab3f9-858c-4483-a49f-fa97392c314b",
-        "subtenantLabel" => "catalog_subtenant",
-      },
-      "providerBinding" => {
-        "bindingId" => "33af5413-4f20-4b3b-8268-32edad434dfb",
-        "providerRef" => {
-          "id" => "c3b2bc30-47b0-454f-b57d-df02a7356fe6",
-          "label" => "iaas-service",
-        },
-      },
-    }
+    JSON.parse(File.read('spec/fixtures/resource/sample_catalog_item.json'))
   end
 
   let(:other_catalog_item_payload) do
-    {
-        "@type" => "CatalogItem",
-        "id" => "3232323e-5443-4082-afd5-ab5a32939bbc",
-        "version" => 2,
-        "name" => "CentOS 6.6",
-        "description" => "Blueprint for deploying a CentOS Linux development server",
-        "status" => "PUBLISHED",
-        "statusName" => "Published",
-        "organization" => {
-            "tenantRef" => "vsphere.local",
-            "tenantLabel" => "vsphere.local",
-            "subtenantRef" => "962ab3f9-858c-4483-a49f-fa97392c314b",
-            "subtenantLabel" => "catalog_subtenant",
-        },
-        "providerBinding" => {
-            "bindingId" => "33af5413-4f20-4b3b-8268-32edad434dfb",
-            "providerRef" => {
-                "id" => "c3b2bc30-47b0-454f-b57d-df02a7356fe6",
-                "label" => "iaas-service",
-            },
-        },
-    }
+    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
-      expect { Vra::CatalogItem.new }.to raise_error(ArgumentError)
+  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(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-service/api/consumer/catalogItems/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/admin/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
-        allow(client).to receive(:http_get).with("/catalog-service/api/consumer/catalogItems/catalog-12345").and_raise(Vra::Exception::HTTPNotFound)
-        expect { Vra::CatalogItem.new(client, id: "catalog-12345") }.to raise_error(Vra::Exception::NotFound)
+    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')
+          .and_raise(Vra::Exception::HTTPNotFound)
+
+        expect { Vra::CatalogItem.new(client, id: 'catalog-12345') }
+          .to raise_error(Vra::Exception::NotFound)
+          .with_message('catalog ID catalog-12345 does not exist')
       end
     end
   end
 
-  describe "#organization" do
-    let(:catalog_item) { Vra::CatalogItem.new(client, data: catalog_item_payload) }
+  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'))
+        .to_return(status: 200, body: catalog_item_payload.to_json, headers: {})
 
-    context "when organization data exists" do
-      let(:catalog_item_payload) do
-        {
-          "@type" => "CatalogItem",
-          "id" => "9e98042e-5443-4082-afd5-ab5a32939bbc",
-          "organization" => {
-            "tenantRef" => "vsphere.local",
-            "tenantLabel" => "vsphere.local",
-            "subtenantRef" => "962ab3f9-858c-4483-a49f-fa97392c314b",
-            "subtenantLabel" => "catalog_subtenant",
-          },
-        }
-      end
+      response = double('response', body: '{"message": "success"}', success?: true)
+      allow(client).to receive(:http_post).and_return(response)
 
-      it "returns the correct organization data" do
-        expect(catalog_item.organization["tenantRef"]).to eq("vsphere.local")
-      end
+      entitle_response = described_class.entitle!(client, '123456')
+      expect(entitle_response).not_to be_nil
     end
+  end
 
-    context "when organization data does not exist" do
-      let(:catalog_item_payload) do
-        {
-          "@type" => "CatalogItem",
-          "id" => "9e98042e-5443-4082-afd5-ab5a32939bbc",
-        }
-      end
-
-      it "returns an empty hash" do
-        expect(catalog_item.organization).to eq({})
-      end
-
-      it "returns nil for any organization keys" do
-        expect(catalog_item.organization["tenantRef"]).to eq(nil)
-      end
-    end
-
-    describe "class methods" do
-      let(:response) { double("response", code: 200, body: catalog_item_payload.to_json) }
-
-      it "#dump_template" do
-        expect(client).to receive(:http_get).with("/catalog-service/api/consumer/entitledCatalogItems/#{catalog_id}/requests/template")
-                              .and_return(response)
-        described_class.dump_template(client, catalog_id )
-      end
-
-      it "#write_template" do
-        allow(client).to receive(:http_get).with("/catalog-service/api/consumer/entitledCatalogItems/#{catalog_id}/requests/template")
-                             .and_return(response)
-        expect(File).to receive(:write).with("9e98042e-5443-4082-afd5-ab5a32939bbc.json", JSON.pretty_generate(catalog_item_payload))
-        expect(described_class.write_template(client, catalog_id)).to eq("9e98042e-5443-4082-afd5-ab5a32939bbc.json")
-      end
-
-      it "#write_template with custom filename" do
-        allow(client).to receive(:http_get).with("/catalog-service/api/consumer/entitledCatalogItems/#{catalog_id}/requests/template")
-                             .and_return(response)
-        expect(File).to receive(:write).with("somefile.json", JSON.pretty_generate(catalog_item_payload))
-        expect(described_class.write_template(client, catalog_id, "somefile.json")).to eq("somefile.json")
-      end
-
-      context "entitled items" do
-        let(:response2) { double("response", code: 200, body: other_catalog_item_payload.to_json) }
-
-        let(:entitled_catalog_item) do
-          {
-              "@type" => "ConsumerEntitledCatalogItem",
-              "catalogItem" => {
-                  "id" => "d29efd6b-3cd6-4f8d-b1d8-da4ddd4e52b1",
-                  "version" => 2,
-                  "name" => "WindowsServer2012",
-                  "description" => "Windows Server 2012 with the latest updates and patches.",
-                  "status" => "PUBLISHED",
-                  "statusName" => "Published",
-                  "organization" => {
-                      "tenantRef" => "vsphere.local",
-                      "tenantLabel" => "vsphere.local",
-                      "subtenantRef" => nil,
-                      "subtenantLabel" => nil,
-                  },
-                  "providerBinding" => {
-                      "bindingId" => "59fd02a1-acca-4918-9d3d-2298d310caef",
-                      "providerRef" => {
-                          "id" => "c3b2bc30-47b0-454f-b57d-df02a7356fe6",
-                          "label" => "iaas-service",
-                      },
-                  },
-              },
-          }
-        end
-
-        let(:entitled_catalog_item2) do
-          {
-              "@type" => "ConsumerEntitledCatalogItem",
-              "catalogItem" => {
-                  "id" => "3232323e-5443-4082-afd5-ab5a32939bbc",
-                  "version" => 2,
-                  "name" => "WindowsServer2016",
-                  "description" => "Windows Server 2012 with the latest updates and patches.",
-                  "status" => "PUBLISHED",
-                  "statusName" => "Published",
-                  "organization" => {
-                      "tenantRef" => "vsphere.local",
-                      "tenantLabel" => "vsphere.local",
-                      "subtenantRef" => nil,
-                      "subtenantLabel" => nil,
-                  },
-                  "providerBinding" => {
-                      "bindingId" => "59fd02a1-acca-4918-9d3d-2298d310caef",
-                      "providerRef" => {
-                          "id" => "c3b2bc30-47b0-454f-b57d-df02a7356fe6",
-                          "label" => "iaas-service",
-                      },
-                  },
-              },
-          }
-        end
-
-        before(:each) do
-          allow(client).to receive(:http_get_paginated_array!).with("/catalog-service/api/consumer/entitledCatalogItems")
-                                .and_return([ entitled_catalog_item, entitled_catalog_item2 ])
-          allow(client).to receive(:http_get)
-                               .with("/catalog-service/api/consumer/entitledCatalogItems/d29efd6b-3cd6-4f8d-b1d8-da4ddd4e52b1/requests/template")
-                               .and_return(response)
-          allow(client).to receive(:http_get)
-                               .with("/catalog-service/api/consumer/entitledCatalogItems/3232323e-5443-4082-afd5-ab5a32939bbc/requests/template")
-                               .and_return(response)
-          allow(File).to receive(:write).with("vra_templates/d29efd6b-3cd6-4f8d-b1d8-da4ddd4e52b1.json", JSON.pretty_generate(catalog_item_payload))
-          allow(File).to receive(:write).with("vra_templates/3232323e-5443-4082-afd5-ab5a32939bbc.json", JSON.pretty_generate(catalog_item_payload))
-          allow(File).to receive(:write).with("vra_templates/windowsserver2012.json", JSON.pretty_generate(catalog_item_payload))
-          allow(File).to receive(:write).with("vra_templates/windowsserver2016.json", JSON.pretty_generate(catalog_item_payload))
-          allow(File).to receive(:write).with("custom_dir/windowsserver2012.json", JSON.pretty_generate(catalog_item_payload))
-          allow(File).to receive(:write).with("custom_dir/windowsserver2016.json", JSON.pretty_generate(catalog_item_payload))
-
-        end
-
-        it "#dump_templates" do
-          expect(described_class.dump_templates(client)).to eq(["vra_templates/windowsserver2012.json",
-                                                                "vra_templates/windowsserver2016.json"])
-        end
-
-        it "#dump_templates with custom directory" do
-          expect(described_class.dump_templates(client, "custom_dir")).to eq(["custom_dir/windowsserver2012.json",
-                                                                              "custom_dir/windowsserver2016.json"])
-        end
-
-        it "#dump_templates with id" do
-          expect(described_class.dump_templates(client, "vra_templates", true))
-              .to eq(["vra_templates/d29efd6b-3cd6-4f8d-b1d8-da4ddd4e52b1.json",
-                      "vra_templates/3232323e-5443-4082-afd5-ab5a32939bbc.json"])
-
-        end
-      end
-
+  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'))
+        .to_return(
+          status: 200,
+          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.source).to be_a(Vra::CatalogSource)
+      expect(catalog_item.type).to be_a(Vra::CatalogType)
     end
-
   end
 end

data/spec/catalog_source_spec.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+#
+# Author:: Ashique Saidalavi (<ashique.saidalavi@progress.com>)
+# Copyright:: Copyright (c) 2022 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+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'
+    )
+  end
+
+  let(:sample_data) do
+    JSON.parse(File.read('spec/fixtures/resource/sample_catalog_source.json'))
+  end
+
+  describe '#initialize' do
+    let(:source) do
+      described_class.allocate
+    end
+
+    before(:each) do
+      allow(client).to receive(:get_parsed).and_return(sample_data)
+    end
+
+    it 'should validate and fetch data' do
+      expect(source).to receive(:validate!)
+      expect(source).to receive(:fetch_data)
+
+      source.send(:initialize, client, id: '123456')
+    end
+
+    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
+      source.send(:initialize, client, data: sample_data)
+
+      expect(source.id).to eq('123456')
+    end
+  end
+
+  describe '#validate' do
+    let(:source) do
+      described_class.allocate
+    end
+
+    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 }]
+      expect { source.send(:initialize, *params) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#fetch_data' do
+    let(:source) do
+      described_class.allocate
+    end
+
+    it 'should fetch the data correctly' do
+      allow(client).to receive(:get_parsed).and_return(sample_data)
+      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')
+    end
+
+    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']) }
+        .to raise_error(Vra::Exception::NotFound)
+        .with_message("catalog source ID #{sample_data['id']} does not exist")
+    end
+  end
+
+  describe 'attributes' do
+    let(:sample_type_data) do
+      JSON.parse(File.read('spec/fixtures/resource/sample_catalog_type.json'))
+    end
+
+    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')
+      expect(source.catalog_type).to be_a(Vra::CatalogType)
+      expect(source.config).to eq({ 'sourceProjectId' => 'pro-123456'})
+      expect(source.global?).to be_falsey
+      expect(source.project_id).to eq('pro-123456')
+    end
+  end
+
+  describe '#create' do
+    let(:create_params) do
+      {
+        name: 'Devops',
+        catalog_type_id: 'com.vmw.blueprint',
+        project_id: 'pro-123456'
+      }
+    end
+
+    before(:each) 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)
+      expect(Vra::Http).to receive(:execute)
+        .with(method: :post,
+              url: client.full_url('/catalog/api/admin/sources'),
+              payload: {
+                name: 'Devops',
+                typeId: 'com.vmw.blueprint',
+                config: {
+                  sourceProjectId: 'pro-123456'
+                }
+              }.to_json,
+              headers: anything,
+              verify_ssl: true)
+        .and_return(response)
+
+      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)
+      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')
+    end
+  end
+
+  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'))
+        .to_return(status: 200, body: sample_data.to_json, headers: {})
+
+      response = double('response', body: '{"message": "success"}', success?: true)
+      allow(client).to receive(:http_post).and_return(response)
+
+      entitle_response = described_class.entitle!(client, '123456')
+      expect(entitle_response).not_to be_nil
+    end
+  end
+end