foreman_google 3.0.8 → 3.1.1

data/test/models/foreman_google/gce_test.rb

@@ -2,7 +2,7 @@ require 'test_google_helper'
 
 module ForemanGoogle
   class GCETest < GoogleTestCase
-    subject { ForemanGoogle::GCE.new(zone: 'zone', password: gauth_json) }
+    subject { ForemanGoogle::GCE.new(zone: 'us-east1-b', password: gauth_json) }
     let(:service) { mock('GoogleAdapter') }
 
     let(:instance_args) do
@@ -18,6 +18,142 @@ module ForemanGoogle
       service.stubs(:project_id).returns('project_id')
     end
 
+    describe '#to_label' do
+      it 'includes name, zone, and provider' do
+        subject.name = 'my-gce'
+        expected = 'my-gce (us-east1-b-Google)'
+        assert_equal expected, subject.to_label
+      end
+    end
+
+    describe '#capabilities' do
+      it 'returns image and new_volume' do
+        assert_equal %i[image new_volume], subject.capabilities
+      end
+    end
+
+    describe '#provided_attributes' do
+      it 'includes ip mapped to vm_ip_address' do
+        attrs = subject.provided_attributes
+        assert_equal :vm_ip_address, attrs[:ip]
+      end
+    end
+
+    describe '#user_data_supported?' do
+      it 'returns true' do
+        assert subject.user_data_supported?
+      end
+    end
+
+    describe '#zone' do
+      it 'reads from url attribute' do
+        subject.url = 'us-central1-a'
+        assert_equal 'us-central1-a', subject.zone
+      end
+    end
+
+    describe '#zone=' do
+      it 'writes to url attribute' do
+        subject.zone = 'europe-west1-b'
+        assert_equal 'europe-west1-b', subject.url
+      end
+    end
+
+    describe 'validations' do
+      it 'is valid with name, zone, and password' do
+        subject.name = 'test-gce'
+        assert subject.valid?, "Expected subject to be valid, got errors: #{subject.errors.full_messages}"
+      end
+
+      it 'requires password' do
+        cr = ForemanGoogle::GCE.new(zone: 'us-east1-b', password: nil)
+        assert_not cr.valid?
+        assert_includes cr.errors.attribute_names, :password
+      end
+
+      it 'requires zone' do
+        cr = ForemanGoogle::GCE.new(zone: nil, password: gauth_json)
+        assert_not cr.valid?
+        assert_includes cr.errors.attribute_names, :zone
+      end
+
+      it 'requires name' do
+        cr = ForemanGoogle::GCE.new(name: nil, zone: 'us-east1-b', password: gauth_json)
+        assert_not cr.valid?
+        assert_includes cr.errors.attribute_names, :name
+      end
+    end
+
+    describe '#zones' do
+      it 'returns zone names from client' do
+        zones = [OpenStruct.new(name: 'us-east1-b'), OpenStruct.new(name: 'us-west1-a')]
+        service.expects(:zones).returns(zones)
+        assert_equal %w[us-east1-b us-west1-a], subject.zones
+      end
+
+      it 'is aliased as available_zones' do
+        zones = [OpenStruct.new(name: 'us-east1-b')]
+        service.expects(:zones).returns(zones)
+        assert_equal %w[us-east1-b], subject.available_zones
+      end
+    end
+
+    describe '#networks' do
+      it 'returns network names from client' do
+        networks = [OpenStruct.new(name: 'default'), OpenStruct.new(name: 'custom')]
+        service.expects(:networks).returns(networks)
+        assert_equal %w[default custom], subject.networks
+      end
+    end
+
+    describe '#available_networks' do
+      it 'returns full network objects from client' do
+        network_objects = [OpenStruct.new(name: 'default')]
+        service.expects(:networks).returns(network_objects)
+        assert_equal network_objects, subject.available_networks
+      end
+    end
+
+    describe '#machine_types' do
+      it 'returns machine types for the zone from client' do
+        types = [OpenStruct.new(name: 'e2-micro')]
+        service.expects(:machine_types).with('us-east1-b').returns(types)
+        assert_equal types, subject.machine_types
+      end
+
+      it 'is aliased as available_flavors' do
+        types = [OpenStruct.new(name: 'n1-standard-1')]
+        service.expects(:machine_types).with('us-east1-b').returns(types)
+        assert_equal types, subject.available_flavors
+      end
+    end
+
+    describe '#available_images' do
+      it 'delegates to client.images with filter' do
+        images = [OpenStruct.new(name: 'centos-7')]
+        service.expects(:images).with(filter: nil).returns(images)
+        assert_equal images, subject.available_images
+      end
+
+      it 'passes custom filter to client' do
+        images = [OpenStruct.new(name: 'centos-7')]
+        service.expects(:images).with(filter: 'name = "centos"').returns(images)
+        assert_equal images, subject.available_images(filter: 'name = "centos"')
+      end
+    end
+
+    describe '#filter_for_images' do
+      it 'defaults to nil' do
+        assert_nil subject.filter_for_images
+      end
+    end
+
+    describe '#google_project_id' do
+      it 'delegates to client' do
+        assert_equal 'project_id', subject.google_project_id
+      end
+    end
+
     describe '#find_vm_by_uuid' do
       it 'does query gce' do
         instance = OpenStruct.new(**instance_args)
@@ -48,11 +184,29 @@ module ForemanGoogle
       end
 
       it 'iteration over the vms array' do
-        subject.vms.each_with_index { |instance, i| assert instance.name, instances[i].name }
+        subject.vms.each_with_index { |instance, i| assert_equal instances[i].name, instance.name }
       end
 
       it 'all method' do
-        subject.vms.all.each_with_index { |instance, i| assert instance.name, instances[i].name }
+        subject.vms.all.each_with_index { |instance, i| assert_equal instances[i].name, instance.name }
+      end
+    end
+
+    describe '#new_vm' do
+      it 'assigns provided attributes' do
+        vm = subject.new_vm(name: 'test-vm', machine_type: 'e2-micro')
+        assert_equal 'test-vm', vm.name
+        assert_equal 'e2-micro', vm.machine_type
+      end
+
+      it 'converts volumes_attributes nested hash' do
+        attrs = {
+          'name' => 'test-vm',
+          'volumes_attributes' => { '0' => { 'size_gb' => '20' } },
+        }
+        vm = subject.new_vm(attrs)
+        assert_equal 1, vm.volumes.size
+        assert_equal 20, vm.volumes.first.size_gb
       end
     end
 
@@ -65,5 +219,123 @@ module ForemanGoogle
         value { subject.create_vm({ image_id: 0 }) }.must_raise(::Foreman::Exception)
       end
     end
+
+    describe '#create_vm success path' do
+      let(:os_image) { OpenStruct.new(username: 'gce_user', name: 'centos-7') }
+      let(:gce_image) { OpenStruct.new(id: 42, self_link: 'image-link') }
+      let(:key_pair_obj) { OpenStruct.new(public: 'ssh-rsa AAAA') }
+      let(:vm) { mock('GoogleCompute') }
+
+      setup do
+        service.stubs(:image).returns(gce_image)
+        service.stubs(:instance)
+        subject.stubs(:images).returns(stub(find_by: os_image))
+        subject.stubs(:key_pair).returns(key_pair_obj)
+        subject.stubs(:new_vm).returns(vm)
+        vm.stubs(:hostname).returns('test-vm')
+
+        vm.expects(:create_volumes)
+        vm.expects(:create_instance)
+        vm.expects(:set_disk_auto_delete)
+      end
+
+      it 'creates volumes, instance, and sets auto-delete' do
+        result = subject.create_vm({ image_id: 42 })
+        assert_kind_of ForemanGoogle::GoogleCompute, result
+      end
+    end
+
+    describe '#create_vm rollback on error' do
+      let(:os_image) { OpenStruct.new(username: 'gce_user', name: 'centos-7') }
+      let(:gce_image) { OpenStruct.new(id: 42, self_link: 'image-link') }
+      let(:key_pair_obj) { OpenStruct.new(public: 'ssh-rsa AAAA') }
+      let(:vm) { mock('GoogleCompute') }
+
+      setup do
+        subject.stubs(:images).returns(stub(find_by: os_image))
+        service.stubs(:image).returns(gce_image)
+        subject.stubs(:key_pair).returns(key_pair_obj)
+        subject.stubs(:new_vm).returns(vm)
+        vm.stubs(:create_volumes).raises(::Google::Cloud::Error.new('quota exceeded'))
+
+        vm.expects(:destroy_volumes)
+      end
+
+      it 'destroys volumes and raises WrappedException' do
+        assert_raises(Foreman::WrappedException) { subject.create_vm({ image_id: 42 }) }
+      end
+    end
+
+    describe '#destroy_vm' do
+      it 'calls set_disk_auto_delete and delete_instance' do
+        service.expects(:set_disk_auto_delete).with('us-east1-b', 'vm-uuid')
+        service.expects(:delete_instance).with('us-east1-b', 'vm-uuid')
+        subject.destroy_vm('vm-uuid')
+      end
+
+      it 'returns true when VM not found' do
+        service.expects(:set_disk_auto_delete).raises(ActiveRecord::RecordNotFound)
+        assert subject.destroy_vm('missing-vm')
+      end
+    end
+
+    describe '#new_volume' do
+      it 'returns an AttachedDisk with 20 GB default' do
+        vol = subject.new_volume
+        assert_kind_of Google::Cloud::Compute::V1::AttachedDisk, vol
+        assert_equal 20, vol.disk_size_gb
+      end
+
+      it 'merges provided attributes' do
+        vol = subject.new_volume(device_name: 'boot-disk')
+        assert_equal 'boot-disk', vol.device_name
+        assert_equal 20, vol.disk_size_gb
+      end
+    end
+
+    describe '#console' do
+      let(:vm) { mock('GoogleCompute') }
+
+      setup do
+        subject.stubs(:find_vm_by_uuid).returns(vm)
+      end
+
+      it 'returns serial output when VM is ready' do
+        vm.stubs(:ready?).returns(true)
+        vm.stubs(:serial_port_output).returns('boot log...')
+        vm.stubs(:name).returns('test-vm')
+
+        result = subject.console('test-vm')
+        assert_equal 'boot log...', result['output']
+        assert_equal 'log', result[:type]
+        assert_equal 'test-vm', result[:name]
+        assert result['timestamp'].is_a?(Time)
+      end
+
+      it 'raises when VM is not ready' do
+        vm.stubs(:ready?).returns(false)
+        assert_raises(::Foreman::Exception) { subject.console('test-vm') }
+      end
+    end
+
+    describe '#associated_host' do
+      it 'calls associate_by with ip addresses' do
+        vm = OpenStruct.new(public_ip_address: '1.2.3.4', private_ip_address: '10.0.0.1')
+        subject.expects(:associate_by).with('ip', ['1.2.3.4', '10.0.0.1'])
+        subject.associated_host(vm)
+      end
+    end
+
+    describe '#vm_ready' do
+      it 'polls until vm is ready' do
+        vm = mock('GoogleCompute')
+        vm.stubs(:reload).returns(vm)
+        vm.stubs(:ready?).returns(false, true)
+        vm.stubs(:wait_for).yields.returns({ duration: 2 })
+
+        result = subject.vm_ready(vm)
+        assert_equal({ duration: 2 }, result)
+      end
+    end
   end
 end

data/test/models/foreman_google/google_compute_test.rb

@@ -194,20 +194,209 @@ module ForemanGoogle
 
     it '@network' do
       cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone)
-      assert cr.network, 'default'
+      assert_equal 'default', cr.network
 
       cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone, args: { network: 'my-network' })
-      assert cr.network, 'my-network'
+      assert_equal 'my-network', cr.network
     end
 
     it '@zone' do
       cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone)
-      assert zone, cr.zone
+      assert_equal zone, cr.zone
     end
 
     it '@zone_name' do
       cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone, instance: instance)
-      assert zone, cr.zone_name
+      assert_equal zone, cr.zone_name
+    end
+
+    describe '#status' do
+      it 'returns status when persisted' do
+        instance.status = 'RUNNING'
+        client.expects(:instance).with(zone, identity).returns(instance)
+        assert_equal 'RUNNING', subject.status
+      end
+
+      it 'returns false when not persisted' do
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone)
+        assert_not cr.status
+      end
+    end
+
+    describe '#state' do
+      it 'is an alias for status' do
+        instance.status = 'TERMINATED'
+        client.expects(:instance).with(zone, identity).returns(instance)
+        assert_equal subject.status, subject.state
+      end
+    end
+
+    describe '#start' do
+      it 'delegates to client.start when persisted' do
+        client.stubs(:instance).with(zone, identity).returns(instance)
+        client.expects(:start).with(zone, identity).returns(true)
+        subject.start
+      end
+
+      it 'raises when not persisted' do
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone)
+        assert_raises(Foreman::Exception) { cr.start }
+      end
+    end
+
+    describe '#stop' do
+      it 'delegates to client.stop when persisted' do
+        client.stubs(:instance).with(zone, identity).returns(instance)
+        client.expects(:stop).with(zone, identity).returns(true)
+        subject.stop
+      end
+
+      it 'raises when not persisted' do
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone)
+        assert_raises(Foreman::Exception) { cr.stop }
+      end
+    end
+
+    describe '#to_s' do
+      it 'returns the name' do
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone, args: { name: 'my-vm' })
+        assert_equal 'my-vm', cr.to_s
+      end
+    end
+
+    describe '#interfaces' do
+      it 'returns network_interfaces' do
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone)
+        assert_equal cr.network_interfaces, cr.interfaces
+      end
+    end
+
+    describe '#vm_description' do
+      it 'delegates to pretty_machine_type' do
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone, instance: instance)
+        assert_equal cr.pretty_machine_type, cr.vm_description
+      end
+    end
+
+    describe '#vm_ip_address - no network interfaces' do
+      it 'returns nil' do
+        empty_instance = OpenStruct.new(
+          name: 'instance', network_interfaces: [],
+          creation_timestamp: Time.zone.now, zone: zone,
+          machine_type: 'machineTypes/e2-micro'
+        )
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone, instance: empty_instance)
+        assert_nil cr.vm_ip_address
+      end
+    end
+
+    describe '#private_ip_address - no network interfaces' do
+      it 'returns nil' do
+        empty_instance = OpenStruct.new(
+          name: 'instance', network_interfaces: [],
+          creation_timestamp: Time.zone.now, zone: zone,
+          machine_type: 'machineTypes/e2-micro'
+        )
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone, instance: empty_instance)
+        assert_nil cr.private_ip_address
+      end
+    end
+
+    describe '#pretty_image_name - no disks' do
+      it 'returns nil' do
+        instance.disks = []
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone, instance: instance)
+        assert_nil cr.pretty_image_name
+      end
+    end
+
+    describe '#ip_addresses' do
+      it 'returns public and private IP' do
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone, instance: instance)
+        assert_equal ['1.2.3.4', '10.10.10.23'], cr.ip_addresses
+      end
+    end
+
+    describe '#serial_port_output' do
+      it 'delegates to client' do
+        client.stubs(:instance).with(zone, identity).returns(instance)
+        client.expects(:serial_port_output).with(zone, identity).returns(OpenStruct.new(contents: 'boot log'))
+        assert_equal 'boot log', subject.serial_port_output
+      end
+
+      it 'returns nil when client returns nil' do
+        client.stubs(:instance).with(zone, identity).returns(instance)
+        client.expects(:serial_port_output).with(zone, identity).returns(nil)
+        assert_nil subject.serial_port_output
+      end
+    end
+
+    describe '#volumes_attributes=' do
+      it 'is a no-op' do
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone)
+        cr.volumes_attributes = { '0' => { size_gb: 10 } }
+        assert cr.volumes.any?
+      end
+    end
+
+    describe '#reload - without identity' do
+      it 'returns nil' do
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone)
+        assert_nil cr.reload
+      end
+    end
+
+    describe '#create_volumes' do
+      it 'inserts disks and waits for READY' do
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone, args: { volumes: [{ size_gb: '20' }] })
+
+        client.expects(:insert_disk).with(zone, cr.volumes.first.insert_attrs)
+        client.expects(:disk).with(zone, cr.volumes.first.device_name).returns(OpenStruct.new(status: 'READY'))
+        client.expects(:wait_for).yields.returns({ duration: 1 })
+
+        cr.create_volumes
+      end
+    end
+
+    describe '#destroy_volumes' do
+      it 'deletes each volume disk' do
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone, args: { volumes: [{ size_gb: '20' }] })
+        client.expects(:delete_disk).with(zone, cr.volumes.first.device_name)
+        cr.destroy_volumes
+      end
+    end
+
+    describe '#create_instance' do
+      it 'calls insert_instance via ComputeAttributes' do
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone, args: { name: 'test-vm', machine_type: 'e2-micro' })
+        client.expects(:insert_instance).with(zone, has_key(:name))
+        cr.create_instance
+      end
+    end
+
+    describe '#set_disk_auto_delete' do
+      it 'delegates to client' do
+        args = { name: 'my-vm' }
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone, args: args)
+        client.expects(:set_disk_auto_delete).with(zone, 'my-vm')
+        cr.set_disk_auto_delete
+      end
+    end
+
+    describe '#wait_for' do
+      it 'delegates to client.wait_for' do
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone)
+        client.expects(:wait_for).yields.returns({ duration: 0 })
+        result = cr.wait_for { true }
+        assert_equal({ duration: 0 }, result)
+      end
+    end
+
+    describe '#public_ip_address' do
+      it 'is an alias for vm_ip_address' do
+        cr = ForemanGoogle::GoogleCompute.new(client: client, zone: zone, instance: instance)
+        assert_equal cr.vm_ip_address, cr.public_ip_address
+      end
     end
   end
 end

data/test/unit/foreman_google/google_compute_adapter_test.rb

@@ -131,7 +131,7 @@ module ForemanGoogle
 
         result = subject.insert_instance('us-east1-b', args)
 
-        assert 'insert', result.operation.operation_type
+        assert_equal 'insert', result.operation.operation_type
         assert_includes result.operation.target_link, 'foreman-test-google'
       end
 
@@ -156,14 +156,14 @@ module ForemanGoogle
         stub_request(:post, 'https://compute.googleapis.com/compute/v1/projects/coastal-haven-123456/zones/us-east1-b/instances/instance_name/start')
           .to_return(status: 200, body: File.read(File.join(__dir__, '..', '..', 'fixtures', 'instance_start.json')))
         result = subject.start('us-east1-b', 'instance_name')
-        assert 'start', result.operation.operation_type
+        assert_equal 'start', result.operation.operation_type
       end
 
       it '#stop' do
         stub_request(:post, 'https://compute.googleapis.com/compute/v1/projects/coastal-haven-123456/zones/us-east1-b/instances/instance_name/stop')
           .to_return(status: 200, body: File.read(File.join(__dir__, '..', '..', 'fixtures', 'instance_stop.json')))
         result = subject.stop('us-east1-b', 'instance_name')
-        assert 'stop', result.operation.operation_type
+        assert_equal 'stop', result.operation.operation_type
       end
 
       it '#set_disk_auto_delete' do
@@ -174,7 +174,7 @@ module ForemanGoogle
           .to_return(status: 200, body: File.read(File.join(__dir__, '..', '..', 'fixtures', 'instance_set_disk_auto_delete.json')))
         result = subject.set_disk_auto_delete('us-east1-b', 'instance_name')
 
-        assert 'device-1', result[0].source
+        assert_equal 'instance-1', result[0].device_name
         assert result[0].auto_delete
       end
     end
@@ -186,14 +186,14 @@ module ForemanGoogle
 
         result = subject.insert_disk('us-east1-b', { name: 'foreman-disk1', size_gb: 23 })
         assert_includes result.operation.target_link, 'foreman-disk1'
-        assert 'insert', result.operation.operation_type
+        assert_equal 'insert', result.operation.operation_type
       end
 
       it '#get' do
         stub_request(:get, 'https://compute.googleapis.com/compute/v1/projects/coastal-haven-123456/zones/us-east1-b/disks/foreman-disk1')
           .to_return(status: 200, body: File.read(File.join(__dir__, '..', '..', 'fixtures', 'disks_get.json')))
         result = subject.disk('us-east1-b', 'foreman-disk1')
-        assert 'foreman-disk1', result.name
+        assert_equal 'foreman-disk1', result.name
       end
 
       it '#delete' do
@@ -202,7 +202,59 @@ module ForemanGoogle
         result = subject.delete_disk('us-east1-b', 'foreman-disk1')
 
         assert_includes result.operation.target_link, 'foreman-disk1'
-        assert 'delete', result.operation.operation_type
+        assert_equal 'delete', result.operation.operation_type
+      end
+    end
+
+    describe '#delete_instance' do
+      it 'deletes an instance' do
+        stub_request(:delete, 'https://compute.googleapis.com/compute/v1/projects/coastal-haven-123456/zones/us-east1-b/instances/instance_name')
+          .to_return(status: 200, body: File.read(File.join(__dir__, '..', '..', 'fixtures', 'instance_stop.json')))
+        result = subject.delete_instance('us-east1-b', 'instance_name')
+        assert_equal 'stop', result.operation.operation_type
+      end
+    end
+
+    describe '#image' do
+      setup do
+        stub_request(:get, 'https://compute.googleapis.com/compute/v1/projects/coastal-haven-123456/global/images')
+          .to_return(body: File.read(File.join(__dir__, '..', '..', 'fixtures', 'images_coastal.json')))
+      end
+
+      it 'finds image by numeric id' do
+        subject.stub(:all_projects, []) do
+          result = subject.image(1)
+          assert_equal 'coastal-image', result.name
+        end
+      end
+
+      it 'returns nil when image not found' do
+        subject.stub(:all_projects, []) do
+          assert_nil subject.image(999)
+        end
+      end
+    end
+
+    describe '#serial_port_output' do
+      it 'returns serial port output' do
+        body = { contents: 'boot log output', next: 12_345, start: 0, selfLink: 'self-link' }.to_json
+        stub_request(:get, 'https://compute.googleapis.com/compute/v1/projects/coastal-haven-123456/zones/us-east1-b/instances/instance_name/serialPort')
+          .to_return(status: 200, body: body)
+        result = subject.serial_port_output('us-east1-b', 'instance_name')
+        assert_equal 'boot log output', result.contents
+      end
+    end
+
+    describe '#project_id' do
+      it 'returns the project_id from auth JSON' do
+        assert_equal 'coastal-haven-123456', subject.project_id
+      end
+    end
+
+    describe '#wait_for' do
+      it 'returns immediately when block yields true' do
+        result = subject.wait_for { true }
+        assert result[:duration] <= 1
       end
     end
   end