kanrisuru 0.3.2 → 0.5.1

data/spec/functional/core/zypper_spec.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Core::Zypper do
+  TestHosts.each_os(only: %w[sles opensuse]) do |os_name|
+    context "with #{os_name}" do
+      let(:host_json) { TestHosts.host(os_name) }
+      let(:host) do
+        Kanrisuru::Remote::Host.new(
+          host: host_json['hostname'],
+          username: host_json['username'],
+          keys: [host_json['ssh_key']]
+        )
+      end
+
+      after do
+        host.disconnect
+      end
+
+      def find_repo(host, repo_name)
+        repos = host.zypper('repos').data
+        repos.find { |repo| repo.alias == repo_name }
+      end
+
+      it 'lists repos' do
+        result = host.zypper('repos')
+        expect(result).to be_success
+      end
+
+      it 'installs a package' do
+        host.su('root')
+        result = host.zypper('install', packages: 'ffmpeg')
+        expect(result).to be_success
+      end
+
+      it 'installs multiple packages' do
+        host.su('root')
+        result = host.zypper('install', packages: %w[curl ffmpeg])
+        expect(result).to be_success
+      end
+
+      it 'lists updates' do
+        result = host.zypper('list-updates')
+        expect(result).to be_success
+      end
+
+      it 'lists patches' do
+        result = host.zypper('list-patches')
+        expect(result).to be_success
+      end
+
+      it 'lists important and secure patches' do
+        result = host.zypper('list-patches', category: ['security'], severity: %w[important moderate])
+        expect(result).to be_success
+      end
+
+      it 'lists patch check counts' do
+        result = host.zypper('patch-check')
+        expect(result).to be_success
+      end
+
+      it 'updates a package' do
+        host.su('root')
+        result = host.zypper('update', packages: 'curl')
+        expect(result).to be_success
+      end
+
+      it 'gets info for one package' do
+        result = host.zypper('info', packages: 'curl')
+        expect(result).to be_success
+      end
+
+      it 'gets info for multiple packages' do
+        result = host.zypper('info', packages: %w[curl wget git sudo])
+        expect(result).to be_success
+      end
+
+      it 'gets info for type' do
+        result = host.zypper('info', type: 'package', packages: 'gc*')
+        expect(result).to be_success
+      end
+
+      it 'patches system' do
+        host.su('root')
+        result = host.zypper('patch', severity: 'moderate')
+        expect(result).to be_success
+      end
+
+      it 'performs a dist-upgrade' do
+        case os_name
+        when 'opensuse'
+          host.su('root')
+          result = host.zypper('dist-upgrade', dry_run: true)
+          expect(result).to be_success
+        when 'sles'
+          host.su('root')
+          result = host.zypper('dist-upgrade', dry_run: true, auto_agree_with_licenses: true)
+          expect(result).to be_success
+        end
+      end
+
+      it 'searches for single package with match' do
+        result = host.zypper('search', packages: 'gc*', sort_by_name: true)
+        expect(result).to be_success
+      end
+
+      it 'searches for multiple packages' do
+        result = host.zypper('search', packages: %w[nginx ffmpeg], sort_by_repo: true)
+        expect(result).to be_success
+      end
+
+      it 'manages a repo' do
+        repo_alias = 'graphics'
+        if os_name == 'opensuse'
+          repo_name = 'Graphics Project (openSUSE_Leap_15.2)'
+          repo_uri = 'https://download.opensuse.org/repositories/graphics/openSUSE_Leap_15.2/'
+        else
+          repo_name = 'Graphics Project (openSUSE_Leap_15.3)'
+          repo_uri = 'https://download.opensuse.org/repositories/graphics/openSUSE_Leap_15.3/'
+        end
+
+        url = "#{repo_uri}/#{repo_alias}.repo"
+
+        host.su('root')
+        result = host.zypper('addrepo', repos: url)
+        expect(result).to be_success
+
+        repo = find_repo(host, repo_alias)
+
+        expect(repo).to be_instance_of(Kanrisuru::Core::Zypper::Repo)
+        expect(repo.uri).to eq(repo_uri)
+        expect(repo.name).to eq(repo_name)
+
+        new_repo_alias = 'graphics-repo'
+        result = host.zypper('renamerepo', repo: repo_alias, alias: new_repo_alias)
+        expect(result).to be_success
+        repo = find_repo(host, new_repo_alias)
+        expect(repo.alias).to eq(new_repo_alias)
+
+        result = host.zypper('modifyrepo', repos: new_repo_alias, disable: true)
+        expect(result).to be_success
+        repo = find_repo(host, new_repo_alias)
+        expect(repo.enabled).to be_falsey
+
+        result = host.zypper('removerepo', repos: new_repo_alias)
+        expect(result).to be_success
+
+        repo = find_repo(host, new_repo_alias)
+        expect(repo).to be_nil
+      end
+
+      it 'refreshes repos' do
+        host.su('root')
+        result = host.zypper('refresh')
+        expect(result).to be_success
+      end
+
+      it 'cleans repo caches' do
+        host.su('root')
+        result = host.zypper('clean')
+        expect(result).to be_success
+      end
+
+      it 'lists services' do
+        result = host.zypper('services')
+        expect(result).to be_success
+      end
+
+      it 'refreshes services' do
+        host.su('root')
+        result = host.zypper('refresh-services')
+        expect(result).to be_success
+      end
+
+      it 'manages locks' do
+        host.su('root')
+        result = host.zypper('addlock', lock: 'nginx', type: 'package')
+        expect(result).to be_success
+
+        result = host.zypper('locks')
+        expect(result).to be_success
+
+        lock = result.first
+        expect(lock.name).to eq('nginx')
+        expect(lock.type).to eq('package')
+
+        result = host.zypper('removelock', lock: 'nginx')
+        expect(result).to be_success
+      end
+    end
+  end
+end

data/spec/functional/remote/fstab_spec.rb

@@ -82,7 +82,7 @@ RSpec.describe Kanrisuru::Remote::Fstab do
         entry.mount_point = '/mnt/test3'
 
         expect(fstab['/dev/vda14'].to_s).to eq '/dev/vda14 /mnt/test3 ext4 ' \
-          'user,exec,rw,auto,relatime,async,nodev,nosuid,owner,group 0 0'
+                                               'user,exec,rw,auto,relatime,async,nodev,nosuid,owner,group 0 0'
 
         fstab << '/dev/vda16 /mnt/test2 fat defaults,user,uid=1000,gid=1000 0 0'
         expect(fstab['/dev/vda16'].to_s).to eq('/dev/vda16 /mnt/test2 fat defaults,user,uid=1000,gid=1000 0 0')

data/spec/functional/remote/os_spec.rb

@@ -24,7 +24,7 @@ RSpec.describe Kanrisuru::Remote::Os do
 
         case os_name
         when 'opensuse'
-          expect(host.os.release).to eq('opensuse-leap')
+          expect(host.os.release).to eq('opensuse_leap')
         else
           expect(host.os.release).to eq(os_name)
         end

data/spec/helper/test_hosts.rb

@@ -2,9 +2,10 @@
 
 class TestHosts
   class << self
-    def each_os(&block)
+    def each_os(opts = {}, &block)
       %w[debian ubuntu fedora centos rhel opensuse sles].each do |os_name|
         next unless test?(os_name)
+        next if opts[:only] && !only?(opts, os_name)
 
         block.call(os_name)
       end
@@ -14,6 +15,11 @@ class TestHosts
       hosts(name)
     end
 
+    def only?(opts, name)
+      ((opts[:only].instance_of?(Array) && opts[:only].include?(name)) ||
+        (opts[:only].instance_of?(String) && opts[:only] == name))
+    end
+
     def test?(name)
       return false if host(name).nil?
 

data/spec/unit/core/apt_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Core::Apt do
+  it 'responds to apt fields' do
+    expect(Kanrisuru::Core::Apt::Source.new).to respond_to(
+      :url, :dist, :architecture
+    )
+
+    expect(Kanrisuru::Core::Apt::PackageOverview.new).to respond_to(
+      :package, :version, :suites, :architecture, :installed, :upgradeable, :automatic
+    )
+    
+    expect(Kanrisuru::Core::Apt::PackageDetail.new).to respond_to(
+      :package,
+      :version,
+      :priority,
+      :section,
+      :origin,
+      :maintainer,
+      :original_maintainer,
+      :bugs,
+      :install_size,
+      :dependencies,
+      :recommends,
+      :provides,
+      :suggests,
+      :breaks,
+      :conflicts,
+      :replaces,
+      :homepage,
+      :task,
+      :supported,
+      :download_size,
+      :apt_manual_installed,
+      :apt_sources,
+      :description,
+      :summary
+    )
+  end
+end

data/spec/unit/core/archive_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Core::Archive do
+  it 'responds to archive fields' do
+    expect(Kanrisuru::Core::Archive::FilePath.new).to respond_to(
+      :path
+    )
+  end
+end

data/spec/unit/core/disk_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Core::Disk do
+  it 'responds to disk fields' do
+    expect(Kanrisuru::Core::Disk::DiskUsage.new).to respond_to(:fsize, :path)
+    expect(Kanrisuru::Core::Disk::DiskFree.new).to respond_to(
+      :file_system, :type, :total, :used, :capacity, :mount
+    )
+    expect(Kanrisuru::Core::Disk::LsblkDevice.new).to respond_to(
+      :name, :maj_dev, :min_dev, :removable_device, :readonly_device, :owner, :group,
+      :mode, :fsize, :type, :mount_point, :fs_type, :uuid, :children
+    )
+    expect(Kanrisuru::Core::Disk::BlkidDevice.new).to respond_to(
+      :name, :label, :uuid, :type, :uuid_sub, :label_fatboot, :version, :usage,
+      :part_uuid, :part_entry_scheme, :part_entry_uuid, :part_entry_type,
+      :part_entry_number, :part_entry_offset, :part_entry_size, :part_entry_disk
+    )
+  end
+end

data/spec/unit/core/dmi_spec.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Core::Dmi do
+  it 'responds to dmi type fields' do
+    expect(Kanrisuru::Core::Dmi::BIOS.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :vendor, :version, :release_date, :address, :runtime_size,
+      :rom_size, :characteristics, :bios_revision, :firmware_revision
+    )
+    expect(Kanrisuru::Core::Dmi::System.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :manufacturer, :product_name, :version, :serial_number,
+      :uuid, :wake_up_type, :sku_number, :family
+    )
+    expect(Kanrisuru::Core::Dmi::Baseboard.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :type, :manufacturer, :product_name, :version, :serial_number, :asset_tag,
+      :features, :location_in_chassis, :chassis_handle, :contained_object_handles
+    )
+    expect(Kanrisuru::Core::Dmi::Chassis.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :manufacturer, :type, :lock, :version, :serial_number,
+      :asset_tag, :boot_up_state, :power_supply_state, :thermal_state,
+      :security_status, :oem_information, :height, :number_of_power_cords,
+      :contained_elements, :sku_number
+    )
+    expect(Kanrisuru::Core::Dmi::Processor.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :socket_designation, :type, :family, :manufacturer, :id, :signature, :flags,
+      :version, :voltage, :external_clock, :max_speed, :current_speed,
+      :status, :upgrade, :l1_cache_handle, :l2_cache_handle, :l3_cache_handle,
+      :serial_number, :asset_tag, :part_number, :core_count, :core_enabled, :thread_count,
+      :characteristics
+    )
+    expect(Kanrisuru::Core::Dmi::MemoryController.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :error_detecting_method, :error_correcting_capabilities, :supported_interleave,
+      :current_interleave, :maximum_memory_module_size, :maximum_total_memory_size,
+      :supported_seeds, :supported_memory_types, :memory_module_voltage, :associated_memory_slots,
+      :enabled_error_correcting_capabilities
+    )
+    expect(Kanrisuru::Core::Dmi::MemoryModule.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :socket_designation, :bank_connections, :current_speed, :type, :installed_size, :enabled_size,
+      :error_status
+    )
+    expect(Kanrisuru::Core::Dmi::Cache.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :socket_designation, :configuration, :operational_mode, :location,
+      :installed_size, :maximum_size, :supported_sram_types, :installed_sram_type,
+      :speed, :error_correction_type, :system_type, :associativity
+    )
+    expect(Kanrisuru::Core::Dmi::PortConnector.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :internal_reference_designator,
+      :internal_connector_type,
+      :external_reference_designator,
+      :external_connector_type,
+      :port_type
+    )
+    expect(Kanrisuru::Core::Dmi::SystemSlots.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :designation, :type, :current_usage, :slot_length,
+      :id, :characteristics, :bus_address,
+      :data_bus_width, :peer_devices
+    )
+    expect(Kanrisuru::Core::Dmi::OnBoardDevice.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :type, :status, :description
+    )
+    expect(Kanrisuru::Core::Dmi::OEMStrings.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :strings
+    )
+    expect(Kanrisuru::Core::Dmi::SystemConfigurationOptions.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :options
+    )
+    expect(Kanrisuru::Core::Dmi::BIOSLanguage.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :language_description_format, :installed_languages, :currently_installed_language
+    )
+    expect(Kanrisuru::Core::Dmi::GroupAssociation.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :name, :items
+    )
+    expect(Kanrisuru::Core::Dmi::SystemEventLog.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :area_length, :header_start_offset, :header_length, :data_start_offset,
+      :access_method, :change_token, :header_format, :supported_log_type_descriptors,
+      :descriptors
+    )
+    expect(Kanrisuru::Core::Dmi::PhysicalMemoryArray.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :location, :use, :error_correction_type, :maximum_capacity,
+      :error_information_handle, :number_of_devices
+    )
+    expect(Kanrisuru::Core::Dmi::MemoryDevice.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :array_handle, :error_information_handle, :total_width,
+      :data_width, :mem_size, :form_factor, :set, :locator,
+      :bank_locator, :type, :type_detail, :speed,
+      :manufacturer, :serial_number, :asset_tag,
+      :part_number, :rank, :configured_clock_speed,
+      :minimum_voltage, :maximum_voltage, :configured_voltage,
+      :firmware_version, :model_manufacturer_id, :module_product_id,
+      :memory_subsystem_controller_manufacturer_id,
+      :memory_subsystem_controller_product_id,
+      :non_volatile_size, :cache_size, :logical_size
+    )
+    expect(Kanrisuru::Core::Dmi::MemoryError32Bit.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :type, :granularity, :operation, :vendor_syndrome, :memory_array_address,
+      :device_address, :resolution
+    )
+    expect(Kanrisuru::Core::Dmi::MemoryArrayMappedAddress.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :starting_address, :ending_address, :range_size,
+      :physical_array_handle, :partition_width
+    )
+    expect(Kanrisuru::Core::Dmi::MemoryDeviceMappedAddress.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :starting_address, :ending_address, :range_size,
+      :physical_device_handle, :memory_array_mapped_address_handle,
+      :partition_row_position, :interleave_position,
+      :interleaved_data_depth
+    )
+    expect(Kanrisuru::Core::Dmi::BuiltInPointingDevice.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :type, :inteface, :buttons
+    )
+    expect(Kanrisuru::Core::Dmi::PortableBattery.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :location, :manufacturer, :manufacture_date,
+      :serial_number, :name, :chemistry,
+      :design_capacity, :design_voltage, :maximum_error,
+      :sbds_version, :sbds_serial_number, :sbds_manufacturer_date,
+      :sbds_chemistry, :oem_specific_information
+    )
+    expect(Kanrisuru::Core::Dmi::SystemReset.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :status, :watchdog_timer, :boot_option,
+      :boot_option_on_limit, :timer_interval,
+      :reset_count, :reset_limit, :timeout
+    )
+    expect(Kanrisuru::Core::Dmi::HardwareSecurity.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :power_on_password_status, :keyboard_password_status,
+      :administrator_password_status, :front_panel_reset_status
+    )
+    expect(Kanrisuru::Core::Dmi::SystemPowerControls.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :next_scheduled_power_on
+    )
+    expect(Kanrisuru::Core::Dmi::VoltageProbe.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :description, :location, :status, :maximum_value,
+      :minimum_value, :resolution, :tolerance, :accuracy,
+      :oem_specific_information, :nominal_value
+    )
+    expect(Kanrisuru::Core::Dmi::CoolingDevice.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :temperature_probe_handle, :type,
+      :status, :cooling_unit_group, :oem_specific_information,
+      :nominal_speed, :description
+    )
+    expect(Kanrisuru::Core::Dmi::TemperatureProbe.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :description, :location, :status,
+      :maximum_value, :minimum_value, :resolution,
+      :tolerance, :accuracy, :oem_specific_information,
+      :nominal_value
+    )
+    expect(Kanrisuru::Core::Dmi::ElectricalCurrentProbe.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :description, :location, :status,
+      :maximum_value, :minimum_value, :resolution,
+      :tolerance, :accuracy, :oem_specific_information,
+      :nominal_value
+    )
+    expect(Kanrisuru::Core::Dmi::OutOfBandRemoteAccess.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :manufacturer_name, :inbound_connection,
+      :outbound_connection
+    )
+    expect(Kanrisuru::Core::Dmi::BootIntegrityServices.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :checksum,
+      :sixteen_bit_entry_point_address,
+      :thirty_two_bit_entry_point_address
+    )
+    expect(Kanrisuru::Core::Dmi::SystemBoot.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :status
+    )
+    expect(Kanrisuru::Core::Dmi::MemoryError64Bit.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :type, :granularity, :operation, :vendor_syndrome, :memory_array_address,
+      :device_address, :resolution
+    )
+    expect(Kanrisuru::Core::Dmi::ManagementDevice.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :description, :type, :address, :address_type
+    )
+    expect(Kanrisuru::Core::Dmi::ManagementDeviceComponent.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :description, :management_device_handle, :component_handle,
+      :threshold_handle
+    )
+    expect(Kanrisuru::Core::Dmi::ManagementDeviceThresholdData.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :lower_non_critical_threshold,
+      :upper_non_critical_threshold,
+      :lower_critical_threshold,
+      :upper_critical_threshold,
+      :lower_non_recoverable_threshold,
+      :upper_non_recoverable_threshold
+    )
+    expect(Kanrisuru::Core::Dmi::MemoryChannelDevice.new).to respond_to(
+      :load,
+      :handle
+    )
+    expect(Kanrisuru::Core::Dmi::MemoryChannel.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :type, :maximal_load, :devices
+    )
+    expect(Kanrisuru::Core::Dmi::IPMIDevice.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :interface_type, :specification_version, :i2c_slave_address,
+      :nv_storage_device_address, :nv_storage_device, :base_address, :register_spacing,
+      :interrupt_polarity, :interrupt_trigger_mode, :interrupt_number
+    )
+    expect(Kanrisuru::Core::Dmi::SystemPowerSupply.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :power_unit_group, :location, :name,
+      :manufacturer, :serial_number, :asset_tag, :model_part_number,
+      :revision, :max_power_capacity, :status,
+      :type, :input_voltage_range_switching,
+      :plugged, :hot_replaceable,
+      :input_voltage_probe_handle,
+      :cooling_device_handle,
+      :input_current_probe_handle
+    )
+    expect(Kanrisuru::Core::Dmi::AdditionalInformation.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :referenced_handle, :referenced_offset,
+      :string, :value
+    )
+    expect(Kanrisuru::Core::Dmi::OnboardDevicesExtendedInformation.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :reference_designation, :type, :status,
+      :type_instance, :bus_address
+    )
+    expect(Kanrisuru::Core::Dmi::ProtocolRecord.new).to respond_to(
+      :protocol_id,
+      :protocol_type_specific_data
+    )
+    expect(Kanrisuru::Core::Dmi::ManagementControllerHostInterface.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :interface_type, :vendor_id, :device_type,
+      :protocol_records, :host_ip_assignment_type, :host_ip_address_format
+    )
+    expect(Kanrisuru::Core::Dmi::TPMDevice.new).to respond_to(
+      :dmi_type, :dmi_handle, :dmi_size,
+      :specification_version, :firmware_revision,
+      :description, :characteristics, :oem_specific_information
+    )
+  end
+end