adapt tests

Author: kathap

lib/cloud_controller/blobstore/storage_cli/storage_cli_client.rb

@@ -59,13 +59,12 @@ def initialize(connection_config:, directory_key:, resource_type:, root_dir:, mi
 
         begin
           VCAP::CloudController::YAMLConfig.safe_load_file(file_path)
-        rescue => e
+        rescue StandardError => e
           raise BlobstoreError.new("Failed to load storage-cli config at #{file_path}: #{e.message}")
         end
 
         @config_file = file_path
         logger.info('storage_cli_config_selected', resource_type: @resource_type, path: @config_file)
-
       end
 
       def local?

spec/unit/lib/cloud_controller/blobstore/client_provider_spec.rb

@@ -140,7 +140,8 @@ module Blobstore
         it 'provides a storage-cli client' do
           allow(StorageCliClient).to receive(:build).and_return(storage_cli_client_mock)
           ClientProvider.provide(options:, directory_key:, root_dir:, resource_type:)
-          expect(StorageCliClient).to have_received(:build).with(connection_config: {}, directory_key: directory_key, resource_type: resource_type, root_dir: root_dir, min_size: 100, max_size: 1000)
+          expect(StorageCliClient).to have_received(:build).with(connection_config: {}, directory_key: directory_key, resource_type: resource_type, root_dir: root_dir,
+                                                                 min_size: 100, max_size: 1000)
         end
 
         it 'raises an error if connection_config is not provided' do

spec/unit/lib/cloud_controller/blobstore/storage_cli/azure_storage_cli_client_spec.rb

@@ -1,13 +1,44 @@
 require 'spec_helper'
+require 'tempfile'
+require 'json'
 require_relative '../client_shared'
 require 'cloud_controller/blobstore/storage_cli/azure_storage_cli_client'
 require 'cloud_controller/blobstore/storage_cli/storage_cli_blob'
 
 module CloudController
   module Blobstore
     RSpec.describe AzureStorageCliClient do
-      subject(:client) { AzureStorageCliClient.new(connection_config: connection_config, directory_key: directory_key, root_dir: 'bommel') }
+      let!(:tmp_cfg) do
+        f = Tempfile.new(['storage_cli_config', '.json'])
+        f.write({ provider: 'AzureRM',
+                  account_name: 'some-account-name',
+                  account_key: 'some-access-key',
+                  container_name: directory_key,
+                  environment: 'AzureCloud' }.to_json)
+        f.flush
+        f
+      end
+
+      before do
+        cc_cfg = instance_double(VCAP::CloudController::Config)
+        allow(VCAP::CloudController::Config).to receive(:config).and_return(cc_cfg)
+
+        allow(cc_cfg).to receive(:get) do |key, *_|
+          case key
+          when :storage_cli_config_file_droplets,
+            :storage_cli_config_file_buildpacks,
+            :storage_cli_config_file_packages,
+            :storage_cli_config_file_resource_pool
+            tmp_cfg.path
+          end
+        end
+      end
+
+      after { tmp_cfg.close! }
+
+      subject(:client) { AzureStorageCliClient.new(connection_config: connection_config, directory_key: directory_key, resource_type: resource_type, root_dir: 'bommel') }
       let(:directory_key) { 'my-bucket' }
+      let(:resource_type) { 'resource_pool' }
       let(:connection_config) do
         {
           azure_storage_access_key: 'some-access-key',
@@ -59,7 +90,7 @@ module Blobstore
           expect(client.instance_variable_get(:@config_file)).to be_a(String)
           expect(File.exist?(client.instance_variable_get(:@config_file))).to be true
           expect(File.read(client.instance_variable_get(:@config_file))).to eq(
-            '{"account_name":"some-account-name","account_key":"some-access-key","container_name":"my-bucket","environment":"AzureCloud"}'
+            '{"provider":"AzureRM","account_name":"some-account-name","account_key":"some-access-key","container_name":"my-bucket","environment":"AzureCloud"}'
           )
         end
       end

spec/unit/lib/cloud_controller/blobstore/storage_cli/storage_cli_client_spec.rb

@@ -5,7 +5,6 @@ module CloudController
   module Blobstore
     RSpec.describe StorageCliClient do
       describe 'registry build and lookup' do
-
         it 'builds the correct client' do
           droplets_cfg = Tempfile.new(['droplets', '.json'])
           droplets_cfg.write({ connection_config: { provider: 'AzureRM' } }.to_json)
@@ -57,8 +56,6 @@ module Blobstore
             when :storage_cli_config_file_buildpacks    then buildpacks_cfg.path
             when :storage_cli_config_file_packages      then packages_cfg.path
             when :storage_cli_config_file_resource_pool then resource_pool_cfg.path
-            else
-              nil
             end
           end
 
@@ -70,12 +67,12 @@ module Blobstore
           [droplets_cfg, buildpacks_cfg, packages_cfg, resource_pool_cfg].each(&:close!)
         end
 
-        def build_client(rt)
+        def build_client(resource_type)
           StorageCliClient.build(
             connection_config: { provider: 'AzureRM' },
             directory_key: 'dir-key',
             root_dir: 'root',
-            resource_type: rt
+            resource_type: resource_type
           )
         end
 
@@ -110,23 +107,23 @@ def build_client(rt)
         end
 
         it 'raises for unknown resource_type' do
-          expect {
+          expect do
             build_client('nope')
-          }.to raise_error(CloudController::Blobstore::BlobstoreError, /Unknown resource_type: nope/)
+          end.to raise_error(CloudController::Blobstore::BlobstoreError, /Unknown resource_type: nope/)
         end
 
         it 'raises when file missing/unreadable' do
           allow(config_double).to receive(:get).with(:storage_cli_config_file_packages).and_return('/no/such/file.json')
-          expect {
+          expect do
             build_client('packages')
-          }.to raise_error(CloudController::Blobstore::BlobstoreError, /not found or not readable/)
+          end.to raise_error(CloudController::Blobstore::BlobstoreError, /not found or not readable/)
         end
 
         it 'raises when YAML load fails' do
-          File.write(packages_cfg.path, "{ this is: [not, valid }")
-          expect {
+          File.write(packages_cfg.path, '{ this is: [not, valid }')
+          expect do
             build_client('packages')
-          }.to raise_error(CloudController::Blobstore::BlobstoreError, /Failed to load storage-cli config/)
+          end.to raise_error(CloudController::Blobstore::BlobstoreError, /Failed to load storage-cli config/)
         end
       end
 
@@ -157,30 +154,29 @@ def build_client(rt)
         end
 
         it 'returns true on exitstatus 0' do
-          expect(Open3).to receive(:capture3)
-                             .with(kind_of(String), '-c', droplets_cfg.path, 'exists', kind_of(String))
-                             .and_return(['', '', instance_double(Process::Status, success?: true, exitstatus: 0)])
+          expect(Open3).to receive(:capture3).
+            with(kind_of(String), '-c', droplets_cfg.path, 'exists', kind_of(String)).
+            and_return(['', '', instance_double(Process::Status, success?: true, exitstatus: 0)])
 
           expect(client.exists?('key')).to be true
         end
 
         it 'returns false on exitstatus 3' do
-          expect(Open3).to receive(:capture3)
-                             .with(kind_of(String), '-c', droplets_cfg.path, 'exists', kind_of(String))
-                             .and_return(['', '', instance_double(Process::Status, success?: false, exitstatus: 3)])
+          expect(Open3).to receive(:capture3).
+            with(kind_of(String), '-c', droplets_cfg.path, 'exists', kind_of(String)).
+            and_return(['', '', instance_double(Process::Status, success?: false, exitstatus: 3)])
 
           expect(client.exists?('key')).to be false
         end
 
         it 'raises for other non-zero exit codes' do
-          expect(Open3).to receive(:capture3)
-                             .with(kind_of(String), '-c', droplets_cfg.path, 'exists', kind_of(String))
-                             .and_return(['', 'boom', instance_double(Process::Status, success?: false, exitstatus: 2)])
+          expect(Open3).to receive(:capture3).
+            with(kind_of(String), '-c', droplets_cfg.path, 'exists', kind_of(String)).
+            and_return(['', 'boom', instance_double(Process::Status, success?: false, exitstatus: 2)])
 
           expect { client.exists?('key') }.to raise_error(/storage-cli exists failed/)
         end
       end
-
     end
   end
 end

spec/unit/lib/cloud_controller/dependency_locator_spec.rb

@@ -77,7 +77,8 @@
     it 'creates blob store' do
       expect(CloudController::Blobstore::ClientProvider).to receive(:provide).with(
         options: config.get(:resource_pool),
-        directory_key: 'key'
+        directory_key: 'key',
+        resource_type: :resource_pool
       )
       locator.legacy_global_app_bits_cache
     end
@@ -97,7 +98,8 @@
       expect(CloudController::Blobstore::ClientProvider).to receive(:provide).with(
         options: config.get(:resource_pool),
         directory_key: 'key',
-        root_dir: 'app_bits_cache'
+        root_dir: 'app_bits_cache',
+        resource_type: :resource_pool
       )
       locator.global_app_bits_cache
     end