kanrisuru 0.12.1 → 0.16.0

data/spec/integration/core/apt_spec.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-TestHosts.each_os(only: %w[debian ubuntu]) do |os_name, host_json|
-  RSpec.describe Kanrisuru::Core::Apt do
-    context "with #{os_name}" do
-      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 'installs package' do
-        host.su('root')
-        result = host.apt('install', packages: %w[ffmpeg curl])
-        expect(result).to be_success
-
-        result = host.which('ffmpeg')
-        expect(result).to be_success
-        paths = result.map(&:path)
-        expect(paths).to include(match('ffmpeg'))
-
-        result = host.which('curl')
-        expect(result).to be_success
-        paths = result.map(&:path)
-        expect(paths).to include(match('curl'))
-      end
-
-      it 'removes installed packages' do
-        host.su('root')
-        result = host.apt('remove', packages: ['ffmpeg'])
-        expect(result).to be_success
-      end
-
-      it 'purges installed packages' do
-        host.su('root')
-        result = host.apt('purge', packages: ['ffmpeg'])
-        expect(result).to be_success
-      end
-
-      it 'removes unused packages' do
-        host.su('root')
-        result = host.apt('autoremove')
-        expect(result).to be_success
-      end
-
-      it 'cleans packages' do
-        host.su('root')
-        result = host.apt('clean')
-        expect(result).to be_success
-      end
-
-      it 'autocleans packages' do
-        host.su('root')
-        result = host.apt('autoclean')
-        expect(result).to be_success
-      end
-
-      it 'updates packages' do
-        host.su('root')
-        result = host.apt('update')
-        expect(result).to be_success
-      end
-
-      it 'upgrades packages' do
-        host.su('root')
-        result = host.apt('upgrade')
-        expect(result).to be_success
-      end
-
-      it 'fully upgrades packages' do
-        host.su('root')
-        result = host.apt('full-upgrade')
-        expect(result).to be_success
-      end
-
-      it 'shows details of listed packages' do
-        result = host.apt('show', packages: %w[wget curl git sudo])
-        expect(result).to be_success
-      end
-
-      it 'lists all packages' do
-        host.su('root')
-        result = host.apt('list')
-        expect(result).to be_success
-      end
-
-      it 'lists installed packages' do
-        host.su('root')
-        result = host.apt('list', installed: true)
-        expect(result).to be_success
-      end
-
-      it 'lists upgradable packages' do
-        host.su('root')
-        result = host.apt('list', upgradable: true)
-        expect(result).to be_success
-      end
-
-      it 'lists all versions for packages' do
-        host.su('root')
-        result = host.apt('list', all_versions: true)
-        expect(result).to be_success
-      end
-
-      it 'searches packages' do
-        result = host.apt('search', query: 'wget')
-        expect(result).to be_success
-      end
-    end
-  end
-end

data/spec/integration/core/archive_spec.rb

@@ -1,223 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-TestHosts.each_os do |os_name, host_json, spec_dir|
-  RSpec.describe Kanrisuru::Core::Archive do
-    context "with #{os_name}" do
-      before(:all) do
-        host = Kanrisuru::Remote::Host.new(
-          host: host_json['hostname'],
-          username: host_json['username'],
-          keys: [host_json['ssh_key']]
-        )
-
-        host.mkdir(spec_dir, silent: true)
-        host.disconnect
-      end
-
-      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
-
-      after(:all) do
-        host = Kanrisuru::Remote::Host.new(
-          host: host_json['hostname'],
-          username: host_json['username'],
-          keys: [host_json['ssh_key']]
-        )
-
-        host.rmdir(spec_dir)
-        host.rmdir("#{spec_dir}/extract-tar-files") if host.dir?("#{spec_dir}/extract-tar-files")
-        host.disconnect
-      end
-
-      it 'tars an archive' do
-        archive = 'archive.tar'
-        archive2 = 'archive2.tar'
-        directory = spec_dir
-
-        host.touch("#{spec_dir}/test-file.txt")
-        host.touch("#{spec_dir}/test1.txt")
-        host.touch("#{spec_dir}/test2.txt")
-        host.touch("#{spec_dir}/test3.txt")
-
-        host.touch("#{spec_dir}/test1.config")
-        host.touch("#{spec_dir}/test2.config")
-        host.touch("#{spec_dir}/test3.config")
-
-        host.cd(spec_dir)
-        result = host.tar('create', archive, paths: ['*.txt'], exclude: 'test-file.txt', directory: directory)
-
-        expect(result.success?).to eq(true)
-
-        file = host.file("#{spec_dir}/#{archive}")
-
-        expect(file.path).to eq("#{spec_dir}/archive.tar")
-        expect(file.user).to eq(host_json['username'])
-
-        case os_name
-        when 'opensuse', 'sles'
-          expect(file.group).to eq('users')
-        else
-          expect(file.group).to eq(host_json['username'])
-        end
-
-        result = host.tar('list', archive, directory: directory)
-        expect(result.success?).to eq(true)
-        paths = result.map(&:path)
-        expect(paths.include?('test-file.txt')).to eq(false)
-
-        result = host.tar('append', archive, paths: 'test-file.txt', directory: directory)
-        expect(result.success?).to eq(true)
-
-        result = host.tar('list', archive, directory: directory)
-        paths = result.map(&:path)
-
-        expect(paths.include?('test-file.txt')).to eq(true)
-
-        result = host.tar('create', archive2, paths: '*.config', directory: directory)
-        expect(result.success?).to eq(true)
-
-        file = host.file("#{spec_dir}/#{archive2}")
-
-        expect(file.path).to eq("#{spec_dir}/archive2.tar")
-        expect(file.user).to eq(host_json['username'])
-
-        case os_name
-        when 'opensuse', 'sles'
-          expect(file.group).to eq('users')
-        else
-          expect(file.group).to eq(host_json['username'])
-        end
-
-        result = host.tar('concat', archive, paths: archive2, directory: directory)
-        expect(result.success?).to eq(true)
-
-        result = host.tar('list', archive, directory: directory)
-        expect(result.success?).to eq(true)
-        paths = result.map(&:path)
-
-        expect(paths.include?('test1.config')).to eq(true)
-        expect(paths.include?('test2.config')).to eq(true)
-        expect(paths.include?('test3.config')).to eq(true)
-
-        result = host.tar('diff', archive, directory: directory)
-        expect(result.success?).to eq(true)
-
-        result = host.tar('delete', archive, directory: directory, paths: 'test2.config')
-        expect(result.success?).to eq(true)
-
-        result = host.tar('list', archive, directory: directory)
-        expect(result.success?).to eq(true)
-        paths = result.map(&:path)
-        expect(paths.include?('test2.config')).to eq(false)
-
-        host.mkdir("#{spec_dir}/extract-tar-files", silent: true)
-        host.tar('extract', 'archive.tar', directory: "#{spec_dir}/extract-tar-files")
-
-        result = host.ls(path: "#{spec_dir}/extract-tar-files")
-        paths = result.map(&:path)
-
-        expect(paths.include?('test1.config')).to eq(true)
-        expect(paths.include?('test3.config')).to eq(true)
-        expect(paths.include?('test-file.txt')).to eq(true)
-        expect(paths.include?('test1.txt')).to eq(true)
-        expect(paths.include?('test2.txt')).to eq(true)
-        expect(paths.include?('test3.txt')).to eq(true)
-      end
-
-      it 'compresses archive while tar' do
-        archive = 'archive.tar'
-        directory = spec_dir
-
-        host.touch("#{spec_dir}/test1.log")
-        host.touch("#{spec_dir}/test2.log")
-        host.touch("#{spec_dir}/test3.log")
-
-        host.cd(spec_dir)
-        result = host.tar('create', "#{archive}.gz", compress: 'gzip', paths: ['*.log'], directory: directory)
-        expect(result.success?).to eq(true)
-
-        file = host.file("#{spec_dir}/#{archive}.gz")
-        expect(file.path).to eq("#{spec_dir}/archive.tar.gz")
-        expect(file.uid).to eq(1000)
-
-        case os_name
-        when 'opensuse', 'sles'
-          expect(file.gid).to eq(100)
-        else
-          expect(file.gid).to eq(1000)
-        end
-
-        case os_name
-        when 'debian', 'ubuntu'
-          result = host.tar('create', "#{archive}.bz", compress: 'bzip2', paths: ['*.log'], directory: directory)
-          expect(result.success?).to eq(true)
-
-          file = host.file("#{spec_dir}/#{archive}.bz")
-          expect(file.path).to eq("#{spec_dir}/archive.tar.bz")
-          expect(file.uid).to eq(1000)
-          expect(file.gid).to eq(1000)
-        end
-
-        # case os_name
-        # when 'opensuse', 'sles'
-        #   expect(file.gid).to eq(100)
-        # else
-        # end
-
-        case os_name
-        when 'debian'
-          ## no op
-        else
-          result = host.tar('create', "#{archive}.xz", compress: 'xz', paths: ['*.log'], directory: directory)
-          expect(result.success?).to eq(true)
-
-          file = host.file("#{spec_dir}/#{archive}.xz")
-          expect(file.path).to eq("#{spec_dir}/archive.tar.xz")
-          expect(file.uid).to eq(1000)
-
-          case os_name
-          when 'opensuse', 'sles'
-            expect(file.gid).to eq(100)
-          else
-            expect(file.gid).to eq(1000)
-          end
-        end
-
-        case os_name
-        when 'centos', 'rhel', 'debian'
-          ## no op
-        else
-          result = host.tar('create', "#{archive}.lzma", compress: 'lzma', paths: ['*.log'], directory: directory)
-          expect(result.success?).to eq(true)
-
-          file = host.file("#{spec_dir}/#{archive}.lzma")
-          expect(file.path).to eq("#{spec_dir}/archive.tar.lzma")
-          expect(file.uid).to eq(1000)
-
-          case os_name
-          when 'opensuse', 'sles'
-            expect(file.gid).to eq(100)
-          else
-            expect(file.gid).to eq(1000)
-          end
-        end
-
-        expect do
-          host.tar('create', "#{archive}.lzop", compress: 'lzop', paths: ['*.log'],
-                                                directory: directory)
-        end.to raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/spec/integration/core/disk_spec.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-TestHosts.each_os do |os_name, host_json|
-  RSpec.describe Kanrisuru::Core::Disk do
-    context "with #{os_name}" do
-      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 'searches detail on block devices' do
-        host.su('root')
-        result = host.blkid
-        expect(result.success?).to eq(true)
-
-        device = result[0]
-        expect(device).to respond_to(
-          :name, :label, :type, :uuid,
-          :label_fatboot, :part_uuid, :uuid_sub
-        )
-
-        result = host.blkid(uuid: device.uuid)
-        expect(result.success?).to eq(true)
-        expect(result.data).to eq(device.name)
-
-        result = host.blkid(device: device.name)
-        # puts device.name
-        # puts result.inspect
-        expect(result.success?).to eq(true)
-        expect(result.data[0]).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,
-          :minimum_io_size, :physical_sector_size, :logical_sector_size
-        )
-      end
-
-      it 'gets details on block devices' do
-        result = host.lsblk
-        expect(result.data).to be_instance_of(Array)
-
-        device = result[0]
-
-        expect(device).to respond_to(
-          :name, :maj_dev, :min_dev,
-          :removable_device, :readonly_device,
-          :owner, :group, :mode,
-          :fsize, :type, :mount_point,
-          :fs_type, :uuid, :children
-        )
-      end
-
-      it 'gets summarize disk usage' do
-        result = host.du(path: "#{host_json['home']}/.bashrc", summarize: true)
-        expect(result).to be_success
-        expect(result[0].path).to eq("#{host_json['home']}/.bashrc")
-      end
-
-      it 'gets all disk usage' do
-        result = host.du(path: host_json['home'])
-        expect(result).to be_success
-        expect(result.data.length).to be >= 2
-      end
-
-      it 'gets summarized disk usage root user' do
-        host.su('root')
-        result = host.du(path: '/etc', summarize: true)
-        expect(result).to be_success
-        expect(result[0].path).to eq('/etc')
-      end
-
-      it 'gets disk free for system' do
-        expect(host.df.data).to be_instance_of(Array)
-        expect(host.df(inodes: true).data).to be_instance_of(Array)
-      end
-
-      it 'gets disk usage for path' do
-        result = host.df(path: '/')
-        expect(result.data).to be_instance_of(Array)
-        expect(result[0].mount).to eq('/')
-      end
-    end
-  end
-end

data/spec/integration/core/dmi_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-TestHosts.each_os do |os_name, host_json|
-  RSpec.describe Kanrisuru::Core::Dmi do
-    context "with #{os_name}" do
-      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 'parses dmi values' do
-        host.su('root')
-        result = host.dmi
-        expect(result).to be_success
-      end
-
-      it 'parses dmi values with types' do
-        host.su('root')
-        result = host.dmi(types: ['System', 3])
-        expect(result).to be_success
-
-        expect(result.find { |i| i.dmi_type == 'System' }).to be_instance_of(Kanrisuru::Core::Dmi::System)
-        expect(result.find { |i| i.dmi_type == 'Chassis' }).to be_instance_of(Kanrisuru::Core::Dmi::Chassis)
-      end
-    end
-  end
-end