kanrisuru 0.8.14 → 0.8.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1537cdde3ded7563e59018ddb94f1c05bb17ff486c87f6113eaa1800b6f7c338
-  data.tar.gz: 571b0fef3b4d780d3fac4f485f7f1b1dd14bd3c73253a7b5649ae7e86975fd81
+  metadata.gz: 6e813c072c86f8c0b076a90d2b8136fb9bc64271df996c6c54c4e2bf6c7b5806
+  data.tar.gz: a763991aa4979eb17c1c0e123d80c2057552b2caf9be24358b39659a292e241d
 SHA512:
-  metadata.gz: 2351ae7e335b61a1362c15a08540977c5d366ae2c441882f4feff32bc7939da71312dc5f380fa707a6c3cb187e81d413d558ae55e31e395d069e1a3c5e3f2a08
-  data.tar.gz: 2fbb6a9649eb2a67c46bc0a617cd22965738dfcbb092b4b99da588ae70518b4a0dfc79aa2da55c58d53f760170a5c33c844a86aae97f56eeed4628c735a65546
+  metadata.gz: 52be23f3a72de4d6f9633e8b01470949035aec9be4123a87bbfc2e4a93120c463fa1470a69030ad696fbabb389ce60890b64925d129654f513a4baa392846ca8
+  data.tar.gz: 749dfdd773a1256575ab262a73f56be48ec6caaef21e8499ea9fb42d9cb2ae79e569d3f8b9581aa153d9d7031eef88d46c64a9a68900d27e00cf85e28885d45d

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 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.
 

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

@@ -10,6 +10,7 @@ module Kanrisuru
       os_define :linux, :find
 
       FilePath = Struct.new(:path)
+      REGEX_TYPES = ['emacs', 'posix-awk', 'posix-basic', 'posix-egrep', 'posix-extended']
 
       def find(opts = {})
         paths      = opts[:paths]
@@ -32,7 +33,7 @@ module Kanrisuru
           if paths.instance_of?(Array)
             paths = paths.join(' ')
           elsif paths.class != String
-            raise 'Invalid paths type'
+            raise ArgumentError, 'Invalid paths type'
           end
 
           command << paths
@@ -64,13 +65,19 @@ module Kanrisuru
         command.append_arg('-cmin', opts[:cmin])
         command.append_arg('-mmin', opts[:mmin])
 
-        command.append_arg('-regex', "'#{regex}'") if Kanrisuru::Util.present?(regex)
+        if Kanrisuru::Util.present?(opts[:regex_type])
+          unless REGEX_TYPES.include?(opts[:regex_type])
+            raise ArgumentError, 'invalid regex type'
+          end
 
-        if size.instance_of?(String)
-          match = Regexp.new(/^([-+]+)\s*?(\d+)([bcwkMG])$/).match(size)
+          command.append_arg('-regextype', opts[:regex_type])
+        end
 
-          raise ArgumentError, "invalid size string: '#{@size}'" if match.nil? || match.captures.include?(nil)
+        command.append_arg('-regex', "'#{regex}'") if Kanrisuru::Util.present?(regex)
 
+        if size.instance_of?(String)
+          regex = Regexp.new(/^([-+])?(\d+)([bcwkMG])*$/)
+          raise ArgumentError, "invalid size string: '#{@size}'" unless regex.match?(size) 
           command.append_arg('-size', size)
         elsif size.instance_of?(Integer)
           command.append_arg('-size', size)

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

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

data/spec/functional/core/find_spec.rb

@@ -2,51 +2,162 @@
 
 require 'spec_helper'
 
+StubNetwork.stub!
+
 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
+  let(:host) do
+    Kanrisuru::Remote::Host.new(
+      host: 'localhost',
+      username: 'ubuntu',
+      keys: ['id_rsa']
+    )
+  end
+
+  it 'prepares find command' do
+    expect_command(host.find, "find")
+
+    expect_command(host.find(follow: 'never'), "find -P")
+    expect_command(host.find(follow: 'always'), "find -L")
+    expect_command(host.find(follow: 'command'), "find -H")
+
+    expect_command(host.find(paths: '/etc'), "find /etc")
+    expect_command(host.find(paths: ['/etc', '/var', '/home']), "find /etc /var /home")
+
+    expect {
+      host.find(paths: 1)
+    }.to raise_error(ArgumentError)
+
+    expect_command(host.find(paths: '/', 
+        executable: true,
+        empty: true,
+        readable: true,
+        writeable: true,
+        nogroup: true,
+        nouser: true,
+        mount: true
+      ), 
+      "find / -executable -empty -readable -nogroup -nouser -mount"
+    )
+
+    expect_command(host.find(paths: '/', 
+        path: "/lib",
+        name: '*.so',
+        gid: 0,
+        uid: 0,
+        user: 'root',
+        group: 'root',
+        links: 2,
+        mindepth: 0,
+        maxdepth: 100   
+      ),
+      "find / -path /lib -name *.so -gid 0 -uid 0 -user root -group root -links 2 -maxdepth 100 -mindepth 0"
+    )
+
+    expect_command(host.find(paths: '/var/log',
+        atime: '+1',
+        ctime: '+2',
+        mtime: '+3',
+        amin: '100',
+        cmin: '200',
+        mmin: '300'
+      ),
+      "find /var/log -atime +1 -ctime +2 -mtime +3 -amin 100 -cmin 200 -mmin 300"
+    )
+
+    expect_command(host.find(
+        paths: '/dev', 
+        regex: '/dev/tty[0-9]*'
+      ), 
+      "find /dev -regex '/dev/tty[0-9]*'"
+    )
+
+    expect_command(host.find(
+        paths: '/dev', 
+        regex_type: 'posix-egrep',
+        regex: '/dev/tty[0-9]*'
+      ), 
+      "find /dev -regextype posix-egrep -regex '/dev/tty[0-9]*'"
+    )
+
+    expect_command(host.find(
+        paths: '/var/log',
+        size: 100
+      ),
+      "find /var/log -size 100"
+    )
+
+    expect_command(host.find(
+        paths: '/var/log',
+        size: "100"
+      ),
+      "find /var/log -size 100"
+    )
+    
+    expect {
+      host.find(size: "100n")
+    }.to raise_error(ArgumentError)
+
+    expect_command(host.find(
+        paths: '/var/log',
+        size: "-100k"
+      ),
+      "find /var/log -size -100k"
+    )
+
+    expect_command(host.find(
+        paths: '/var/log',
+        size: "+10M"
+      ),
+      "find /var/log -size +10M"
+    )
+
+    expect_command(host.find(
+        paths: "/dev",
+        type: 'directory' 
+      ),
+      "find /dev -type d"
+    )
+
+    expect_command(host.find(
+        paths: "/dev",
+        type: 'file' 
+      ),
+      "find /dev -type f"
+    )
+
+    expect_command(host.find(
+        paths: "/dev",
+        type: 'symlinks' 
+      ),
+      "find /dev -type l"
+    )
+
+    expect_command(host.find(
+        paths: "/dev",
+        type: 'block'
+      ),
+      "find /dev -type b"
+    )
+
+    expect_command(host.find(
+        paths: "/dev",
+        type: 'character'
+      ),
+      "find /dev -type c"
+    )
+
+    expect_command(host.find(
+        paths: "/dev",
+        type: 'pipe'
+      ),
+      "find /dev -type p"
+    )
+
+    expect_command(host.find(
+        paths: "/dev",
+        type: 'socket'
+      ),
+      "find /dev -type s"
+    )
   end
 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