kanrisuru 0.8.14 → 0.8.18

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

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/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)