kanrisuru 0.8.12 → 0.8.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96b168459e76c64aa511a58fc43d0d777d5d783874e47a24c373dd6da2ef3ff4
-  data.tar.gz: 461c0236448253694f369cfc1b7757f61aeb0a4e0af3841cea62b6297d862c14
+  metadata.gz: 6c2110c3bfef603ff4d09ade3a4fabf81b34e2f5ca51ff9f120d382963542f7f
+  data.tar.gz: 6ef4e848168e93b37a06e0d0cbfffd9138d979e125d7a151e77c594539aba85d
 SHA512:
-  metadata.gz: 4d8b47306256c698e30c7950fc18a59551fb156b14bc6e077df323a27832af8125f567213ec066ec1c8e5f7295411a0a113823ef4a6c97df0bbf5a6d753fc851
-  data.tar.gz: 5152a07e2d3580c4de9fb477d36c8de6f1d3fae3a6e234a6c3a80318524cb8ae6fefaebd984501f63b3b5de79350c2d9b53eac92b133453aebd1c47ba4323619
+  metadata.gz: 3444e7a640af911e1f0eb67181503e0b87677847adacd6c0bf3a45c13ce8c8287b2b17ad56ba36d4fe301fe3a19aaf5b17856d3f9bceb1175002ed199d1eb774
+  data.tar.gz: d5a76df5b4ffd4f7483c6953d5c36479755f30efb3e19c822f1df41e459e6213c555c64324f6412df2a9b1ac5a4f003d5e525110c9e6f8e92389d655666fd5d7

data/CHANGELOG.md

@@ -1,4 +1,19 @@
-## Kanrisuru 0.8.12 (October 3, 20201)
+## Kanrisuru 0.8.16 (October 14, 20201)
+* Add functional test cases for `stream` and `path` modules
+* Create `expect_command`  helper for quick testing on raw command result
+
+## Kanrisuru 0.8.15 (October 12, 20201)
+* Move functional specs to integration. Anything that performs an actual network request will be under the integrations test.
+* Create a `StubNetwork` to quickly monkey patch the `Kanrisuru::Remote::Host` to simulate a `Net::SSH` channel request. Will add additional functionality for different simulations later on.
+* Start with testing the `stat` command as a functional test.
+
+## Kanrisuru 0.8.14 (October 8, 20201)
+* Update `Kanrisuru::Remote::Cluster` instantiation method to use array splat instead of passing array directly.
+
+## Kanrisuru 0.8.13 (October 4, 20201)
+* Fix `wc` command. Ensure result parsing is cast to integer values.
+
+## Kanrisuru 0.8.12 (October 4, 20201)
 * Refactor `rmdir` command to only work on empty directories. 
 
 ## Kanrisuru 0.8.11 (October 1, 20201)

data/README.md

@@ -48,7 +48,7 @@ result.path 					# => /home/ubuntu
 
 ### Cluster 
 ```ruby
-cluster = Kanrisuru::Remote::Cluster.new([{
+cluster = Kanrisuru::Remote::Cluster.new({
   host: 'host1', username: 'ubuntu', keys: ['~/.ssh/id_rsa']
 }, {
   host: 'host2', username: 'alice', keys: ['~/.ssh/id_rsa']
@@ -72,7 +72,7 @@ host.execute(command)
 command.success? #=> true
 command.to_s  #=> Linux
 
-cluster = Kanrisuru::Remote::Cluster.new([host, {host: 'host2', username: 'alice', keys: ['~/.ssh/id_rsa']}])
+cluster = Kanrisuru::Remote::Cluster.new(host, {host: 'host2', username: 'alice', keys: ['~/.ssh/id_rsa']})
 
 cluster.execute('uname') #=> {host: 'host1', result: 'Linux'}, {host: 'host2', result: 'Linux'}
 ```

data/lib/kanrisuru/core/file.rb

@@ -332,7 +332,7 @@ module Kanrisuru
         execute_shell(command)
 
         Kanrisuru::Result.new(command) do |cmd|
-          items = cmd.to_a
+          items = cmd.to_s.split
           FileCount.new(items[0].to_i, items[1].to_i, items[2].to_i)
         end
       end

data/lib/kanrisuru/core/stat.rb

@@ -66,10 +66,8 @@ module Kanrisuru
       end
 
       def stat(path, opts = {})
-        follow = opts[:follow]
-
         command = Kanrisuru::Command.new('stat')
-        command.append_flag('-L', follow)
+        command.append_flag('-L', opts[:follow])
         command.append_arg('-c', '%A,%b,%D,%F,%g,%G,%h,%i,%n,%s,%u,%U,%x,%y,%z')
         command << path
 

data/lib/kanrisuru/remote/cluster.rb

@@ -6,7 +6,7 @@ module Kanrisuru
       extend OsPackage::Collection
       include Enumerable
 
-      def initialize(hosts)
+      def initialize(*hosts)
         @hosts = {}
         hosts.each do |host_opts|
           add_host(host_opts)

data/lib/kanrisuru/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kanrisuru
-  VERSION = '0.8.12'
+  VERSION = '0.8.16'
 end

data/spec/functional/core/path_spec.rb

@@ -2,92 +2,45 @@
 
 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('.')
+StubNetwork.stub!
 
-        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
+RSpec.describe Kanrisuru::Core::Path do
+  let(:host) do
+    Kanrisuru::Remote::Host.new(
+      host: 'localhost',
+      username: 'ubuntu', 
+      keys: ['id_rsa']
+    )
+  end
 
-      it 'gets whoami' do
-        expect(host.whoami.user).to eq(host_json['username'])
-      end
+  it 'prepares ls command' do
+    expect_command(host.ls(path: '/etc'), 'ls -i -l /etc')
+    expect_command(host.ls(path: '/var/log', all: true, id: true), 'ls -i -l -a -n /var/log')
+  end
 
-      it 'gets pwd' do
-        expect(host.pwd.path).to eq(host_json['home'])
-      end
+  it 'prepares pwd command' do
+    expect_command(host.pwd, 'pwd')
+  end
 
-      it 'uses which to get path for bash' do
-        result = host.which('bash', all: true)
-        paths = result.map(&:path)
+  it 'prepares whoami command' do
+    expect_command(host.whoami, 'whoami')
+  end
 
-        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 'prepares which command' do
+    expect_command(host.which('which'), 'which which')
+    expect_command(host.which('pwd', all: true), 'which -a pwd')
+  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 'prepares realpath command' do
+    expect_command(host.realpath('/etc/os-release'), 'realpath /etc/os-release')
+    expect_command(host.realpath('/etc/os-release', strip: true), 'realpath /etc/os-release -s')
+  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
+  it 'prepares readlink command' do
+    expect_command(host.readlink('/etc/os-release'), 'readlink /etc/os-release')
+    expect_command(host.readlink('/etc/os-release', canonicalize: true), 'readlink -f /etc/os-release')
+    expect_command(host.readlink('/etc/os-release', canonicalize_existing: true), 'readlink -e /etc/os-release')
+    expect_command(host.readlink('/etc/os-release', canonicalize_missing: true), 'readlink -m /etc/os-release')
   end
+
 end

data/spec/functional/core/stat_spec.rb

@@ -2,97 +2,25 @@
 
 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)
+StubNetwork.stub!
 
-          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
+RSpec.describe Kanrisuru::Core::Stat do
+  let(:host) do
+    Kanrisuru::Remote::Host.new(
+      host: 'localhost',
+      username: 'ubuntu', 
+      keys: ['id_rsa']
+    )
+  end
 
-        expect(result.uid).to eq(1000)
-        expect(result.user).to eq(host_json['username'])
+  it 'prepares stat command' do
+    expect_command(host.stat('~/file1.txt'), 
+      'stat -c %A,%b,%D,%F,%g,%G,%h,%i,%n,%s,%u,%U,%x,%y,%z ~/file1.txt'
+    )
 
-        expect(result.fsize).to be >= 0
-      end
-    end
+    expect_command(host.stat('~/file2.txt', follow: true),
+      'stat -L -c %A,%b,%D,%F,%g,%G,%h,%i,%n,%s,%u,%U,%x,%y,%z ~/file2.txt'
+    )
   end
+
 end

data/spec/functional/core/stream_spec.rb

@@ -1,117 +1,109 @@
 # frozen_string_literal: true
 
+require 'spec_helper'
+
+StubNetwork.stub!
+
 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
+  let(:host) do
+    Kanrisuru::Remote::Host.new(
+      host: 'localhost',
+      username: 'ubuntu', 
+      keys: ['id_rsa']
+    )
+  end
+
+  it 'prepares head command' do
+    result = host.head('/var/log/syslog')
+    expect_command(result, 'head /var/log/syslog')
+
+    result = host.head('/var/log/syslog', bytes: 1024)
+    expect_command(result, 'head -c 1024 /var/log/syslog')
+
+    result = host.head('/var/log/syslog', lines: 50)
+    expect_command(result, 'head -n 50 /var/log/syslog')
+  end
+
+  it 'prepares tail command' do
+    result = host.tail('/var/log/syslog')
+    expect_command(result, 'tail /var/log/syslog' )
+
+    result = host.tail('/var/log/syslog', bytes: 1024)
+    expect_command(result, 'tail -c 1024 /var/log/syslog')
+
+    result = host.tail('/var/log/syslog', lines: 50)
+    expect_command(result, 'tail -n 50 /var/log/syslog' )
+  end
+
+  it 'prepares read_file_chunk command' do
+    result = host.read_file_chunk('/var/log/apache2/access.log', 10, 20)
+    expect_command(result, 'tail -n +10 /var/log/apache2/access.log | head -n 11')
+
+    result = host.read_file_chunk('/var/log/apache2/access.log', 0, 0)
+    expect_command(result, 'tail -n +0 /var/log/apache2/access.log | head -n 1')
+
+    expect {
+      host.read_file_chunk('file.log', 10, '20')
+    }.to raise_error(ArgumentError)
+
+    expect {
+      host.read_file_chunk('file.log', '10', 20)
+    }.to raise_error(ArgumentError)
+
+    expect {
+      host.read_file_chunk('file.log', 10, 9)
+    }.to raise_error(ArgumentError)
+
+    expect {
+      host.read_file_chunk('file.log', -1, 1)
+    }.to raise_error(ArgumentError)
+
+    expect {
+      host.read_file_chunk('file.log', 10, -2)
+    }.to raise_error(ArgumentError)
+  end
+
+  it 'prepares sed command' do
+    result = host.sed("~/file.txt", 'Cat', 'Dog')
+    expect_command(result, "sed 's/Cat/Dog/g' '~/file.txt'")
+
+    result = host.sed("~/file.txt", 'Cat', 'Doggz', in_place: true, new_file: '~/file2.txt', mode: 'write') 
+    expect_command(result, "sed -i 's/Cat/Doggz/g' '~/file.txt' > ~/file2.txt")
+
+    result = host.sed("~/file.txt", 'Cat', 'Dogo', regexp_extended: true, new_file: '~/file2.txt', mode: 'append')
+    expect_command(result, "sed -r 's/Cat/Dogo/g' '~/file.txt' >> ~/file2.txt")
+  end
+
+  it 'prepares echo command' do
+    expect_command(host.echo('Hello world') , "echo 'Hello world'")
+    expect_command(host.echo("Hello\\n world", backslash: true), "echo -e 'Hello\\n world'")
+
+    expect_command(host.echo('Hello world', new_file: '~/file1.txt', mode: 'write'),
+      "echo 'Hello world' > ~/file1.txt")
+    expect_command(host.echo("Goodbye", new_file: '~/file1.txt', mode: 'append'), 
+      "echo 'Goodbye' >> ~/file1.txt")
   end
+
+  it 'prepares cat command' do
+    expect_command(host.cat('/etc/group'), 'cat /etc/group')
+    expect_command(host.cat('/etc/group', show_all: true), 'cat -A /etc/group')
+    expect_command(host.cat('/etc/group', 
+      show_tabs: true, 
+      number: true, 
+      squeeze_blank: true, 
+      show_nonprinting: true,
+      show_ends: true,
+      number_nonblank: true
+    ), 'cat -T -n -s -v -E -b /etc/group')
+
+    expect_command(host.cat(['~/file1.txt', '~/file2.txt', '~/file3.txt']),
+      'cat ~/file1.txt ~/file2.txt ~/file3.txt')
+
+    expect_command(host.cat(['~/file1.txt', '~/file2.txt', '~/file3.txt'], mode: 'write', new_file: 'combined.txt'),
+      'cat ~/file1.txt ~/file2.txt ~/file3.txt > combined.txt')
+
+    expect_command(host.cat(['~/file1.txt', '~/file2.txt', '~/file3.txt'], mode: 'append', new_file: 'combined.txt'),
+      'cat ~/file1.txt ~/file2.txt ~/file3.txt >> combined.txt')
+  end
+
 end

data/spec/functional/os_package_spec.rb

@@ -111,7 +111,7 @@ RSpec.describe Kanrisuru::OsPackage do
     host = Kanrisuru::Remote::Host.new(host: '127.0.0.1', username: 'ubuntu', keys: ['~/.ssh/id_rsa'])
     host2 = Kanrisuru::Remote::Host.new(host: 'localhost', username: 'ubuntu', keys: ['~/.ssh/id_rsa'])
 
-    cluster = Kanrisuru::Remote::Cluster.new([host, host2])
+    cluster = Kanrisuru::Remote::Cluster.new(host, host2)
 
     expect(host).to respond_to(:tester)
     expect(host.tester).to eq('hello ubuntu')
@@ -125,7 +125,7 @@ RSpec.describe Kanrisuru::OsPackage do
     host = Kanrisuru::Remote::Host.new(host: '127.0.0.1', username: 'ubuntu', keys: ['~/.ssh/id_rsa'])
     host2 = Kanrisuru::Remote::Host.new(host: 'localhost', username: 'ubuntu', keys: ['~/.ssh/id_rsa'])
 
-    cluster = Kanrisuru::Remote::Cluster.new([host, host2])
+    cluster = Kanrisuru::Remote::Cluster.new(host, host2)
 
     expect(host).to respond_to(:asdf)
     expect(host.asdf).to respond_to(:tester)
@@ -151,7 +151,7 @@ RSpec.describe Kanrisuru::OsPackage do
     host2 = Kanrisuru::Remote::Host.new(host: 'centos-host', username: 'centos', keys: ['~/.ssh/id_rsa'])
     host3 = Kanrisuru::Remote::Host.new(host: 'opensuse-host', username: 'opensuse', keys: ['~/.ssh/id_rsa'])
 
-    cluster = Kanrisuru::Remote::Cluster.new([host1, host2, host3])
+    cluster = Kanrisuru::Remote::Cluster.new(host1, host2, host3)
 
     expect(host1).to respond_to(:output)
     expect(host2).to respond_to(:output)

data/spec/helper/expect_helpers.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+def expect_command(result, string)
+  expect(result.command.raw_command).to eq(
+    string
+  )
+end

data/spec/helper/stub_network.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class StubNetwork
+  class << self
+
+    def stub!
+      ## Stub out the execute_with_retries method to 
+      ## test functionality of host commands 
+      Kanrisuru::Remote::Host.class_eval do
+        private
+
+        def execute_with_retries(command)
+          command.handle_status(0) 
+          command.handle_data(nil)
+
+          command
+        end
+      end
+
+      Kanrisuru::Remote::Os.class_eval do
+        def initialize(host)
+          @host = host
+
+          @kernel_name       = 'Linux'
+          @kernel_version    = '#91-Ubuntu SMP Thu Jul 15 19:09:17 UTC 2021'
+          @operating_system  = 'GNU/Linux'
+          @hardware_platform = "x86_64"
+          @processor         = "x86_64"
+          @release           = "ubuntu"
+          @version           = 20.0
+        end
+      end
+
+      Kanrisuru::Result.class_eval do
+        def initialize(command, &block)
+          @command = command
+          @data = nil
+
+          @error = @command.to_a if @command.failure?
+        end
+      end
+    end 
+
+  end
+end

data/spec/{functional → integration}/core/file_spec.rb

@@ -349,10 +349,17 @@ RSpec.describe Kanrisuru::Core::File do
         expect(result.success?).to eq(true)
         expect(result).to respond_to(:lines, :words, :characters)
 
-        lines = result.lines
-        result = host.cat('/etc/hosts')
+        ## Need to remap data including newline chars to get byte size
+        data = host.cat('/etc/hosts').command.raw_result
+        doc = data.map(&:lines).flatten
 
-        expect(lines).to eq(result.to_a.length)
+        lines = doc.length
+        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

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/{functional → integration}/remote/cluster_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 RSpec.describe Kanrisuru::Remote::Cluster do
   context 'with ubuntu' do
     it 'gets hostname for cluster' do
-      cluster = described_class.new([{
+      cluster = described_class.new({
                                       host: 'localhost',
                                       username: 'ubuntu',
                                       keys: ['~/.ssh/id_rsa']
@@ -13,7 +13,7 @@ RSpec.describe Kanrisuru::Remote::Cluster do
                                       host: '127.0.0.1',
                                       username: 'ubuntu',
                                       keys: ['~/.ssh/id_rsa']
-                                    }])
+                                    })
 
       expect(cluster.hostname).to match([
                                           { host: 'localhost', result: 'ubuntu' },
@@ -24,7 +24,7 @@ RSpec.describe Kanrisuru::Remote::Cluster do
     end
 
     it 'can ping host cluster' do
-      cluster = described_class.new([{
+      cluster = described_class.new({
                                       host: 'localhost',
                                       username: 'ubuntu',
                                       keys: ['~/.ssh/id_rsa']
@@ -32,7 +32,7 @@ RSpec.describe Kanrisuru::Remote::Cluster do
                                       host: '127.0.0.1',
                                       username: 'ubuntu',
                                       keys: ['~/.ssh/id_rsa']
-                                    }])
+                                    })
 
       expect(cluster.ping?).to match([
                                        { host: 'localhost', result: true },

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
 
@@ -18,4 +21,4 @@ RSpec.configure do |config|
   config.expect_with :rspec do |c|
     c.syntax = :expect
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kanrisuru
 version: !ruby/object:Gem::Version
-  version: 0.8.12
+  version: 0.8.16
 platform: ruby
 authors:
 - Ryan Mammina
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-04 00:00:00.000000000 Z
+date: 2021-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -173,34 +173,39 @@ 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