kanrisuru 0.8.13 → 0.8.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2465d4419a5fa15bc4ec736c6064e48386be6e130d4a934404b8a1b0f7eaaa0
-  data.tar.gz: 5441c0ae297aad2fdc7f08686eca97585793f747aaf92b32339da66c4343f3cf
+  metadata.gz: 3fddbe577acc9083ead480c1c69dad8e74c3b00c6a66cd770655b626bf022cb7
+  data.tar.gz: dac3e1bfc3ddcb59eff30b620e080210f23e0a2586ab0b38031db01920504c90
 SHA512:
-  metadata.gz: 328fdfb44f1d0b18f4bd1fb49ab54779fb464e3f8948a8600f2d2e5cdddfe8ac351fa4499ee0f981a8f12fd262bf1d7757f71d721dafbf447834c8d6ff17ac6f
-  data.tar.gz: 20c59fd7d9e2e57e356beecf55809c3cbb009fe5d0e8b5692088731ed6bac3665e1e88f6e162d6cda1b7874e8a9a30e30ef52a6c5572cdfbd33f4328ee402eda
+  metadata.gz: 43537168eee374dbe372259ea263a139dd9999ad242666e1f036adecee96df6d1040e1a03cc083ca9e1ba6704c61d29c6146e97356951564927278f61e14762a
+  data.tar.gz: 45184c4eeafd9447b4e46f323a65d545f666eaeac33bd3e1e19f1d308fc1555ff6042850eecad47368ce5927fa8065b55e6cb141ca09731b3dd190f79fe0134a

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## Kanrisuru 0.8.17 (October 16 2021)
+* Add functional test cases for `transfer` module
+* Update wget command to accept hash for `headers` opt.
+
+## Kanrisuru 0.8.16 (October 14, 2021)
+* 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.
 

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/disk.rb

@@ -23,7 +23,7 @@ module Kanrisuru
         :name, :label, :uuid, :type, :uuid_sub, :label_fatboot, :version, :usage,
         :part_uuid, :part_entry_scheme, :part_entry_uuid, :part_entry_type,
         :part_entry_number, :part_entry_offset, :part_entry_size, :part_entry_disk,
-        :minimum_io_size, :physical_sector_size, :logical_sector_size, 
+        :minimum_io_size, :physical_sector_size, :logical_sector_size
       )
 
       def du(opts = {})

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/core/transfer.rb

@@ -124,7 +124,6 @@ module Kanrisuru
         command.append_flag('--no-cookies', opts[:no_cookies])
         command.append_flag('--keep-session-cookies', opts[:keep_session_cookies])
         command.append_flag('--ignore-length', opts[:ignore_length])
-        command.append_arg('--header', opts[:header])
         command.append_arg('--max-redirect', opts[:max_redirect])
         command.append_arg('--proxy-user', opts[:proxy_user])
         command.append_arg('--proxy-password', opts[:proxy_password])
@@ -132,6 +131,18 @@ module Kanrisuru
         command.append_flag('--save-headers', opts[:save_headers])
         command.append_arg('--user-agent', opts[:user_agent])
 
+        headers = opts[:headers]
+        if Kanrisuru::Util.present?(headers)
+          if headers.instance_of?(Hash)
+            headers.each do |key, value|
+              header = "'#{key}: #{value}'"
+              command.append_arg('--header', header)
+            end
+          elsif headers.instance_of?(String)
+            command.append_arg('--header', headers)
+          end
+        end
+
         post_data = opts[:post_data]
 
         if Kanrisuru::Util.present?(post_data)

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.13'
+  VERSION = '0.8.17'
 end

data/spec/functional/core/path_spec.rb

@@ -2,92 +2,44 @@
 
 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,22 @@
 
 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,108 @@
 # 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 do
+      host.read_file_chunk('file.log', 10, '20')
+    end.to raise_error(ArgumentError)
+
+    expect do
+      host.read_file_chunk('file.log', '10', 20)
+    end.to raise_error(ArgumentError)
+
+    expect do
+      host.read_file_chunk('file.log', 10, 9)
+    end.to raise_error(ArgumentError)
+
+    expect do
+      host.read_file_chunk('file.log', -1, 1)
+    end.to raise_error(ArgumentError)
+
+    expect do
+      host.read_file_chunk('file.log', 10, -2)
+    end.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