kanrisuru 0.11.1 → 0.14.0

data/spec/integration/core/file_spec.rb

@@ -1,368 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Kanrisuru::Core::File do
-  TestHosts.each_os do |os_name|
-    context "with #{os_name}" do
-      before(:all) do
-        host_json = TestHosts.host(os_name)
-        host = Kanrisuru::Remote::Host.new(
-          host: host_json['hostname'],
-          username: host_json['username'],
-          keys: [host_json['ssh_key']]
-        )
-
-        host.mkdir("#{host_json['home']}/.kanrisuru_spec_files", silent: true)
-        host.disconnect
-      end
-
-      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
-
-      let(:spec_dir) { "#{host_json['home']}/.kanrisuru_spec_files" }
-
-      after do
-        host.disconnect
-      end
-
-      after(:all) do
-        host_json = TestHosts.host(os_name)
-        host = Kanrisuru::Remote::Host.new(
-          host: host_json['hostname'],
-          username: host_json['username'],
-          keys: [host_json['ssh_key']]
-        )
-
-        host.rm("#{host_json['home']}/.kanrisuru_spec_files", force: true, recursive: true)
-        if host.dir?("#{host_json['home']}/extract-tar-files")
-          host.rm("#{host_json['home']}/extract-tar-files", force: true,
-                                                            recursive: true)
-        end
-        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
-end

data/spec/integration/core/find_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Kanrisuru::Core::Find 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 '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
-end

data/spec/integration/core/group_spec.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Kanrisuru::Core::Group 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 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
-end

data/spec/integration/core/ip_spec.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Kanrisuru::Core::IP 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
-
-      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
-end

data/spec/integration/core/path_spec.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Kanrisuru::Core::Path 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 '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
-end

data/spec/integration/core/socket_spec.rb

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