kanrisuru 0.1.0 → 0.2.1

data/spec/functional/core/group_spec.rb

@@ -0,0 +1,65 @@
+# 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/functional/core/ip_spec.rb

@@ -0,0 +1,71 @@
+# 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/functional/core/path_spec.rb

@@ -0,0 +1,93 @@
+# 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.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
+
+      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/functional/core/socket_spec.rb

@@ -0,0 +1,31 @@
+# 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/functional/core/stat_spec.rb

@@ -0,0 +1,98 @@
+# 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/functional/core/stream_spec.rb

@@ -0,0 +1,99 @@
+# 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 '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