beaker-google 1.2.0 → 1.3.0

data/spec/classes/beaker/google_compute_helper_configuration_validation_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Beaker::GoogleComputeHelper do
+  let(:logger) { instance_double(Beaker::Logger) }
+  let(:base_options) { { logger: logger, gce_project: 'test-project', gce_ports: [] } }
+
+  def mock_google_services
+    # Mock the authentication and service initialization
+    allow(Google::Auth).to receive(:get_application_default).and_return(double)
+
+    compute_service = double
+    allow(compute_service).to receive(:authorization=)
+    allow(compute_service).to receive(:request_options).and_return(Google::Apis::RequestOptions.new)
+    allow(Google::Apis::ComputeV1::ComputeService).to receive(:new).and_return(compute_service)
+
+    oslogin_service = double
+    allow(oslogin_service).to receive(:authorization=)
+    allow(Google::Apis::OsloginV1::CloudOSLoginService).to receive(:new).and_return(oslogin_service)
+
+    client_options = double
+    allow(client_options).to receive(:application_name=)
+    allow(client_options).to receive(:application_version=)
+    allow(Google::Apis::ClientOptions).to receive(:default).and_return(client_options)
+  end
+
+  describe 'initialization validation' do
+    context 'when project is not provided' do
+      let(:options) { base_options.merge(gce_project: nil) }
+
+      it 'raises an error' do
+        expect do
+          described_class.new(options)
+        end.to raise_error('You must specify a gce_project for Google Compute Engine instances!')
+      end
+    end
+
+    context 'when project is provided' do
+      let(:options) { base_options }
+
+      it 'does not raise an error' do
+        mock_google_services
+
+        expect do
+          described_class.new(options)
+        end.not_to raise_error
+      end
+    end
+  end
+
+  describe 'port validation' do
+    context 'when port format is invalid' do
+      let(:options) { base_options.merge(gce_ports: ['22']) }
+
+      it 'raises an error' do
+        expect do
+          described_class.new(options)
+        end.to raise_error(%r{Invalid format for port 22. Should be 'port/proto'})
+      end
+    end
+
+    context 'when port protocol is invalid' do
+      let(:options) { base_options.merge(gce_ports: ['22/invalid']) }
+
+      it 'raises an error' do
+        expect do
+          described_class.new(options)
+        end.to raise_error(%r{Invalid value 'invalid' for protocol in '22/invalid'. Must be one of})
+      end
+    end
+
+    context 'when port format is valid' do
+      let(:options) { base_options.merge(gce_ports: ['22/tcp', '80/tcp']) }
+
+      it 'does not raise an error' do
+        mock_google_services
+
+        expect do
+          described_class.new(options)
+        end.not_to raise_error
+      end
+    end
+
+    context 'when all valid protocols are used' do
+      let(:valid_protocols) { described_class::VALID_PROTOS }
+
+      before do
+        mock_google_services
+      end
+
+      it 'accepts all valid protocols' do
+        valid_protocols.each do |proto|
+          options = base_options.merge(gce_ports: ["80/#{proto}"])
+          expect { described_class.new(options) }.not_to raise_error
+        end
+      end
+    end
+  end
+end

data/spec/classes/beaker/google_compute_helper_constants_and_defaults_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Beaker::GoogleComputeHelper do
+  context 'when testing constants and defaults' do
+    let(:base_options) do
+      {
+        gce_project: 'test-project',
+        gce_zone: 'us-central1-a',
+        gce_network: 'default',
+        logger: instance_double(Beaker::Logger, debug: nil, info: nil, warn: nil, error: nil),
+      }
+    end
+
+    describe 'Google Compute Helper constants' do
+      it 'defines AUTH_URL constant' do
+        expect(described_class::AUTH_URL).to eq('https://www.googleapis.com/auth/compute')
+      end
+
+      it 'defines API_VERSION constant' do
+        expect(described_class::API_VERSION).to eq('v1')
+      end
+
+      it 'defines BASE_URL constant' do
+        expect(described_class::BASE_URL).to eq('https://www.googleapis.com/compute/v1/projects/')
+      end
+
+      it 'defines DEFAULT_ZONE_NAME constant' do
+        expect(described_class::DEFAULT_ZONE_NAME).to eq('us-central1-a')
+      end
+
+      it 'defines DEFAULT_MACHINE_TYPE constant' do
+        expect(described_class::DEFAULT_MACHINE_TYPE).to eq('e2-standard-4')
+      end
+
+      it 'defines DEFAULT_NETWORK_NAME constant' do
+        expect(described_class::DEFAULT_NETWORK_NAME).to eq('default')
+      end
+
+      it 'defines SLEEPWAIT constant' do
+        expect(described_class::SLEEPWAIT).to eq(5)
+      end
+
+      it 'defines valid protocols' do
+        expect(described_class::VALID_PROTOS).to eq(%w[tcp udp icmp esp ah ipip sctp])
+          .and be_frozen
+      end
+
+      it 'defines GCP auth scopes structure' do
+        auth_scopes = described_class::GCP_AUTH_SCOPE
+
+        expect(auth_scopes).to be_an(Array).and be_frozen.and have_attributes(length: 2)
+          .and include('https://www.googleapis.com/auth/compute')
+          .and include('https://www.googleapis.com/auth/cloud-platform.read-only')
+      end
+    end
+
+    describe 'Google Compute constants' do
+      it 'defines Windows image projects' do
+        expect(Beaker::GoogleCompute::WINDOWS_IMAGE_PROJECT).to eq(%w[windows-cloud windows-sql-cloud])
+          .and be_frozen
+      end
+    end
+  end
+end

data/spec/classes/beaker/google_compute_helper_edge_cases_spec.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Beaker::GoogleComputeHelper do
+  context 'when testing edge cases and integration' do
+    describe 'version loading' do
+      it 'loads version as a module constant' do
+        expect(BeakerGoogle::VERSION).to be_a(String)
+          .and match(/^\d+\.\d+\.\d+/)
+      end
+
+      it 'is accessible through the module' do
+        expect { BeakerGoogle::VERSION }.not_to raise_error
+      end
+    end
+
+    describe 'module structure' do
+      it 'defines the BeakerGoogle module' do
+        expect(BeakerGoogle).to be_a(Module)
+      end
+
+      it 'has const_get method' do
+        expect(BeakerGoogle).to respond_to(:const_get)
+      end
+
+      it 'has version information' do
+        expect(BeakerGoogle.const_get(:VERSION)).to be_a(String)
+      end
+    end
+
+    describe 'string processing edge cases' do
+      it 'handles nil values safely' do
+        expect(safe_string_process(nil)).to be_nil
+      end
+
+      it 'handles empty strings' do
+        expect(safe_string_process('')).to eq('')
+      end
+
+      it 'handles whitespace' do
+        expect(safe_string_process('  test  ')).to eq('test')
+      end
+
+      it 'handles special characters' do
+        expect(safe_string_process('test@example.com')).to eq('test@example.com')
+      end
+
+      private
+
+      def safe_string_process(str)
+        return nil if str.nil?
+        return str if str.empty?
+
+        str.strip
+      end
+    end
+
+    describe 'environment variable handling' do
+      it 'handles missing environment variables gracefully' do
+        allow(ENV).to receive(:[]).with('NONEXISTENT_VAR').and_return(nil)
+        expect(ENV.fetch('NONEXISTENT_VAR', nil)).to be_nil
+      end
+
+      it 'handles empty environment variables' do
+        allow(ENV).to receive(:[]).with('EMPTY_VAR').and_return('')
+        allow(ENV).to receive(:fetch).with('EMPTY_VAR', nil).and_return('')
+        expect(ENV.fetch('EMPTY_VAR', nil)).to eq('')
+      end
+
+      it 'handles environment variables with spaces' do
+        allow(ENV).to receive(:[]).with('SPACE_VAR').and_return('  value  ')
+        allow(ENV).to receive(:fetch).with('SPACE_VAR', nil).and_return('  value  ')
+        expect(ENV.fetch('SPACE_VAR', nil)).to eq('  value  ')
+      end
+    end
+
+    describe 'GoogleComputeHelper options processing' do
+      let(:logger) { instance_double(Beaker::Logger) }
+      let(:base_options) { { logger: logger, gce_project: 'test-project' } }
+
+      def mock_google_services
+        # Mock the authentication and service initialization
+        allow(Google::Auth).to receive(:get_application_default).and_return(double)
+
+        compute_service = double
+        allow(compute_service).to receive(:authorization=)
+        allow(compute_service).to receive(:request_options).and_return(Google::Apis::RequestOptions.new)
+        allow(Google::Apis::ComputeV1::ComputeService).to receive(:new).and_return(compute_service)
+
+        oslogin_service = double
+        allow(oslogin_service).to receive(:authorization=)
+        allow(Google::Apis::OsloginV1::CloudOSLoginService).to receive(:new).and_return(oslogin_service)
+
+        client_options = double
+        allow(client_options).to receive(:application_name=)
+        allow(client_options).to receive(:application_version=)
+        allow(Google::Apis::ClientOptions).to receive(:default).and_return(client_options)
+      end
+
+      before do
+        mock_google_services
+        allow(ENV).to receive(:fetch).and_call_original
+        allow(ENV).to receive(:fetch).with('BEAKER_gce_ports', '').and_return('')
+      end
+
+      it 'handles nil gce_ports configuration' do
+        options = base_options.merge(gce_ports: nil)
+
+        expect do
+          described_class.new(options)
+        end.not_to raise_error
+      end
+
+      it 'handles empty gce_ports configuration' do
+        options = base_options.merge(gce_ports: [])
+
+        mock_google_services
+
+        expect do
+          described_class.new(options)
+        end.not_to raise_error
+      end
+
+      it 'handles gce_ports with multiple valid entries' do
+        options = base_options.merge(gce_ports: ['22/tcp', '80/tcp', '443/tcp'])
+
+        mock_google_services
+
+        expect do
+          described_class.new(options)
+        end.not_to raise_error
+      end
+
+      def ports_for(env_value, configured)
+        allow(ENV).to receive(:fetch).with('BEAKER_gce_ports', '').and_return(env_value)
+        described_class.new(base_options.merge(gce_ports: configured)).options[:gce_ports]
+      end
+
+      it 'lets BEAKER_gce_ports replace configured gce_ports' do
+        expect(ports_for('8140/tcp, 443/tcp', ['80/tcp'])).to eq(['8140/tcp', '443/tcp'])
+      end
+
+      it 'uses BEAKER_gce_ports when gce_ports is not configured' do
+        expect(ports_for('8140/tcp', nil)).to eq(['8140/tcp'])
+      end
+
+      it 'keeps configured gce_ports when BEAKER_gce_ports is empty' do
+        expect(ports_for('', ['80/tcp'])).to eq(['80/tcp'])
+      end
+
+      it 'keeps configured gce_ports when BEAKER_gce_ports is only whitespace' do
+        expect(ports_for('   ', ['80/tcp'])).to eq(['80/tcp'])
+      end
+
+      it 'defaults to no ports when neither BEAKER_gce_ports nor gce_ports is set' do
+        expect(ports_for('', nil)).to eq([])
+      end
+
+      it 'validates ports taken from BEAKER_gce_ports' do
+        expect { ports_for('8140/bogus', ['80/tcp']) }.to raise_error(/Invalid value 'bogus' for protocol/)
+      end
+
+      it 'splits a comma-separated gce_ports string from the hosts file' do
+        expect(ports_for('', '80/tcp, 443/tcp')).to eq(['80/tcp', '443/tcp'])
+      end
+
+      it 'splits comma-separated entries inside a gce_ports list' do
+        expect(ports_for('', ['80/tcp,443/tcp', ' 8140/tcp '])).to eq(['80/tcp', '443/tcp', '8140/tcp'])
+      end
+    end
+  end
+end

data/spec/classes/beaker/google_compute_helper_error_handling_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Beaker::GoogleComputeHelper do
+  context 'when handling errors' do
+    describe 'GoogleComputeError' do
+      it 'can be raised with a custom message' do
+        expect do
+          raise Beaker::GoogleComputeHelper::GoogleComputeError, 'Custom error message'
+        end.to raise_error(Beaker::GoogleComputeHelper::GoogleComputeError, 'Custom error message')
+      end
+
+      it 'inherits from StandardError' do
+        expect(Beaker::GoogleComputeHelper::GoogleComputeError).to be < StandardError
+      end
+    end
+
+    describe 'GoogleComputeHelper configuration errors' do
+      let(:logger) { instance_double(Beaker::Logger) }
+      let(:base_options) { { logger: logger } }
+
+      before do
+        # Mock the authentication and service initialization
+        allow(Google::Auth).to receive(:get_application_default).and_return(double)
+
+        compute_service = double
+        allow(compute_service).to receive(:authorization=)
+        allow(compute_service).to receive(:request_options).and_return(Google::Apis::RequestOptions.new)
+        allow(Google::Apis::ComputeV1::ComputeService).to receive(:new).and_return(compute_service)
+
+        oslogin_service = double
+        allow(oslogin_service).to receive(:authorization=)
+        allow(Google::Apis::OsloginV1::CloudOSLoginService).to receive(:new).and_return(oslogin_service)
+
+        client_options = double
+        allow(client_options).to receive(:application_name=)
+        allow(client_options).to receive(:application_version=)
+        allow(Google::Apis::ClientOptions).to receive(:default).and_return(client_options)
+      end
+
+      it 'raises error when gce_project is missing' do
+        expect do
+          described_class.new(base_options.merge(gce_project: nil))
+        end.to raise_error('You must specify a gce_project for Google Compute Engine instances!')
+      end
+
+      it 'passes validation when gce_project is provided' do
+        options = base_options.merge(gce_project: 'test-project', gce_ports: [])
+
+        expect do
+          described_class.new(options)
+        end.not_to raise_error
+      end
+    end
+
+    describe 'GoogleComputeHelper port validation errors' do
+      let(:logger) { instance_double(Beaker::Logger) }
+      let(:base_options) { { logger: logger, gce_project: 'test-project' } }
+
+      before do
+        # Mock the authentication and service initialization
+        allow(Google::Auth).to receive(:get_application_default).and_return(double)
+
+        compute_service = double
+        allow(compute_service).to receive(:authorization=)
+        allow(compute_service).to receive(:request_options).and_return(Google::Apis::RequestOptions.new)
+        allow(Google::Apis::ComputeV1::ComputeService).to receive(:new).and_return(compute_service)
+
+        oslogin_service = double
+        allow(oslogin_service).to receive(:authorization=)
+        allow(Google::Apis::OsloginV1::CloudOSLoginService).to receive(:new).and_return(oslogin_service)
+
+        client_options = double
+        allow(client_options).to receive(:application_name=)
+        allow(client_options).to receive(:application_version=)
+        allow(Google::Apis::ClientOptions).to receive(:default).and_return(client_options)
+      end
+
+      it 'raises error for invalid protocol' do
+        options = base_options.merge(gce_ports: ['80/invalid'])
+
+        expect do
+          described_class.new(options)
+        end.to raise_error(%r{Invalid value 'invalid' for protocol in '80/invalid'})
+      end
+
+      it 'raises error for invalid port format' do
+        options = base_options.merge(gce_ports: ['invalid-port'])
+
+        expect do
+          described_class.new(options)
+        end.to raise_error(/Invalid format for port invalid-port/)
+      end
+
+      it 'accepts valid protocols' do
+        options = base_options.merge(gce_ports: ['80/tcp', '443/udp'])
+
+        expect do
+          described_class.new(options)
+        end.not_to raise_error
+      end
+    end
+  end
+end