kanrisuru 0.11.1 → 0.14.0

data/spec/integration/core/zypper_spec.rb

@@ -1,199 +0,0 @@
-# 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: 'nginx')
-        expect(result).to be_success
-      end
-
-      it 'installs multiple packages' do
-        host.su('root')
-        result = host.zypper('install', packages: %w[curl nginx])
-        expect(result).to be_success
-      end
-
-      it 'removes a package' do
-        host.su('root')
-        result = host.zypper('remove', packages: ['nginx'])
-        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/integration/remote/cpu_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Kanrisuru::Remote::Cpu do
-  TestHosts.each_os 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
-
-      it 'gets cpu details' do
-        expect(host.cpu.cores).to eq(1)
-        expect(host.cpu.total).to eq(1)
-        expect(host.cpu.count).to eq(1)
-
-        expect(host.cpu.threads_per_core).to eq(1)
-        expect(host.cpu.cores_per_socket).to eq(1)
-        expect(host.cpu.sockets).to eq(1)
-
-        expect(host.cpu.hyperthreading?).to eq(false)
-      end
-
-      it 'gets cpu load average' do
-        expect(host.cpu.load_average).to be_instance_of(Array)
-        expect(host.cpu.load_average1).to be_instance_of(Float)
-        expect(host.cpu.load_average5).to be_instance_of(Float)
-        expect(host.cpu.load_average15).to be_instance_of(Float)
-      end
-    end
-  end
-end

data/spec/integration/remote/env_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Kanrisuru::Remote::Env do
-  TestHosts.each_os 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
-
-      it 'sets env var' do
-        host.env['HELLO'] = 'world'
-        host.env['KANRISURU'] = 'manage'
-
-        expect(host.env['KANRISURU']).to eq('manage')
-        expect(host.env.to_s).to eq('export HELLO=world; export KANRISURU=manage;')
-        expect(host.env.to_h).to eq({ 'HELLO' => 'world', 'KANRISURU' => 'manage' })
-
-        command = Kanrisuru::Command.new('echo $KANRISURU $HELLO')
-        host.execute_shell(command)
-
-        expect(command.to_s).to eq('manage world')
-      end
-    end
-  end
-end

data/spec/integration/remote/fstab_spec.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Kanrisuru::Remote::Fstab do
-  TestHosts.each_os 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
-
-      it 'outputs string version of fstab' do
-        host.su('root')
-
-        result = host.cat('/etc/fstab')
-        expect(result).to be_success
-        raw_file_lines = []
-        result.each do |line|
-          next if line.match(/^#/) || line == ''
-
-          raw_file_lines << line.split.join(' ')
-        end
-
-        raw_file_output = raw_file_lines.join("\n")
-        expect(raw_file_output).to eq(host.fstab.to_s)
-      end
-
-      it 'parses fstab' do
-        host.su('root')
-        fstab = host.fstab
-
-        entry =
-          case os_name
-          when 'opensuse'
-            fstab['/dev/vda3']
-          when 'sles'
-            fstab['/dev/xvda1']
-          else
-            fstab['/dev/vda1']
-          end
-
-        expect(fstab.get_entry(entry.uuid)).to eq(entry)
-        expect(fstab.get_entry(entry.label)).to eq(entry)
-
-        fstab << Kanrisuru::Remote::Fstab::Entry.new(
-          device: '/dev/vda14',
-          mount_point: '/mnt/test',
-          type: 'ext4',
-          opts: { defaults: true },
-          freq: '0',
-          passno: '0'
-        )
-
-        entry = fstab['/dev/vda14']
-        expect(entry.to_s).to eq('/dev/vda14 /mnt/test ext4 defaults 0 0')
-        expect(entry.device).to eq('/dev/vda14')
-        expect(entry.mount_point).to eq('/mnt/test')
-        expect(entry.type).to eq('ext4')
-        expect(entry.opts.to_s).to eq('defaults')
-        expect(entry.freq).to eq('0')
-        expect(entry.passno).to eq('0')
-
-        entry.opts['defaults'] = false
-        entry.opts['user'] = true
-        entry.opts['exec'] = true
-        entry.opts['rw'] = true
-        entry.opts['auto'] = true
-        entry.opts['relatime'] = true
-        entry.opts['async'] = true
-        entry.opts[:nodev] = true
-        entry.opts[:nosuid] = true
-        entry.opts[:owner] = true
-        entry.opts[:group] = true
-
-        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'
-
-        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')
-      end
-    end
-  end
-end

data/spec/integration/remote/host_spec.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Kanrisuru::Remote::Host do
-  TestHosts.each_os do |os_name|
-    context "with #{os_name}" do
-      let(:host_json) { TestHosts.host(os_name) }
-      let(:host) do
-        described_class.new(
-          host: host_json['hostname'],
-          username: host_json['username'],
-          keys: [host_json['ssh_key']]
-        )
-      end
-
-      after do
-        host.disconnect
-      end
-
-      it 'can ping localhost' do
-        expect(host.ping?).to eq(true)
-      end
-
-      it 'gets hostname' do
-        expect(host.hostname).to eq(host_json['hostname'])
-      end
-
-      it 'changes directories' do
-        expect(host.pwd.path).to eq(host_json['home'])
-
-        host.cd('../')
-        expect(host.pwd.path).to eq('/home')
-
-        host.cd('../')
-        expect(host.pwd.path).to eq('/')
-
-        host.cd('~')
-
-        expect(host.pwd.path).to eq(host_json['home'])
-
-        host.su('root')
-        host.cd('/root/../etc')
-
-        result = host.ls
-        paths = result.map(&:path)
-
-        expect(paths).to include('hosts')
-        expect(paths).to include('shadow')
-        expect(paths).to include('ssh')
-
-        host.cd('default')
-        expect(host.pwd.path).to eq('/etc/default')
-
-        host.su(host_json['username'])
-
-        host.cd('.')
-        expect(host.pwd.path).to eq('/etc/default')
-
-        result = host.ls(path: '/home')
-        expect(result[0].path).to eq(host_json['username'])
-
-        host.cd('/bin')
-        expect(host.pwd.path).to eq('/bin')
-      end
-    end
-  end
-end

data/spec/integration/remote/memory_spec.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Kanrisuru::Remote::Memory do
-  TestHosts.each_os 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
-
-      it 'gets memory details' do
-        expect(host.memory.total(:gb)).to be >= 0.5
-        expect(host.memory.free(:mb)).to be >= 10.0
-        expect(host.memory.swap).to be_instance_of(Integer)
-        expect(host.memory.swap_free).to be_instance_of(Integer)
-      end
-    end
-  end
-end

data/spec/integration/remote/os_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Kanrisuru::Remote::Os do
-  TestHosts.each_os 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
-
-      it 'detects os specs' do
-        expect(host.os.kernel).to eq(host_json['kernel'])
-        expect(host.os.processor).to eq('x86_64')
-
-        case os_name
-        when 'opensuse'
-          expect(host.os.release).to eq('opensuse_leap')
-        else
-          expect(host.os.release).to eq(os_name)
-        end
-
-        expect(host.os.version).to be > 0.00
-
-        case os_name
-        when 'debian'
-          expect(host.os.version).to eq(10)
-        when 'ubuntu'
-          expect(host.os.version).to eq(18.04)
-        when 'fedora'
-          expect(host.os.version).to eq(32)
-        when 'centos'
-          expect(host.os.version).to eq(7)
-        when 'opensuse'
-          expect(host.os.version).to eq(15.2)
-        when 'rhel'
-          expect(host.os.version).to eq(7.9)
-        end
-      end
-
-      it 'gets uname' do
-        expect(host.os.uname).to eq(host_json['kernel'])
-      end
-
-      it 'gets uname details' do
-        host.os.uname(
-          kernel_name: true,
-          hardware_platform: true,
-          operating_system: true
-        )
-      end
-    end
-  end
-end