kanrisuru 0.8.13 → 0.8.17

data/spec/functional/core/transfer_spec.rb

@@ -2,107 +2,180 @@
 
 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
+StubNetwork.stub!
+
+RSpec.describe Kanrisuru::Core::Stat do
+  let(:host) do
+    Kanrisuru::Remote::Host.new(
+      host: 'localhost',
+      username: 'ubuntu', 
+      keys: ['id_rsa']
+    )
+  end
+
+  it 'prepares wget command' do
+    url = 'https://rubygems.org'
+
+    expect_command(host.wget(url),
+      "wget #{url}"
+    )
+
+    ## Output options
+    expect_command(host.wget(url, 
+      quiet: true, verbose: false, log_file: '/var/log/wget.log'),
+      "wget --quiet --no-verbose --output-file /var/log/wget.log #{url}"
+    )
+
+    expect_command(host.wget(url, 
+      verbose: true, append_log_file: '/var/log/wget.log'),
+      "wget --verbose --append-output /var/log/wget.log #{url}"
+    )
+
+    ## Download options
+    expect_command(host.wget(url,
+        bind_address: '0.0.0.0', 
+        retries: 3, 
+        output_document: '/home/ubuntu/index.html',
+        no_clobber: true,
+        timeout: 30,
+        dns_timeout: 60,
+        connect_timeout: 60,
+        read_timeout: 15,
+        limit_rate: '120k',
+        wait: 5, 
+        waitretry: 15,
+        random_wait: true, 
+        no_proxy: true,
+        no_dns_cache: true
+      ),
+      "wget --bind-address 0.0.0.0 --tries 3 --output-document /home/ubuntu/index.html --no-clobber --timeout 30 --dns-timeout 60 --connect-timeout 60 --read-timeout 15 --limit-rate 120k --wait 5 --waitretry 15 --random-wait --no-proxy --no-dns-cache https://rubygems.org"
+    )
+
+    ## Other Options
+    expect_command(host.wget(url,
+        quota: 'inf',
+        family: 'inet',
+        restrict_file_names: ['unix', 'ascii', 'lowercase', 'uppercase'],
+        retry_connrefused: true,
+        user: 'admin',
+        password: 'admin',
+        no_iri: true,
+      ),
+      "wget --quota inf --restrict-file-names unix,ascii,lowercase,uppercase --inet4-only --retry-connrefused --user admin --password admin --no-iri #{url}"
+    )
+
+    ## Directories
+    expect_command(host.wget(url,
+        no_directories: true,
+        no_host_directories: true,
+        cut_dirs: 3,
+        directory_prefix: '~/downloads/'
+      ),
+    "wget --no-directories --no-host-directories --cut-dirs 3 --directory-prefix ~/downloads/ #{url}"
+    )
+
+    ## HTTP
+    expect_command(host.wget(url,
+        default_page: 'index.html',
+        adjust_extension: true,
+        http_user: 'admin',
+        http_password: 'admin',
+        load_cookies: '~/cookies.txt',
+        save_cookies: '~/cookies.txt',
+        no_cache: true,
+        keep_session_cookies: true,
+        ignore_length: true,
+        headers: {
+          'Accept-Language' => 'hr',
+          'Authorization' => 'Bearer 1234' 
+        },
+        max_redirect: 5,
+        proxy_user: 'admin',
+        proxy_password: '12345678'
+      ),
+      "wget --default-page index.html --adjust-extension --http-user admin --http-password admin --load-cookies ~/cookies.txt --save-cookies ~/cookies.txt --no-cache --keep-session-cookies --ignore-length --max-redirect 5 --proxy-user admin --proxy-password 12345678 --header 'Accept-Language: hr' --header 'Authorization: Bearer 1234' #{url}"
+    )
+
+    expect_command(host.wget(url,
+        post_data: {
+          url: "https://example.com?param=123"
+        },
+        content_disposition: true,
+        secure_protocol: 'SSLv3',
+        no_check_certificate: true,
+      ),
+      "wget --post-data url=https%3A%2F%2Fexample.com%3Fparam%3D123 --content-disposition --secure-protocol SSLv3 --no-check-certificate #{url}"
+    )
+
+    expect {
+      host.wget(url, secure_protocol: 'SSL')
+    }.to raise_error(ArgumentError)
+
+    expect_command(host.wget(url,
+        certificate: '~/cert.pem',
+        certificate_type: 'PEM',
+        private_key: '~/key.pem',
+        private_key_type: 'PEM',
+        ca_certificate: '~/ca.pem',
+        random_file: '~/random'
+      ),
+      "wget --certificate ~/cert.pem --certificate-type PEM --private-key ~/key.pem --private-key-type PEM --ca-certificate ~/ca.pem --random-file ~/random #{url}"
+    )
+
+    expect_command(host.wget(url,
+        certificate: '~/cert.pem',
+        certificate_type: 'PEM',
+        private_key: '~/key.pem',
+        private_key_type: 'PEM',
+        ca_certificate: '~/ca.pem',
+        random_file: '~/random'
+      ),
+      "wget --certificate ~/cert.pem --certificate-type PEM --private-key ~/key.pem --private-key-type PEM --ca-certificate ~/ca.pem --random-file ~/random #{url}"
+    )
+
+    ## FTP
+    expect_command(host.wget(url, 
+        ftp_user: 'admin',
+        ftp_password: '12345678',
+        no_remove_listing: true,
+        no_glob: true,
+        no_passive_ftp: true,
+        retr_symlinks: true
+      ),
+      "wget --ftp-user admin --ftp-password 12345678 --no-remove-listing --no-glob --no-passive-ftp --retr-symlinks #{url}"
+    )
+
+    ## Recursive Retrieval
+    expect_command(host.wget(url,
+        recursive: true,
+        depth: 10,
+        delete_after: true,
+        convert_links: true,
+        backup_converted: true,
+        mirror: true,
+        page_requisites: true,
+        strict_comments: true
+      ),
+      "wget --recursive --level 10 --delete-after --convert-links --backup-converted --mirror --page-requisites --strict-comments #{url}"
+    )
+
+    ## Recursive Accept/Reject
+    expect_command(host.wget(url,
+        accept_list: ['.txt', '.html'],
+        reject_list: ['.csv'],
+        domain_list: ['example.com'],
+        exclude_domain_list: ['hackernews.com'],
+        follow_tags: ['a', 'div', 'span'],
+        ignore_tags: ['area', 'link'],
+        include_directories: ['/gems'],
+        exclude_directories: ['/releases'],
+        follow_ftp: true,
+        ignore_case: true,
+        span_hosts: true,
+        relative: true,
+        no_parent: true
+      ),
+      "wget --accept .txt,.html --reject .csv --domains example.com --exclude-domains hackernews.com --follow-tags a,div,span --ignore-tags area,link --include-directories /gems --exclude-directories /releases --follow-ftp --ignore-case --span-hosts --relative --no-parent #{url}"
+    )
   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,8 @@
+# frozen_string_literal: true
+
+def expect_command(result, string)
+  puts result.command.raw_command
+  expect(result.command.raw_command).to eq(
+    string
+  )
+end

data/spec/helper/stub_network.rb

@@ -0,0 +1,43 @@
+# 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)
+          @command = command
+          @data = nil
+
+          @error = @command.to_a if @command.failure?
+        end
+      end
+    end
+  end
+end

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

@@ -41,7 +41,7 @@ RSpec.describe Kanrisuru::Core::Disk do
           :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
         )
       end
 

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

@@ -41,7 +41,10 @@ RSpec.describe Kanrisuru::Core::File do
         )
 
         host.rm("#{host_json['home']}/.kanrisuru_spec_files", force: true, recursive: true)
-        host.rm("#{host_json['home']}/extract-tar-files", force: true, recursive: true) if host.dir?("#{host_json['home']}/extract-tar-files")
+        if host.dir?("#{host_json['home']}/extract-tar-files")
+          host.rm("#{host_json['home']}/extract-tar-files", force: true,
+                                                            recursive: true)
+        end
         host.disconnect
       end
 
@@ -68,9 +71,9 @@ RSpec.describe Kanrisuru::Core::File do
         expect(mode.symbolic).to eq('-rwxr--r--')
         expect(mode.to_i).to eq(0o744)
 
-        expect {
+        expect do
           host.chmod(path, 600)
-        }.to raise_error(ArgumentError)
+        end.to raise_error(ArgumentError)
       end
 
       it 'changes file owner and group' do
@@ -338,7 +341,7 @@ RSpec.describe Kanrisuru::Core::File do
         ## Can't delete non empty dir
         result = host.rmdir("#{spec_dir}/directory")
         expect(result).to be_failure
-       
+
         result = host.rmdir("#{spec_dir}/directory/3")
         expect(result).to be_success
       end
@@ -355,7 +358,7 @@ RSpec.describe Kanrisuru::Core::File do
 
         lines = doc.length
         words = doc.map(&:split).flatten
-        chars = doc.map(&:length).flatten 
+        chars = doc.map(&:length).flatten
 
         expect(result.lines).to eq(doc.length)
         expect(result.words).to eq(words.length)

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