kanrisuru 0.1.0 → 0.2.1

data/spec/functional/core/system_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Core::System 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 environment variables' do
+        result = host.load_env
+
+        expect(result.success?).to be(true)
+        expect(result.data).to be_instance_of(Hash)
+      end
+
+      it 'gets uptime' do
+        result = host.uptime
+        expect(result.success?).to eq(true)
+
+        expect(result).to respond_to(
+          :boot_time, :uptime, :seconds,
+          :hours, :minutes, :days
+        )
+
+        expect(result.seconds).to be > 0
+        expect(result.minutes).to be >= 0
+        expect(result.hours).to be >= 0
+        expect(result.days).to be >= 0
+      end
+
+      it 'kills pids' do
+        command = 'sleep 100000 > /dev/null 2>&1 &'
+
+        host.execute_shell("nohup #{command}")
+        result = host.ps(user: host_json['username'])
+        expect(result.success?).to eq(true)
+
+        process = result.select do |proc|
+          proc.command == 'sleep 100000'
+        end
+
+        pids = process.map(&:pid)
+        result = host.kill('SIGKILL', pids)
+        expect(result.success?).to eq(true)
+
+        result = host.ps(user: host_json['username'])
+        process = result.select do |proc|
+          proc.command == 'sleep 100000'
+        end
+
+        expect(process).to be_empty
+      end
+
+      it 'gets process details' do
+        result = host.ps
+
+        expect(result.data).to be_instance_of(Array)
+        process = result[0]
+
+        expect(process).to respond_to(
+          :uid, :user, :gid, :group,
+          :pid, :ppid, :cpu_usage, :memory_usage,
+          :stat, :priority, :flags, :policy_abbr, :policy,
+          :cpu_time, :command
+        )
+
+        result = host.ps(user: [host_json['username']])
+
+        expect(result.data).to be_instance_of(Array)
+
+        process = result.find do |proc|
+          proc.command == result.command.raw_command
+        end
+
+        expect(process.command).to eq(result.command.raw_command)
+      end
+
+      it 'gets information for users' do
+        result = host.who
+        expect(result.success?).to eq(true)
+      end
+    end
+  end
+end

data/spec/functional/core/transfer_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+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
+  end
+end

data/spec/functional/core/user_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Core::User 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
+
+      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.su('root')
+        host.user?('rails')
+        host.delete_user('rails').inspect if host.user?('rails')
+        host.rmdir('/home/rails') if host.dir?('/home/rails')
+        host.disconnect
+      end
+
+      it 'gets uid for user' do
+        expect(host.get_uid(host_json['uername']).to_i).to eq(1000)
+        expect(host.get_uid('asdf').to_i).to eq(nil)
+      end
+
+      it 'gets a user details' do
+        result = host.get_user(host_json['username'])
+        expect(result.uid).to eq(1000)
+        expect(result.name).to eq(host_json['username'])
+        expect(result.home.path).to eq(host_json['home'])
+
+        case os_name
+        when 'opensuse', 'sles'
+          expect(result.groups[0]).to have_attributes(gid: 100, name: 'users')
+        else
+          expect(result.groups[0]).to have_attributes(gid: 1000, name: host_json['username'])
+        end
+      end
+
+      it 'manages a user' do
+        ## Need priviledge escalation to manage group
+        host.su('root')
+
+        result = host.create_user('rails', password: '123456', groups: %w[mail tty])
+        expect(result.success?).to eq(true)
+        expect(result.uid).to eq(1001)
+        expect(result.groups.length).to eq(3)
+        expect(result.shell.path).to eq('/bin/false')
+        expect(result.home.path).to eq('/home/rails')
+
+        result = host.update_user('rails', uid: 1002, shell: '/bin/bash', groups: ['audio'], append: true)
+
+        expect(result.uid).to eq(1002)
+        expect(result.shell.path).to eq('/bin/bash')
+        expect(result.groups.length).to eq(4)
+
+        expect(host.delete_user('rails').success?).to eq(true) if host.user?('rails')
+      end
+    end
+  end
+end

data/spec/functional/os_package_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module Kanrisuru
+  module TestInclude
+    extend Kanrisuru::OsPackage::Define
+
+    os_define :ubuntu, :tester
+
+    def tester
+      'hello ubuntu'
+    end
+  end
+
+  module TestNamespace
+    extend Kanrisuru::OsPackage::Define
+
+    os_define :unix_like, :tester
+    os_define :centos, :test_not_correct
+
+    def tester
+      'hello namespace'
+    end
+
+    def test_not_correct; end
+  end
+end
+
+module Kanrisuru
+  module Remote
+    class Host
+      os_include Kanrisuru::TestInclude
+      os_include Kanrisuru::TestNamespace, namespace: :asdf
+    end
+
+    class Cluster
+      os_collection Kanrisuru::TestInclude
+      os_collection Kanrisuru::TestNamespace, namespace: :asdf
+    end
+  end
+end
+
+RSpec.describe Kanrisuru::OsPackage do
+  it 'includes with os_include' 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])
+
+    expect(host).to respond_to(:tester)
+    expect(host.tester).to eq('hello ubuntu')
+    expect(cluster.tester).to be_instance_of(Array)
+
+    host.disconnect
+    cluster.disconnect
+  end
+
+  it 'includes a namespaced os_include' 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])
+
+    expect(host).to respond_to(:asdf)
+    expect(host.asdf).to respond_to(:tester)
+    expect(host.asdf.tester).to eq 'hello namespace'
+    expect(host.tester).to eq('hello ubuntu')
+    expect { host.asdf.test_not_correct }.to raise_error(NoMethodError)
+    expect(cluster.asdf.tester).to be_instance_of(Array)
+
+    host.disconnect
+    cluster.disconnect
+  end
+end

data/spec/functional/remote/cluster_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Remote::Cluster do
+  context 'with ubuntu' do
+    it 'gets hostname for cluster' do
+      cluster = described_class.new([{
+                                      host: 'localhost',
+                                      username: 'ubuntu',
+                                      keys: ['~/.ssh/id_rsa']
+                                    }, {
+                                      host: '127.0.0.1',
+                                      username: 'ubuntu',
+                                      keys: ['~/.ssh/id_rsa']
+                                    }])
+
+      expect(cluster.hostname).to match([
+                                          { host: 'localhost', result: 'ubuntu' },
+                                          { host: '127.0.0.1', result: 'ubuntu' }
+                                        ])
+
+      cluster.disconnect
+    end
+
+    it 'can ping host cluster' do
+      cluster = described_class.new([{
+                                      host: 'localhost',
+                                      username: 'ubuntu',
+                                      keys: ['~/.ssh/id_rsa']
+                                    }, {
+                                      host: '127.0.0.1',
+                                      username: 'ubuntu',
+                                      keys: ['~/.ssh/id_rsa']
+                                    }])
+
+      expect(cluster.ping?).to match([
+                                       { host: 'localhost', result: true },
+                                       { host: '127.0.0.1', result: true }
+                                     ])
+
+      cluster.disconnect
+    end
+  end
+end

data/spec/functional/remote/cpu_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Remote::Cpu 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 cpu details' do
+        expect(host.cpu.cores).to eq(1)
+        expect(host.cpu.total).to eq(1)
+        expect(host.cpu.count).to eq(1)
+
+        expect(host.cpu.threads_per_core).to eq(1)
+        expect(host.cpu.cores_per_socket).to eq(1)
+        expect(host.cpu.sockets).to eq(1)
+
+        expect(host.cpu.hyperthreading?).to eq(false)
+      end
+
+      it 'gets cpu load average' do
+        expect(host.cpu.load_average).to be_instance_of(Array)
+        expect(host.cpu.load_average1).to be_instance_of(Float)
+        expect(host.cpu.load_average5).to be_instance_of(Float)
+        expect(host.cpu.load_average15).to be_instance_of(Float)
+      end
+    end
+  end
+end