kanrisuru 0.8.14 → 0.8.18

data/spec/integration/core/find_spec.rb

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

@@ -0,0 +1,117 @@
+# 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/transfer_spec.rb

@@ -0,0 +1,108 @@
+# 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/spec_helper.rb

@@ -4,7 +4,10 @@ require 'simplecov'
 SimpleCov.start
 
 require 'kanrisuru'
+
 require_relative 'helper/test_hosts'
+require_relative 'helper/stub_network'
+require_relative 'helper/expect_helpers'
 
 Kanrisuru.logger.level = Logger::WARN
 

data/spec/unit/core/find_spec.rb

@@ -5,5 +5,8 @@ require 'spec_helper'
 RSpec.describe Kanrisuru::Core::Find do
   it 'responds to find fields' do
     expect(Kanrisuru::Core::Find::FilePath.new).to respond_to(:path)
+    expect(Kanrisuru::Core::Find::REGEX_TYPES).to(
+      eq(['emacs', 'posix-awk', 'posix-basic', 'posix-egrep', 'posix-extended'])
+    )
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kanrisuru
 version: !ruby/object:Gem::Version
-  version: 0.8.14
+  version: 0.8.18
 platform: ruby
 authors:
 - Ryan Mammina
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-09 00:00:00.000000000 Z
+date: 2021-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -173,34 +173,41 @@ files:
 - lib/kanrisuru/util/os_family.rb
 - lib/kanrisuru/util/signal.rb
 - lib/kanrisuru/version.rb
-- spec/functional/core/apt_spec.rb
-- spec/functional/core/archive_spec.rb
-- spec/functional/core/disk_spec.rb
-- spec/functional/core/dmi_spec.rb
-- spec/functional/core/file_spec.rb
 - spec/functional/core/find_spec.rb
-- spec/functional/core/group_spec.rb
-- spec/functional/core/ip_spec.rb
 - spec/functional/core/path_spec.rb
-- spec/functional/core/socket_spec.rb
 - spec/functional/core/stat_spec.rb
 - spec/functional/core/stream_spec.rb
-- spec/functional/core/system_spec.rb
 - spec/functional/core/transfer_spec.rb
-- spec/functional/core/user_spec.rb
-- spec/functional/core/yum_spec.rb
-- spec/functional/core/zypper_spec.rb
 - spec/functional/os_package_spec.rb
-- spec/functional/remote/cluster_spec.rb
-- spec/functional/remote/cpu_spec.rb
-- spec/functional/remote/env_spec.rb
-- spec/functional/remote/fstab_spec.rb
-- spec/functional/remote/host_spec.rb
-- spec/functional/remote/memory_spec.rb
-- spec/functional/remote/os_spec.rb
-- spec/functional/remote/remote_file_spec.rb
+- spec/helper/expect_helpers.rb
+- spec/helper/stub_network.rb
 - spec/helper/test_hosts.rb
 - spec/hosts.json
+- spec/integration/core/apt_spec.rb
+- spec/integration/core/archive_spec.rb
+- spec/integration/core/disk_spec.rb
+- spec/integration/core/dmi_spec.rb
+- spec/integration/core/file_spec.rb
+- spec/integration/core/find_spec.rb
+- spec/integration/core/group_spec.rb
+- spec/integration/core/ip_spec.rb
+- spec/integration/core/path_spec.rb
+- spec/integration/core/socket_spec.rb
+- spec/integration/core/stat_spec.rb
+- spec/integration/core/stream_spec.rb
+- spec/integration/core/system_spec.rb
+- spec/integration/core/transfer_spec.rb
+- spec/integration/core/user_spec.rb
+- spec/integration/core/yum_spec.rb
+- spec/integration/core/zypper_spec.rb
+- spec/integration/remote/cluster_spec.rb
+- spec/integration/remote/cpu_spec.rb
+- spec/integration/remote/env_spec.rb
+- spec/integration/remote/fstab_spec.rb
+- spec/integration/remote/host_spec.rb
+- spec/integration/remote/memory_spec.rb
+- spec/integration/remote/os_spec.rb
+- spec/integration/remote/remote_file_spec.rb
 - spec/spec_helper.rb
 - spec/unit/core/apt_spec.rb
 - spec/unit/core/archive_spec.rb