kanrisuru 0.11.1 → 0.14.0

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

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'find' 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 'finds home directory' do
+      host.su('root')
+      result = host.find(paths: '/home')
+      home = result.find { |item| item.path == host_json['home'] }
+      expect(home.path).to eq(host_json['home'])
+
+      result = host.find(paths: ['/home'])
+      home = result.find { |item| item.path == host_json['home'] }
+      expect(home.path).to eq(host_json['home'])
+    end
+
+    it 'finds /etc/hosts file' do
+      host.su('root')
+      result = host.find(paths: '/etc', type: 'file', name: 'hosts', uid: 0, gid: 0, writeable: true, maxdepth: 1)
+      expect(result[0].path).to eq('/etc/hosts')
+
+      file = host.stat(result[0].path)
+      expect(file.uid).to eq(0)
+      expect(file.gid).to eq(0)
+    end
+
+    it 'finds files with regex' do
+      result = host.find(paths: '~', regex: '.*.\\(js\\|rb\\)')
+      expect(result.data).to be_instance_of(Array)
+    end
+
+    it 'finds files by size' do
+      result = host.find(paths: '~', size: '+2M', type: 'file')
+      expect(result.data).to be_instance_of(Array)
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'group' 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 'gets gid for group' do
+      case os_name
+      when 'opensuse', 'sles'
+        expect(host.get_gid('users').to_i).to eq(100)
+      else
+        expect(host.get_gid(host_json['username']).to_i).to eq(1000)
+      end
+
+      expect(host.get_gid('asdf').to_i).to eq(nil)
+    end
+
+    it 'gets group details' do
+      case os_name
+      when 'opensuse', 'sles'
+        result = host.get_group('users')
+        expect(result.success?).to eq(true)
+        expect(result.gid).to eq(100)
+        expect(result.name).to eq('users')
+      else
+        result = host.get_group(host_json['username'])
+        expect(result.success?).to eq(true)
+        expect(result.gid).to eq(1000)
+        expect(result.name).to eq(host_json['username'])
+      end
+
+      expect(result).to respond_to(:users)
+    end
+
+    it 'manages a group' do
+      ## Need priviledge escalation to manage group
+      host.su('root')
+
+      if host.group?('rspec')
+        expect(host.delete_group('rspec').success?).to eq(true)
+      elsif host.group?('minitest')
+        expect(host.delete_group('minitest').success?).to eq(true)
+      end
+
+      expect(host.create_group('rspec').gid).to be >= 1000
+      expect(host.update_group('rspec', gid: 1005, new_name: 'minitest').gid).to eq(1005)
+      expect(host.delete_group('minitest').success?).to eq(true)
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'ip' 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
+
+    describe 'ip address' do
+      it 'show' do
+        result = host.ip('address', 'show', stats: true)
+        expect(result).to be_success
+      end
+    end
+
+    describe 'ip link' do
+      it 'show' do
+        result = host.ip('link', 'show', stats: true)
+        expect(result).to be_success
+      end
+    end
+
+    describe 'ip addrlabel' do
+      it 'list' do
+        result = host.ip('addrlabel', 'list')
+        expect(result).to be_success
+      end
+    end
+
+    describe 'ip route' do
+      it 'show' do
+        result = host.ip('route', 'show')
+        expect(result).to be_success
+      end
+    end
+
+    describe 'ip rule' do
+      it 'show' do
+        result = host.ip('rule', 'show')
+        expect(result).to be_success
+      end
+    end
+
+    describe 'ip neighbour' do
+      it 'show' do
+        result = host.ip('neighbour', 'show', stats: true)
+        expect(result).to be_success
+      end
+    end
+
+    describe 'ip maddress' do
+      it 'show' do
+        result = host.ip('maddress', 'show')
+        expect(result).to be_success
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'path' 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 'lists files and directories' do
+      result = host.ls(all: true)
+      expect(result.data).to be_instance_of(Array)
+
+      dir = result.find { |file| file.path == '.' }
+      expect(dir.path).to eq('.')
+
+      result = host.ls(path: host_json['home'], id: true, all: true)
+      expect(result.data).to be_instance_of(Array)
+
+      file = result.find { |f| f.path == '.bashrc' }
+      expect(file.owner).to eq(1000)
+
+      case os_name
+      when 'opensuse', 'sles'
+        expect(file.group).to eq(100)
+      else
+        expect(file.group).to eq(1000)
+      end
+    end
+
+    it 'gets whoami' do
+      expect(host.whoami.user).to eq(host_json['username'])
+    end
+
+    it 'gets pwd' do
+      expect(host.pwd.path).to eq(host_json['home'])
+    end
+
+    it 'uses which to get path for bash' do
+      result = host.which('bash', all: true)
+      paths = result.map(&:path)
+
+      case os_name
+      when 'ubuntu'
+        if host.os.version <= 18.04
+          expect(paths).to include('/bin/bash')
+        else
+          expect(paths).to include('/usr/bin/bash', '/bin/bash')
+        end
+      when 'opensuse'
+        ## Ignore for local testing
+      when 'sles'
+        expect(paths).to include('/bin/bash')
+      else
+        expect(paths).to include('/usr/bin/bash', '/bin/bash')
+      end
+    end
+
+    it 'gets realpath for dir' do
+      case os_name
+      when 'sles'
+        expect(host.realpath('/var/run').path).to eq('/run')
+      when 'rhel'
+        expect(host.realpath('/bin').path).to eq('/usr/bin')
+      else
+        expect(host.realpath('/etc/os-release').path).to eq('/usr/lib/os-release')
+      end
+    end
+
+    it 'gets full path for dir with readlink' do
+      case os_name
+      when 'sles'
+        expect(host.readlink('/var/run', canonicalize: true).path).to eq('/run')
+      when 'rhel'
+        expect(host.readlink('/bin', canonicalize: true).path).to eq('/usr/bin')
+      else
+        expect(host.readlink('/etc/os-release', canonicalize: true).path).to eq('/usr/lib/os-release')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'socket' 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 'gets socket details' do
+      result = host.ss
+      expect(result).to be_success
+
+      result = host.ss(state: 'listening')
+      expect(result).to be_success
+    end
+  end
+end