kanrisuru 0.11.0 → 0.13.0

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

data/spec/integration/core/stat_spec.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Kanrisuru::Core::Stat 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 '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,117 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Kanrisuru::Core::Stream 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.rmdir("#{host_json['home']}/.kanrisuru_spec_files")
-        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,143 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Kanrisuru::Core::System 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 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

data/spec/integration/core/transfer_spec.rb

@@ -1,108 +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.rmdir("#{host_json['home']}/.kanrisuru_spec_files")
-        host.disconnect
-      end
-
-      it 'uploads a template file' do
-        path = '../templates/test.conf.erb'
-        dest_path = "#{spec_dir}/test.conf"
-
-        template = Kanrisuru::Template.new(path, array: %w[this is an array])
-        result = host.upload(template.read, dest_path)
-
-        expect(result).to be_success
-        expect(result.mode.numeric).to eq('640')
-        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
-
-        expect(host.cat(dest_path).to_a).to eq([
-                                                 '<h1>Hello World</h1>',
-                                                 'this',
-                                                 'is',
-                                                 'an',
-                                                 'array'
-                                               ])
-      end
-
-      it 'uploads a dir' do
-        path = '../meta/'
-        dest_path = "#{spec_dir}/meta"
-
-        result = host.upload(path, dest_path, recursive: true)
-        expect(result).to be_success
-      end
-
-      it 'downloads a file to local fs' do
-        path = '../hosts-file'
-        src_path = '/etc/hosts'
-
-        result = host.download(src_path, path)
-        expect(result).to eq(path)
-        FileUtils.rm(path)
-      end
-
-      it 'downloads a file directly' do
-        src_path = '/etc/hosts'
-
-        result = host.download(src_path)
-        expect(result).to be_instance_of(String)
-        lines = result.split("\n")
-        expect(lines.length).to be >= 1
-      end
-
-      it 'wgets url' do
-        result = host.wget('https://example.com', directory_prefix: spec_dir)
-        expect(result).to be_success
-      end
-    end
-  end
-end

data/spec/integration/core/user_spec.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Kanrisuru::Core::User 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
-
-      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.su('root')
-        host.user?('rails')
-        host.delete_user('rails').inspect if host.user?('rails')
-        host.rmdir('/home/rails') if host.dir?('/home/rails')
-        host.disconnect
-      end
-
-      it 'gets uid for user' do
-        expect(host.get_uid(host_json['uername']).to_i).to eq(1000)
-        expect(host.get_uid('asdf').to_i).to eq(nil)
-      end
-
-      it 'gets a user details' do
-        result = host.get_user(host_json['username'])
-        expect(result.uid).to eq(1000)
-        expect(result.name).to eq(host_json['username'])
-        expect(result.home.path).to eq(host_json['home'])
-
-        case os_name
-        when 'opensuse', 'sles'
-          expect(result.groups[0]).to have_attributes(gid: 100, name: 'users')
-        else
-          expect(result.groups[0]).to have_attributes(gid: 1000, name: host_json['username'])
-        end
-      end
-
-      it 'manages a user' do
-        ## Need priviledge escalation to manage group
-        host.su('root')
-
-        result = host.create_user('rails', password: '123456', groups: %w[mail tty])
-        expect(result.success?).to eq(true)
-        expect(result.uid).to eq(1001)
-        expect(result.groups.length).to eq(3)
-        expect(result.shell.path).to eq('/bin/false')
-        expect(result.home.path).to eq('/home/rails')
-
-        result = host.update_user('rails', uid: 1002, shell: '/bin/bash', groups: ['audio'], append: true)
-
-        expect(result.uid).to eq(1002)
-        expect(result.shell.path).to eq('/bin/bash')
-        expect(result.groups.length).to eq(4)
-
-        expect(host.delete_user('rails').success?).to eq(true) if host.user?('rails')
-      end
-    end
-  end
-end