kanrisuru 0.1.0 → 0.2.1

data/spec/functional/remote/env_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Remote::Env 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 'sets env var' do
+        host.env['HELLO'] = 'world'
+        host.env['KANRISURU'] = 'manage'
+
+        expect(host.env['KANRISURU']).to eq('manage')
+        expect(host.env.to_s).to eq('export HELLO=world; export KANRISURU=manage;')
+        expect(host.env.to_h).to eq({ 'HELLO' => 'world', 'KANRISURU' => 'manage' })
+
+        command = Kanrisuru::Command.new('echo $KANRISURU $HELLO')
+        host.execute_shell(command)
+
+        expect(command.to_s).to eq('manage world')
+      end
+    end
+  end
+end

data/spec/functional/remote/fstab_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+RSpec.describe Kanrisuru::Remote::Fstab 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 'parses fstab' do
+        host.su('root')
+        fstab = host.fstab
+
+        entry =
+          case os_name
+          when 'opensuse'
+            fstab['/dev/vda3']
+          when 'sles'
+            fstab['/dev/xvda1']
+          else
+            fstab['/dev/vda1']
+          end
+
+        expect(fstab.get_entry(entry.uuid)).to eq(entry)
+        expect(fstab.get_entry(entry.label)).to eq(entry)
+
+        fstab << Kanrisuru::Remote::Fstab::Entry.new(
+          device: '/dev/vda14',
+          mount_point: '/mnt/test',
+          type: 'ext4',
+          opts: { defaults: true },
+          freq: '0',
+          passno: '0'
+        )
+
+        entry = fstab['/dev/vda14']
+        expect(entry.to_s).to eq('/dev/vda14 /mnt/test ext4 defaults 0 0')
+        expect(entry.device).to eq('/dev/vda14')
+        expect(entry.mount_point).to eq('/mnt/test')
+        expect(entry.type).to eq('ext4')
+        expect(entry.opts.to_s).to eq('defaults')
+        expect(entry.freq).to eq('0')
+        expect(entry.passno).to eq('0')
+
+        entry.opts['defaults'] = false
+        entry.opts['user'] = true
+        entry.opts['exec'] = true
+        entry.opts['rw'] = true
+        entry.opts['auto'] = true
+        entry.opts['relatime'] = true
+        entry.opts['async'] = true
+        entry.opts[:nodev] = true
+        entry.opts[:nosuid] = true
+        entry.opts[:owner] = true
+        entry.opts[:group] = true
+
+        entry.mount_point = '/mnt/test3'
+
+        expect(fstab['/dev/vda14'].to_s).to eq '/dev/vda14 /mnt/test3 ext4 ' \
+          'user,exec,rw,auto,relatime,async,nodev,nosuid,owner,group 0 0'
+
+        fstab << '/dev/vda16 /mnt/test2 fat defaults,user,uid=1000,gid=1000 0 0'
+        expect(fstab['/dev/vda16'].to_s).to eq('/dev/vda16 /mnt/test2 fat defaults,user,uid=1000,gid=1000 0 0')
+      end
+    end
+  end
+end

data/spec/functional/remote/host_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Remote::Host do
+  TestHosts.each_os do |os_name|
+    context "with #{os_name}" do
+      let(:host_json) { TestHosts.host(os_name) }
+      let(:host) do
+        described_class.new(
+          host: host_json['hostname'],
+          username: host_json['username'],
+          keys: [host_json['ssh_key']]
+        )
+      end
+
+      after do
+        host.disconnect
+      end
+
+      it 'can ping localhost' do
+        expect(host.ping?).to eq(true)
+      end
+
+      it 'gets hostname' do
+        expect(host.hostname).to eq(host_json['hostname'])
+      end
+
+      it 'changes directories' do
+        expect(host.pwd.path).to eq(host_json['home'])
+
+        host.cd('../')
+        expect(host.pwd.path).to eq('/home')
+
+        host.cd('../')
+        expect(host.pwd.path).to eq('/')
+
+        host.cd('~')
+
+        expect(host.pwd.path).to eq(host_json['home'])
+
+        host.su('root')
+        host.cd('/root/../etc')
+
+        result = host.ls
+        paths = result.map(&:path)
+
+        expect(paths).to include('hosts')
+        expect(paths).to include('shadow')
+        expect(paths).to include('ssh')
+
+        host.cd('default')
+        expect(host.pwd.path).to eq('/etc/default')
+
+        host.su(host_json['username'])
+
+        host.cd('.')
+        expect(host.pwd.path).to eq('/etc/default')
+
+        result = host.ls(path: '/home')
+        expect(result[0].path).to eq(host_json['username'])
+
+        host.cd('/bin')
+        expect(host.pwd.path).to eq('/bin')
+      end
+    end
+  end
+end

data/spec/functional/remote/memory_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Remote::Memory 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 'gets memory details' do
+        expect(host.memory.total(:gb)).to be >= 0.5
+        expect(host.memory.free(:mb)).to be >= 10.0
+        expect(host.memory.swap).to be_instance_of(Integer)
+        expect(host.memory.swap_free).to be_instance_of(Integer)
+      end
+    end
+  end
+end

data/spec/functional/remote/os_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Remote::Os 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 'detects os specs' do
+        expect(host.os.kernel).to eq(host_json['kernel'])
+        expect(host.os.processor).to eq('x86_64')
+
+        case os_name
+        when 'opensuse'
+          expect(host.os.release).to eq('opensuse-leap')
+        else
+          expect(host.os.release).to eq(os_name)
+        end
+
+        expect(host.os.version).to be > 0.00
+
+        case os_name
+        when 'debian'
+          expect(host.os.version).to eq(10)
+        when 'ubuntu'
+          expect(host.os.version).to eq(18.04)
+        when 'fedora'
+          expect(host.os.version).to eq(32)
+        when 'centos'
+          expect(host.os.version).to eq(7)
+        when 'opensuse'
+          expect(host.os.version).to eq(15.2)
+        when 'rhel'
+          expect(host.os.version).to eq(7.9)
+        end
+      end
+
+      it 'gets uname' do
+        expect(host.os.uname).to eq(host_json['kernel'])
+      end
+
+      it 'gets uname details' do
+        host.os.uname(
+          kernel_name: true,
+          hardware_platform: true,
+          operating_system: true
+        )
+      end
+    end
+  end
+end

data/spec/functional/remote/remote_file_spec.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+RSpec.describe Kanrisuru::Remote::File do
+  module Kanrisuru
+    module Remote
+      Class.new(File) do
+        READ_FILE_SIZE = 25_000
+      end
+    end
+  end
+
+  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.rmdir("#{host_json['home']}/extract-tar-files") if host.dir?("#{host_json['home']}/extract-tar-files")
+        host.disconnect
+      end
+
+      it 'loads a remote file to edit' do
+        file = host.file("#{spec_dir}/remote-file.txt")
+
+        expect(file).to be_instance_of(described_class)
+        expect(file.exists?).to eq(false)
+        expect(file.expand_path).to eq('')
+
+        file.touch
+
+        expect(file.exists?).to eq(true)
+        expect(file.zero?).to eq(true)
+        expect(file.user).to eq(host_json['username'])
+
+        case os_name
+        when 'opensuse', 'sles'
+          expect(file.group).to eq('users')
+        else
+          expect(file.group).to eq(host_json['username'])
+        end
+
+        expect(file.expand_path).to eq("#{spec_dir}/remote-file.txt")
+
+        file.append do |f|
+          f << 'Hello world'
+          f << 'this is a test!'
+        end
+
+        lines = file.map { |line| line }
+        expect(lines).to eq(['Hello world', 'this is a test!'])
+        expect(file.zero?).to eq(false)
+
+        file.prepend do |f|
+          f << 'Lines exist'
+          f << 'at the beginning...'
+        end
+
+        expect(file[0]).to eq('Lines exist')
+        expect(file[3]).to eq('this is a test!')
+
+        lines = file.map { |line| line }
+        expect(lines).to eq(['Lines exist', 'at the beginning...', 'Hello world', 'this is a test!'])
+
+        expect(file.delete).to eq(true)
+        expect(file.exists?).to eq(false)
+      end
+
+      it 'finds and updates file' do
+        file = host.file("#{spec_dir}/hosts.conf.test")
+
+        file.touch
+
+        file.write do |f|
+          f << '127.0.0.1 localhost'
+          f << '127.0.1.1 ubuntu'
+          f << ''
+          f << '# The following lines are desirable for IPv6 capable hosts'
+          f << '::1 ip6-localhost ip6-loopback'
+          f << 'fe00::0 ip6-localnet'
+          f << 'ff00::0 ip6-mcastprefix'
+          f << 'ff02::1 ip6-allnodes'
+          f << 'ff02::2 ip6-allrouters'
+          f << 'ff02::3 ip6-allhosts'
+        end
+
+        expect(file[2]).to eq('')
+        file.find_and_append(/^127.0.1.1 ubuntu/, '8.8.8.8 rickroll.com')
+        expect(file[2]).to eq('8.8.8.8 rickroll.com')
+
+        expect(file[1]).to eq('127.0.1.1 ubuntu')
+        file.find_and_prepend(/^127.0.1.1 ubuntu/, '1.1.1.1 nevergoingtoletyoudown.io')
+        expect(file[1]).to eq('1.1.1.1 nevergoingtoletyoudown.io')
+
+        file.prepend do |f|
+          f << '# Generated by Kanrisuru'
+        end
+
+        file.find_and_replace_line(/#/, '# Rick Astley was here')
+        expect(file[0]).to eq('# Rick Astley was here')
+        expect(file[6]).to eq('# Rick Astley was here')
+
+        file.find_and_replace_value(/\slocalhost/, ' nevergoingtogiveyouup.biz')
+        expect(file[1]).to eq('127.0.0.1 nevergoingtogiveyouup.biz')
+
+        file.find_and_remove(/^::/)
+        file.find_and_remove(/^ff/)
+        file.find_and_remove(/^fe/)
+
+        expect(file.lines).to eq(7)
+      end
+
+      it 'iterates with chunking' do
+        file = host.file("#{spec_dir}/remote-file-large.txt")
+
+        expect(file.exists?).to eq(false)
+
+        file.touch
+
+        file.write do |f|
+          (0...50_000).each do |i|
+            f << "Line: #{i}"
+          end
+        end
+
+        line = file.find do |f|
+          f == 'Line: 1111'
+        end
+
+        expect(line).to eq('Line: 1111')
+
+        expect(file[0]).to eq('Line: 0')
+        expect(file[5]).to eq('Line: 5')
+        expect(file[28_445]).to eq('Line: 28445')
+        expect(file[49_999]).to eq('Line: 49999')
+        expect { file[50_000] }.to raise_error(ArgumentError)
+
+        file.prepend do |f|
+          f << 'Hello large file'
+        end
+
+        expect(file[0]).to eq('Hello large file')
+        expect(file[1]).to eq('Line: 0')
+        expect(file[28_446]).to eq('Line: 28445')
+        expect(file[50_000]).to eq('Line: 49999')
+      end
+    end
+  end
+end