beaker-google 1.1.0 → 1.3.0

data/spec/classes/beaker/google_compute_ssh_key_management_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Beaker::GoogleCompute do
+  include FakeFS::SpecHelpers
+
+  subject(:google_compute) do
+    mock_google_services
+    described_class.new(hosts, options)
+  end
+
+  let(:logger) { instance_double(Beaker::Logger) }
+  let(:hosts) { [] }
+  let(: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 '#find_google_ssh_private_key' do
+    let(:default_private_key) { File.join(Dir.home, '.ssh', 'google_compute_engine') }
+
+    context 'when default key exists' do
+      before do
+        FileUtils.mkdir_p(File.dirname(default_private_key))
+        File.write(default_private_key, 'private key content')
+      end
+
+      it 'returns the default private key path' do
+        expect(google_compute.find_google_ssh_private_key).to eq(default_private_key)
+      end
+    end
+
+    context 'when private key does not exist' do
+      it 'raises an error' do
+        expect { google_compute.find_google_ssh_private_key }.to raise_error(/Could not find GCE Private SSH key/)
+      end
+    end
+  end
+
+  describe '#find_google_ssh_private_key with custom key' do
+    subject(:google_compute) do
+      mock_google_services
+      described_class.new(hosts, options.merge(gce_ssh_private_key: custom_private_key))
+    end
+
+    let(:custom_private_key) { '/custom/path/to/key' }
+
+    context 'when custom key is specified in options' do
+      before do
+        FileUtils.mkdir_p(File.dirname(custom_private_key))
+        File.write(custom_private_key, 'private key content')
+      end
+
+      it 'returns the custom private key path' do
+        expect(google_compute.find_google_ssh_private_key).to eq(custom_private_key)
+      end
+    end
+  end
+
+  describe '#find_google_ssh_public_key' do
+    subject(:google_compute) do
+      mock_google_services
+      described_class.new(hosts, options)
+    end
+
+    context 'when public key exists' do
+      let(:private_key) { '/path/to/private_key' }
+      let(:public_key) { '/path/to/private_key.pub' }
+
+      before do
+        FileUtils.mkdir_p(File.dirname(private_key))
+        File.write(private_key, 'private key content')
+        File.write(public_key, 'public key content')
+        # Set up the private key path in options for this test
+        google_compute.instance_variable_get(:@options)[:gce_ssh_private_key] = private_key
+      end
+
+      it 'returns the public key path' do
+        expect(google_compute.find_google_ssh_public_key).to eq(public_key)
+      end
+    end
+
+    context 'when public key does not exist' do
+      let(:private_key) { '/path/to/private_key' }
+
+      before do
+        FileUtils.mkdir_p(File.dirname(private_key))
+        File.write(private_key, 'private key content')
+        # Set up the private key path in options for this test
+        google_compute.instance_variable_get(:@options)[:gce_ssh_private_key] = private_key
+      end
+
+      it 'raises an error' do
+        expect { google_compute.find_google_ssh_public_key }.to raise_error(/Could not find GCE Public SSH key/)
+      end
+    end
+  end
+end

data/spec/classes/beaker/google_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# Mock the Google Compute classes to avoid dependency issues
+module Beaker
+  class Google < Beaker::GoogleCompute
+  end
+end
+
+RSpec.describe Beaker::Google do
+  let(:hosts) { [] }
+  let(:options) { { gce_project: 'test', logger: instance_double(Beaker::Logger) } }
+
+  # Mock Google authentication and services to avoid actual authentication
+  before do
+    # Mock the authentication components
+    allow(Google::Auth).to receive(:get_application_default).and_return(
+      instance_double(Google::Auth::ServiceAccountCredentials),
+    )
+    allow(Google::Auth::ServiceAccountCredentials).to receive(:from_env).and_return(
+      instance_double(Google::Auth::ServiceAccountCredentials),
+    )
+
+    # Mock the Google API client options
+    client_options = instance_double(Google::Apis::ClientOptions)
+    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)
+
+    # Mock the Google Compute and OS Login services
+    compute_service = instance_double(Google::Apis::ComputeV1::ComputeService)
+    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 = instance_double(Google::Apis::OsloginV1::CloudOSLoginService)
+    allow(oslogin_service).to receive(:authorization=)
+    allow(Google::Apis::OsloginV1::CloudOSLoginService).to receive(:new).and_return(oslogin_service)
+
+    # Mock environment variables that might be checked
+    allow(ENV).to receive(:[]).and_call_original
+    allow(ENV).to receive(:fetch).and_call_original
+    allow(ENV).to receive(:[]).with('GOOGLE_APPLICATION_CREDENTIALS').and_return(nil)
+    allow(ENV).to receive(:[]).with('GOOGLE_CLOUD_UNIVERSE_DOMAIN').and_return(nil)
+    allow(ENV).to receive(:[]).with('GOOGLE_CLOUD_PROJECT').and_return(nil)
+    allow(ENV).to receive(:[]).with('GCLOUD_PROJECT').and_return(nil)
+    allow(ENV).to receive(:[]).with('BEAKER_gce_project').and_return(nil)
+    allow(ENV).to receive(:[]).with('BEAKER_gce_ssh_public_key').and_return(nil)
+    allow(ENV).to receive(:[]).with('BEAKER_gce_ssh_private_key').and_return(nil)
+    allow(ENV).to receive(:fetch).with('BEAKER_gce_zone', anything).and_return('us-central1-a')
+    allow(ENV).to receive(:fetch).with('BEAKER_gce_network', anything).and_return('default')
+    allow(ENV).to receive(:fetch).with('BEAKER_gce_subnetwork', anything).and_return(nil)
+    allow(ENV).to receive(:fetch).with('BEAKER_gce_ports', anything).and_return('')
+  end
+
+  describe 'class hierarchy' do
+    it 'inherits from GoogleCompute' do
+      expect(described_class.superclass).to eq(Beaker::GoogleCompute)
+    end
+  end
+
+  describe 'instantiation' do
+    it 'can be instantiated' do
+      expect { described_class.new(hosts, options) }.not_to raise_error
+    end
+  end
+end

data/spec/classes/beaker-google/beaker_google_version_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe BeakerGoogle do
+  describe 'VERSION' do
+    it 'has a version number' do
+      expect(BeakerGoogle::VERSION).not_to be_nil
+    end
+
+    it 'is a string' do
+      expect(BeakerGoogle::VERSION).to be_a(String)
+    end
+
+    it 'follows semantic versioning pattern' do
+      expect(BeakerGoogle::VERSION).to match(/\A\d+\.\d+\.\d+\z/)
+    end
+  end
+end

data/spec/classes/beaker_integration_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Beaker do
+  context 'when testing Google integration' do
+    describe 'basic integration test' do
+      let(:logger) { instance_double(Beaker::Logger) }
+      let(:test_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
+
+      before do
+        mock_google_services
+      end
+
+      it 'loads the beaker-google version' do
+        expect(BeakerGoogle::VERSION).to be_a(String)
+      end
+
+      it 'can create GoogleComputeHelper instances' do
+        expect do
+          Beaker::GoogleComputeHelper.new(test_options)
+        end.not_to raise_error
+      end
+
+      it 'can create GoogleCompute instances' do
+        expect do
+          Beaker::GoogleCompute.new([], test_options)
+        end.not_to raise_error
+      end
+
+      it 'has proper class inheritance' do
+        expect(Beaker::GoogleCompute).to be < Beaker::Hypervisor
+      end
+
+      it 'loads ComputeV1 API' do
+        expect(defined?(Google::Apis::ComputeV1)).to be_truthy
+      end
+
+      it 'loads OsloginV1 API' do
+        expect(defined?(Google::Apis::OsloginV1)).to be_truthy
+      end
+
+      it 'loads Google Auth' do
+        expect(defined?(Google::Auth)).to be_truthy
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require 'rspec/its'
+require 'fakefs/spec_helpers'
+require 'simplecov'
+
+# Start SimpleCov if coverage is enabled
+SimpleCov.start if ENV['BEAKER_GOOGLE_COVERAGE']
+
+# Require beaker first to establish the base classes
+require 'beaker'
+
+# Only require the version module directly
+require 'beaker-google/version'
+
+# Require the hypervisor classes
+require 'beaker/hypervisor/google_compute_helper'
+require 'beaker/hypervisor/google_compute'
+require 'beaker/hypervisor/google'
+
+# Load shared mock classes
+require_relative 'support/shared_mocks'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.disable_monkey_patching!
+  config.warnings = true
+
+  config.default_formatter = 'doc' if config.files_to_run.one?
+
+  config.profile_examples = 10
+  config.order = :random
+
+  Kernel.srand config.seed
+end

data/spec/support/google_compute_shared_setup.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+# Shared setup for Google Compute tests to avoid multiple memoized helpers
+module GoogleComputeSharedSetup
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def setup_google_compute_mocks
+      let(:mock_gce_helper) { instance_double(Beaker::GoogleComputeHelper) }
+      let(:mock_network) { MockNetwork.new }
+      let(:mock_machine_type) { MockMachineType.new }
+      let(:mock_image) { MockImage.new }
+      let(:mock_instance) do
+        instance_double(Google::Apis::ComputeV1::Instance).tap do |instance|
+          allow(instance).to receive(:network_interfaces)
+            .and_return([
+                          instance_double(Google::Apis::ComputeV1::NetworkInterface).tap do |interface|
+                            allow(interface).to receive(:access_configs)
+                              .and_return([
+                                            instance_double(Google::Apis::ComputeV1::AccessConfig).tap do |config|
+                                              allow(config).to receive(:nat_ip).and_return('1.2.3.4')
+                                            end,
+                                          ])
+                          end,
+                        ])
+        end
+      end
+      let(:mock_operation) do
+        instance_double(Google::Apis::ComputeV1::Operation).tap do |operation|
+          allow(operation).to receive(:error).and_return(nil)
+        end
+      end
+
+      let(:logger) { instance_double(Beaker::Logger, debug: nil, info: nil, warn: nil, error: nil) }
+
+      before do
+        # Mock the GoogleComputeHelper initialization to avoid authentication
+        allow(Beaker::GoogleComputeHelper).to receive(:new).and_return(mock_gce_helper)
+
+        # Mock all the GoogleComputeHelper methods
+        allow(mock_gce_helper).to receive_messages(
+          get_network: mock_network,
+          get_machine_type: mock_machine_type,
+          get_image: mock_image,
+          get_latest_image_from_family: mock_image,
+          get_instance: mock_instance,
+          create_firewall: mock_operation,
+          delete_firewall: mock_operation,
+          create_instance: mock_operation,
+          delete_instance: mock_operation,
+          add_instance_tag: mock_operation,
+          set_metadata_on_instance: mock_operation,
+          options: options,
+        )
+
+        # Set up environment variables for testing
+        allow(ENV).to receive(:fetch).and_call_original
+        allow(ENV).to receive(:fetch).with('BEAKER_gce_machine_type', anything).and_return('n1-standard-1')
+        allow(ENV).to receive(:fetch).with('BEAKER_gce_ssh_private_key',
+                                           anything).and_return(File.join(Dir.home, '.ssh', 'google_compute_engine'))
+        allow(ENV).to receive(:fetch).with('BEAKER_gce_zone', anything).and_return('us-central1-a')
+        allow(ENV).to receive(:fetch).with('BEAKER_gce_network', anything).and_return('default')
+        allow(ENV).to receive(:fetch).with('BEAKER_gce_subnetwork', anything).and_return(nil)
+        allow(ENV).to receive(:fetch).with('BEAKER_gce_ports', anything).and_return('80/tcp,443/tcp')
+        allow(ENV).to receive(:[]).with('BEAKER_gce_project').and_return('test-project')
+        allow(ENV).to receive(:[]).with('BEAKER_gce_ssh_public_key').and_return(nil)
+        allow(ENV).to receive(:[]).with('BEAKER_gce_ssh_private_key').and_return(nil)
+
+        # Mock the image disk size
+        allow(mock_image).to receive(:disk_size_gb).and_return(20)
+      end
+    end
+
+    def setup_test_hosts
+      let(:primary_host) do
+        {
+          'name' => 'test-host-1',
+          'user' => 'root',
+          'options' => { 'ssh' => { 'keys' => [] } },
+          'gce_machine_type' => 'n1-standard-1',
+          :image => 'ubuntu-1804-lts',
+          'volume_size' => nil,
+          'disable_root_ssh' => nil,
+        }.tap do |host|
+          # Add methods needed by the gem
+          def host.close; end
+
+          def host.name
+            self['name']
+          end
+
+          def host.options
+            self['options']
+          end
+        end
+      end
+
+      let(:secondary_host) do
+        {
+          'name' => 'test-host-2',
+          'user' => 'root',
+          'options' => { 'ssh' => { 'keys' => [] } },
+          'gce_machine_type' => 'n1-standard-1',
+          :image => 'ubuntu-1804-lts',
+          'volume_size' => nil,
+          'disable_root_ssh' => nil,
+        }.tap do |host|
+          # Add methods needed by the gem
+          def host.close; end
+
+          def host.name
+            self['name']
+          end
+
+          def host.options
+            self['options']
+          end
+        end
+      end
+
+      let(:hosts) { [primary_host, secondary_host] }
+    end
+
+    def setup_test_options
+      let(:options) do
+        {
+          gce_project: 'test-project',
+          gce_zone: 'us-central1-a',
+          gce_network: 'default',
+          gce_ports: ['80/tcp', '443/tcp'],
+          logger: logger,
+        }
+      end
+    end
+  end
+end

data/spec/support/shared_mocks.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+# Add mutex_m requirement for Ruby 3.4.0 compatibility
+begin
+  require 'mutex_m'
+rescue LoadError
+  # mutex_m is not available on all Ruby versions
+end
+
+# Mock external classes that we don't want to test
+class MockNetwork
+  def initialize
+    @name = 'test-network'
+    @self_link = 'https://www.googleapis.com/compute/v1/projects/test-project/global/networks/test-network'
+  end
+
+  attr_reader :name, :self_link
+end
+
+class MockSubnetwork
+  def initialize
+    @name = 'test-subnetwork'
+    @self_link = 'https://www.googleapis.com/compute/v1/projects/test-project/regions/us-central1/subnetworks/test-subnetwork'
+  end
+
+  attr_reader :name, :self_link
+end
+
+class MockMachineType
+  def initialize
+    @name = 'n1-standard-1'
+    @memory_mb = 3840
+    @guest_cpus = 1
+  end
+
+  attr_reader :name, :memory_mb, :guest_cpus
+end
+
+class MockImage
+  def initialize
+    @name = 'test-image'
+    @self_link = 'https://www.googleapis.com/compute/v1/projects/test-project/global/images/test-image'
+    @disk_size_gb = 20
+  end
+
+  attr_reader :name, :self_link, :disk_size_gb
+end
+
+class MockInstance
+  def initialize
+    @name = 'test-instance'
+    @status = 'RUNNING'
+    @tags = MockTags.new
+    @metadata = MockMetadata.new
+    @fingerprint = 'test-fingerprint'
+  end
+
+  attr_reader :name, :status, :tags, :metadata, :fingerprint
+end
+
+class MockTags
+  def initialize
+    @items = []
+    @fingerprint = 'test-fingerprint'
+  end
+
+  attr_reader :items, :fingerprint
+end
+
+class MockMetadata
+  def initialize
+    @items = []
+    @fingerprint = 'test-fingerprint'
+  end
+
+  attr_accessor :items
+  attr_reader :fingerprint
+end
+
+class MockOperation
+  def initialize
+    @name = 'test-operation'
+    @status = 'RUNNING'
+  end
+
+  attr_reader :name, :status
+end