kanrisuru 0.12.0 → 0.15.0

data/spec/integration/core/find_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-TestHosts.each_os do |os_name, host_json|
-  RSpec.describe Kanrisuru::Core::Find 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 '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,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-TestHosts.each_os do |os_name, host_json|
-  RSpec.describe Kanrisuru::Core::Group 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 '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,70 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-TestHosts.each_os do |os_name, host_json|
-  RSpec.describe Kanrisuru::Core::IP 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
-
-      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,92 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-TestHosts.each_os do |os_name, host_json|
-  RSpec.describe Kanrisuru::Core::Path 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 '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,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-TestHosts.each_os do |os_name, host_json|
-  RSpec.describe Kanrisuru::Core::Socket 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 '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

data/spec/integration/core/stat_spec.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-TestHosts.each_os do |os_name, host_json|
-  RSpec.describe Kanrisuru::Core::Stat 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 'checks file type correctly' do
-        expect(host.dir?('/')).to eq(true)
-        expect(host.file?('/etc/hosts')).to eq(true)
-
-        case os_name
-        when 'sles'
-          expect(host.block_device?('/dev/xvda')).to eq(true)
-        else
-          expect(host.block_device?('/dev/vda')).to eq(true)
-        end
-
-        expect(host.char_device?('/dev/tty')).to eq(true)
-        expect(host.symlink?('/etc/mtab')).to eq(true)
-        expect(host.inode?('/proc/uptime')).to eq(true)
-      end
-
-      it 'gets file stat' do
-        result = host.stat(host_json['home'])
-
-        expect(result.mode).to be_instance_of(Kanrisuru::Mode)
-        expect(result.mode.directory?).to eq(true)
-
-        case os_name
-        when 'centos', 'rhel', 'fedora'
-          expect(result.mode.numeric).to eq('700')
-          expect(result.mode.to_i).to eq(0o700)
-
-          expect(result.mode.group.read?).to eq(false)
-          expect(result.mode.group.write?).to eq(false)
-          expect(result.mode.group.execute?).to eq(false)
-
-          expect(result.mode.other.read?).to eq(false)
-          expect(result.mode.other.write?).to eq(false)
-          expect(result.mode.other.execute?).to eq(false)
-
-          expect(result.mode.owner.read?).to eq(true)
-          expect(result.mode.owner.write?).to eq(true)
-          expect(result.mode.owner.execute?).to eq(true)
-
-          expect(result.mode.symbolic).to eq('drwx------')
-        else
-          expect(result.mode.numeric).to eq('755')
-          expect(result.mode.to_i).to eq(0o755)
-
-          expect(result.mode.group.read?).to eq(true)
-          expect(result.mode.group.write?).to eq(false)
-          expect(result.mode.group.execute?).to eq(true)
-
-          expect(result.mode.other.read?).to eq(true)
-          expect(result.mode.other.write?).to eq(false)
-          expect(result.mode.other.execute?).to eq(true)
-
-          expect(result.mode.owner.read?).to eq(true)
-          expect(result.mode.owner.write?).to eq(true)
-          expect(result.mode.owner.execute?).to eq(true)
-
-          expect(result.mode.symbolic).to eq('drwxr-xr-x')
-        end
-
-        expect(result.file_type).to eq('directory')
-
-        case os_name
-        when 'opensuse', 'sles'
-          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
-
-        expect(result.uid).to eq(1000)
-        expect(result.user).to eq(host_json['username'])
-
-        expect(result.fsize).to be >= 0
-      end
-    end
-  end
-end

data/spec/integration/core/stream_spec.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-TestHosts.each_os do |os_name, host_json, spec_dir|
-  RSpec.describe Kanrisuru::Core::Stream 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.disconnect
-      end
-
-      it 'outputs beginning of a file' do
-        file = host.file("#{spec_dir}/test-file.txt")
-        file.touch
-        file.append do |f|
-          f << 'This'
-          f << 'is'
-          f << 'a'
-          f << 'file!'
-        end
-
-        result = host.head("#{spec_dir}/test-file.txt", lines: 2)
-        expect(result).to be_success
-        expect(result.data.length).to eq(2)
-        expect(result.data).to eq(%w[This is])
-      end
-
-      it 'outputs end of a file' do
-        file = host.file("#{spec_dir}/test-file.txt")
-        file.touch
-        file.append do |f|
-          f << 'This'
-          f << 'is'
-          f << 'a'
-          f << 'file!'
-        end
-
-        result = host.tail("#{spec_dir}/test-file.txt", lines: 2)
-        expect(result).to be_success
-        expect(result.data.length).to eq(2)
-        expect(result.data).to eq(['a', 'file!'])
-      end
-
-      it 'reads a chunk of text from a file' do
-        file = host.file("#{spec_dir}/test-file-chunk.txt")
-        file.touch
-        file.append do |f|
-          f << 'This'
-          f << 'is'
-          f << 'is'
-          f << 'a'
-          f << 'file'
-          f << 'forever...'
-        end
-
-        result = host.read_file_chunk("#{spec_dir}/test-file-chunk.txt", 2, 4)
-        expect(result).to be_success
-        expect(result.data.length).to eq(3)
-        expect(result.data).to eq(%w[is is a])
-      end
-
-      it 'cats a file' do
-        result = host.cat('/etc/group')
-        expect(result.success?).to eq(true)
-        expect(result.data.include?('root:x:0:')).to eq(true)
-      end
-
-      it 'echoes to stdout' do
-        result = host.echo('Hello world')
-        expect(result.data).to eq('Hello world')
-      end
-
-      it 'seds file to stdout' do
-        path = "#{spec_dir}/test-file.txt"
-        result = host.echo("Hello world, this is a Cat test file.\nCat\nCat\nDog", new_file: path, mode: 'write')
-        expect(result).to be_success
-
-        result = host.sed(path, 'Cat', 'Dog')
-        expect(result).to be_success
-        expect(result.data).to eq("Hello world, this is a Dog test file.\nDog\nDog\nDog")
-      end
-    end
-  end
-end

data/spec/integration/core/system_spec.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-TestHosts.each_os do |os_name, host_json|
-  RSpec.describe Kanrisuru::Core::System 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 'gets cpu details' do
-        result = host.lscpu
-        expect(result).to be_success
-        expect(result.data).to be_instance_of(Kanrisuru::Core::System::CPUArchitecture)
-      end
-
-      it 'gets environment variables' do
-        result = host.load_env
-        expect(result).to be_success
-        expect(result.data).to be_instance_of(Hash)
-      end
-
-      it 'gets open files' do
-        host.su('root')
-        result = host.lsof
-        expect(result).to be_success
-        expect(result.data).to be_instance_of(Array)
-      end
-
-      it 'gets uptime' do
-        result = host.uptime
-        expect(result).to be_success
-
-        expect(result).to respond_to(
-          :boot_time, :uptime, :seconds,
-          :hours, :minutes, :days
-        )
-
-        expect(result.seconds).to be > 0
-        expect(result.minutes).to be >= 0
-        expect(result.hours).to be >= 0
-        expect(result.days).to be >= 0
-      end
-
-      it 'kills pids' do
-        command = 'sleep 100000 > /dev/null 2>&1 &'
-
-        host.execute_shell("nohup #{command}")
-        result = host.ps(user: host_json['username'])
-        expect(result.success?).to eq(true)
-
-        process = result.select do |proc|
-          proc.command == 'sleep 100000'
-        end
-
-        pids = process.map(&:pid)
-        result = host.kill('SIGKILL', pids)
-        expect(result.success?).to eq(true)
-
-        result = host.ps(user: host_json['username'])
-        process = result.select do |proc|
-          proc.command == 'sleep 100000'
-        end
-
-        expect(process).to be_empty
-      end
-
-      it 'gets kernel statistics' do
-        result = host.kernel_statistics
-        expect(result).to be_success
-
-        expect(result.data).to respond_to(
-          :cpu_total,
-          :cpus,
-          :interrupt_total,
-          :interrupts,
-          :ctxt,
-          :btime,
-          :processes,
-          :procs_running,
-          :procs_blocked,
-          :softirq_total,
-          :softirqs
-        )
-
-        expect(result.cpus.length).to eq(host.cpu.cores)
-      end
-
-      it 'gets login details' do
-        host.su('root')
-
-        result = host.last
-        expect(result).to be_success
-      end
-
-      it 'gets failed login attempts' do
-        host.su('root')
-
-        result = host.last(failed_attempts: true)
-        expect(result).to be_success
-      end
-
-      it 'gets process details' do
-        result = host.ps
-
-        expect(result.data).to be_instance_of(Array)
-        process = result[0]
-
-        expect(process).to respond_to(
-          :uid, :user, :gid, :group,
-          :pid, :ppid, :cpu_usage, :memory_usage,
-          :stat, :priority, :flags, :policy_abbr, :policy,
-          :cpu_time, :command
-        )
-
-        result = host.ps(user: [host_json['username']])
-
-        expect(result.data).to be_instance_of(Array)
-
-        process = result.find do |proc|
-          proc.command == result.command.raw_command
-        end
-
-        expect(process.command).to eq(result.command.raw_command)
-      end
-
-      it 'gets information for users' do
-        result = host.who
-        expect(result.success?).to eq(true)
-      end
-    end
-  end
-end