kanrisuru 0.12.0 → 0.15.0

data/spec/support/shared_examples/integration/core/archive.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'archive' do |os_name, host_json, spec_dir|
+  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

data/spec/support/shared_examples/integration/core/disk.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'disk' do |os_name, host_json, _spec_dir|
+  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

data/spec/support/shared_examples/integration/core/dmi.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'dmi' do |os_name, host_json, _spec_dir|
+  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

data/spec/support/shared_examples/integration/core/file.rb

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'file' do |os_name, host_json, spec_dir|
+  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.rm(spec_dir, force: true, recursive: true)
+      host.disconnect
+    end
+
+    it 'changes file permission flags' do
+      host.su('root')
+
+      path = "#{spec_dir}/test.txt"
+      host.touch(path)
+
+      mode = host.stat(path).mode
+
+      expect(mode).to be_instance_of(Kanrisuru::Mode)
+
+      mode.numeric = 0o777
+
+      mode = host.chmod(path, mode).mode
+
+      expect(mode).to be_instance_of(Kanrisuru::Mode)
+      expect(mode.numeric).to eq('777')
+
+      mode.symbolic = 'g=r,o=r'
+
+      mode = host.chmod(path, mode).mode
+      expect(mode.symbolic).to eq('-rwxr--r--')
+      expect(mode.to_i).to eq(0o744)
+
+      expect do
+        host.chmod(path, 600)
+      end.to raise_error(ArgumentError)
+    end
+
+    it 'changes file owner and group' do
+      path = "#{spec_dir}/test-owner.txt"
+
+      host.touch(path)
+
+      host.su('root')
+      result = host.chown(path, owner: host_json['username'], group: host_json['username'])
+
+      expect(result.user).to eq(host_json['username'])
+      expect(result.uid).to eq(1000)
+
+      case os_name
+      when 'opensuse', 'sles'
+        expect(result.group).to eq('users')
+        expect(result.gid).to eq(100)
+      else
+        expect(result.group).to eq(host_json['username'])
+        expect(result.gid).to eq(1000)
+      end
+
+      host.su('root')
+      result = host.chown(path, owner: 'root', group: 'root')
+
+      expect(result.user).to eq('root')
+      expect(result.uid).to eq(0)
+      expect(result.group).to eq('root')
+      expect(result.gid).to eq(0)
+    end
+
+    it 'touches files' do
+      result = host.touch("#{spec_dir}/test-date.txt", date: '2021-01-01')
+
+      expect(result.success?).to eq(true)
+      expect(result[0].last_modified).to be_instance_of(DateTime)
+      expect(result[0].last_modified.to_date.to_s).to eq('2021-01-01')
+
+      paths = ["#{spec_dir}/test1.config", "#{spec_dir}/test2.config", "#{spec_dir}/test3.config"]
+      host.touch(paths)
+
+      realpaths = paths.map do |path|
+        host.realpath(path).path
+      end
+
+      result = host.touch(paths)
+      expect(result.data).to be_instance_of(Array)
+
+      current_date = Time.now.to_date.to_s
+
+      result.each do |item|
+        expect(realpaths.include?(item.path)).to eq(true)
+        expect(item.user).to eq(host_json['username'])
+        expect(item.fsize).to eq(0)
+        expect(item.last_modified.to_date.to_s).to eq(current_date)
+        expect(item.last_access.to_date.to_s).to eq(current_date)
+        expect(item.last_changed.to_date.to_s).to eq(current_date)
+      end
+    end
+
+    it 'soft links file' do
+      path = "#{spec_dir}/test-file.txt"
+
+      result_a = host.touch(path)[0]
+      expect(result_a.path).to eq(host.realpath(path).path)
+
+      result_b = host.symlink(path, "#{spec_dir}/test-symlink.txt")
+
+      expect(host.realpath(result_b.path).path).to eq(result_a.path)
+      expect(result_b.file_type).to eq('symbolic link')
+    end
+
+    it 'hard links file' do
+      path = "#{spec_dir}/test-file-ln.txt"
+      host.touch(path)
+
+      result_a = host.touch(path)[0]
+      result_b = host.link(path, "#{spec_dir}/test-link.txt")
+
+      expect(result_b.inode).to eq(result_a.inode)
+      expect(result_b.file_type).to eq('regular empty file')
+
+      result = host.find(inode: result_a.inode)
+      files = result.map do |item|
+        host.realpath(item.path).path
+      end
+
+      expect(files.include?(host.realpath(result_a.path).path)).to eq(true)
+      expect(files.include?(host.realpath(result_b.path).path)).to eq(true)
+
+      ## Can't hard link dir
+      expect(host.link(spec_dir.to_s, "#{spec_dir}/tmpb")).to eq(false)
+
+      host.rm("#{spec_dir}/test-link.txt")
+    end
+
+    it 'creates directory' do
+      path = "#{spec_dir}/test-dir/"
+      result = host.mkdir(path)
+
+      expect(result).to be_success
+      expect(result.path).to eq(path)
+      expect(result.mode.numeric).to eq('755')
+      expect(result.file_type).to eq('directory')
+      expect(result.uid).to eq(1000)
+      expect(result.user).to eq(host_json['username'])
+
+      case os_name
+      when 'sles', 'opensuse'
+        expect(result.gid).to eq(100)
+        expect(result.group).to eq('users')
+      else
+        expect(result.gid).to eq(1000)
+        expect(result.group).to eq(host_json['username'])
+      end
+
+      result = host.ls(path: spec_dir)
+      expect(result.success?).to eq(true)
+      selected = result.find { |item| item.path == 'test-dir' }
+
+      expect(selected.path).to eq('test-dir')
+    end
+
+    it 'copies a file' do
+      path = "#{spec_dir}/remote-file.txt"
+      copied_path = "#{spec_dir}/remote-file-copied.txt"
+
+      file = host.file(path)
+      file.touch
+      file.append do |f|
+        f << 'Hello'
+        f << 'World'
+      end
+
+      result = host.cp(path, copied_path)
+      expect(result.success?).to eq(true)
+
+      result = host.cat(copied_path)
+      expect(result.success?).to eq(true)
+      expect(result.data).to eq(%w[Hello World])
+    end
+
+    it 'copies directories' do
+      path = "#{spec_dir}/remote-dir"
+      subdir_path = "#{path}/subdir"
+      copied_path = "#{spec_dir}/copied-dir"
+
+      result = host.mkdir(path)
+      expect(result.success?).to eq(true)
+
+      result = host.mkdir(subdir_path)
+      expect(result.success?).to eq(true)
+
+      file = host.file("#{subdir_path}/test-nested.txt")
+      file.touch
+      file.append do |f|
+        f << 'This is a'
+        f << 'test file...'
+      end
+
+      result = host.cp(path, copied_path, recursive: true)
+      expect(result.success?).to eq(true)
+    end
+
+    it 'copies with a backup' do
+      path = "#{spec_dir}/remote-file-to-backup.txt"
+      copied_path = "#{spec_dir}/remote-file-copied-with-backup.txt"
+
+      file = host.file(path)
+      file.touch
+      file.append do |f|
+        f << 'Hello'
+        f << 'World'
+      end
+
+      result = host.cp(path, copied_path)
+      expect(result).to be_success
+
+      file.append do |f|
+        f << 'New Content'
+      end
+
+      result = host.cp(path, copied_path, backup: true)
+      expect(result.success?).to eq(true)
+
+      result = host.ls(path: spec_dir)
+      backup = result.find { |f| f.path == 'remote-file-copied-with-backup.txt~' }
+      expect(backup.path).to eq('remote-file-copied-with-backup.txt~')
+    end
+
+    it 'moves files' do
+      path = "#{spec_dir}/remote-file-to-move.txt"
+      new_path = "#{spec_dir}/remote-file-moved.txt"
+
+      file = host.file(path)
+      file.touch
+      file.append do |f|
+        f << 'Hello'
+        f << 'World'
+      end
+
+      result = host.mv(path, new_path, no_target_directory: true)
+      expect(result.success?).to eq(true)
+
+      result = host.cat(new_path)
+      expect(result).to be_success
+      expect(result.data).to eq(%w[Hello World])
+    end
+
+    it 'moves files into a folder' do
+      paths = ['file1.txt', 'file2.txt', 'file3.txt']
+      paths = paths.map { |p| "#{spec_dir}/#{p}" }
+      new_dir = "#{spec_dir}/new_dir"
+
+      result = host.mkdir(new_dir)
+      expect(result).to be_success
+
+      paths.each do |path|
+        file = host.file(path)
+        file.touch
+        file.append do |f|
+          f << 'this is a file'
+        end
+      end
+
+      result = host.mv(paths, new_dir, target_directory: true)
+      expect(result).to be_success
+    end
+
+    it 'moves folders' do
+      path = "#{spec_dir}/remote-dir-to-move"
+      moved_path = "#{spec_dir}/moved-dir"
+
+      result = host.mkdir(path)
+      expect(result).to be_success
+
+      result = host.mv(path, moved_path)
+      expect(result).to be_success
+    end
+
+    it 'removes file' do
+      path = "#{spec_dir}/test-rm-file.txt"
+
+      result = host.touch(path)[0]
+      expect(host.empty_file?(result.path)).to eq(true)
+
+      result = host.rm(path)
+      expect(result.success?).to eq(true)
+      expect(host.empty_file?(path)).to eq(false)
+    end
+
+    it 'removes directories' do
+      result = host.mkdir("#{spec_dir}/directory/1", silent: true)
+      expect(result).to be_success
+
+      result = host.mkdir("#{spec_dir}/directory/2", silent: true)
+      expect(result).to be_success
+
+      result = host.mkdir("#{spec_dir}/directory/3", silent: true)
+      expect(result).to be_success
+
+      result = host.rmdir(["#{spec_dir}/directory/1", "#{spec_dir}/directory/2"])
+      expect(result).to be_success
+
+      ## Can't delete non empty dir
+      result = host.rmdir("#{spec_dir}/directory")
+      expect(result).to be_failure
+
+      result = host.rmdir("#{spec_dir}/directory/3")
+      expect(result).to be_success
+    end
+
+    it 'counts a file' do
+      result = host.wc('/etc/hosts')
+
+      expect(result.success?).to eq(true)
+      expect(result).to respond_to(:lines, :words, :characters)
+
+      ## Need to remap data including newline chars to get byte size
+      data = host.cat('/etc/hosts').command.raw_result
+      doc = data.map(&:lines).flatten
+
+      words = doc.map(&:split).flatten
+      chars = doc.map(&:length).flatten
+
+      expect(result.lines).to eq(doc.length)
+      expect(result.words).to eq(words.length)
+      expect(result.characters).to eq(chars.sum)
+    end
+  end
+end