kanrisuru 0.1.0 → 0.2.1

data/spec/helper/test_hosts.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+class TestHosts
+  class << self
+    def each_os(&block)
+      %w[debian ubuntu fedora centos rhel opensuse sles].each do |os_name|
+        next unless test?(os_name)
+
+        block.call(os_name)
+      end
+    end
+
+    def host(name)
+      hosts(name)
+    end
+
+    def test?(name)
+      return false if host(name).nil?
+
+      if testable_hosts.nil? && excludable_hosts.nil?
+        true
+      elsif testable_hosts.nil? && !excludable_hosts.nil?
+        hosts_exclude_array = excludable_hosts.split(',')
+
+        !hosts_exclude_array.include?(name)
+      elsif !testable_hosts.nil? && excludable_hosts.nil?
+        hosts_include_array = testable_hosts.split(',')
+
+        hosts_include_array.include?(name)
+      else
+        hosts_include_array = testable_hosts.split(',')
+        hosts_exclude_array = excludable_hosts.split(',')
+
+        hosts_include_array.include?(name) && !hosts_exclude_array.include?(name)
+      end
+    end
+
+    def hosts(name)
+      @hosts ||= begin
+        result = {}
+
+        hosts_list.each do |host_item|
+          result[host_item['name']] = host_item
+        end
+
+        result
+      end
+
+      @hosts[name]
+    end
+
+    def hosts_list
+      json_config_path = File.join('spec', 'hosts.json')
+      hosts_data = File.open(json_config_path).read
+      JSON.parse(hosts_data)
+    end
+
+    private
+
+    def excludable_hosts
+      ENV['EXCLUDE'] || ENV['IGNORE']
+    end
+
+    def testable_hosts
+      ENV['HOSTS']
+    end
+  end
+end

data/spec/hosts.json

@@ -0,0 +1,92 @@
+[
+	{
+		"name": "localhost",
+		"port": 22,
+		"username": "ubuntu",
+		"ssh_key": "~/.ssh/id_rsa",
+		"hostname": "localhost",
+		"kernel": "Linux",
+		"home": "/home/ubuntu"
+	},
+	{
+		"name": "ubuntu",
+		"port": 22,
+		"username": "ubuntu",
+		"ssh_key": "~/.ssh/id_rsa",
+		"hostname": "ubuntu-host",
+		"kernel": "Linux",
+		"home": "/home/ubuntu"
+	},
+	{
+		"name": "debian",
+		"port": 22,
+		"username": "debian",
+		"ssh_key": "~/.ssh/id_rsa",
+		"hostname": "debian-host",
+		"kernel": "Linux",
+		"home": "/home/debian"
+	},
+	{
+		"name": "fedora",
+		"port": 22,
+		"username": "fedora",
+		"ssh_key": "~/.ssh/id_rsa",
+		"hostname": "fedora-host",
+		"kernel": "Linux",
+		"home": "/home/fedora"
+	},
+	{
+		"name": "centos",
+		"port": 22,
+		"username": "centos",
+		"ssh_key": "~/.ssh/id_rsa",
+		"hostname": "centos-host",
+		"kernel": "Linux",
+		"home": "/home/centos"
+	},
+	{
+		"name": "rhel",
+		"port": 22,
+		"username": "cloud-user",
+		"ssh_key": "~/.ssh/id_rsa",
+		"hostname": "rhel-host",
+		"kernel": "Linux",
+		"home": "/home/cloud-user"
+	},
+	{
+		"name": "opensuse",
+		"port": 22,
+		"username": "opensuse",
+		"ssh_key": "~/.ssh/id_rsa",
+		"hostname": "opensuse-host",
+		"kernel": "Linux",
+		"home": "/home/opensuse"
+	},
+	{
+		"name": "sles",
+		"port": 22,
+		"username": "ec2-user",
+		"ssh_key": "~/.ssh/id_rsa",
+		"hostname": "sles-host",
+		"kernel": "Linux",
+		"home": "/home/ec2-user"
+	},
+	{
+		"name": "arch",
+		"port": 22,
+		"username": "arch",
+		"ssh_key": "~/.ssh/id_rsa",
+		"hostname": "arch-host",
+		"kernel": "Linux",
+		"home": "/home/arch"
+	},
+	{
+		"name": "freebsd",
+		"port": 22,
+		"username": "freebsd",
+		"ssh_key": "~/.ssh/id_rsa",
+		"hostname": "freebsd-host",
+		"kernel": "FreeBSD",
+		"home": "/usr/home/freebsd"
+	}
+]

data/spec/spec_helper.rb

@@ -1,9 +1,17 @@
-require "bundler/setup"
-require "kanrisuru"
+# frozen_string_literal: true
+
+require 'simplecov'
+SimpleCov.start
+
+require 'kanrisuru'
+
+require_relative 'helper/test_hosts'
+
+Kanrisuru.logger.level = Logger::WARN
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure
-  config.example_status_persistence_file_path = ".rspec_status"
+  config.example_status_persistence_file_path = '.rspec_status'
 
   # Disable RSpec exposing methods globally on `Module` and `main`
   config.disable_monkey_patching!

data/spec/unit/fstab_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+RSpec.describe Kanrisuru::Remote::Fstab do
+  it 'creates fstab options' do
+    options = Kanrisuru::Remote::Fstab::Options.new('ext4', 'user,defaults,resgid=1000,resuid=1000')
+
+    expect(options.class).to eq(Kanrisuru::Remote::Fstab::Options)
+    expect(options.to_s).to eq('user,defaults,resgid=1000,resuid=1000')
+
+    options = Kanrisuru::Remote::Fstab::Options.new('fat', user: true, defaults: true, uid: 1000, gid: 1000)
+
+    expect(options.class).to eq(Kanrisuru::Remote::Fstab::Options)
+    expect(options.to_s).to eq('user,defaults,uid=1000,gid=1000')
+
+    options['user'] = false
+    options['fat'] = 16
+    options[:uid] = 0
+    options[:gid] = 0
+
+    expect(options.to_s).to eq('defaults,uid=0,gid=0,fat=16')
+  end
+end

data/spec/unit/kanrisuru_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru do
+  it 'has a version number' do
+    expect(Kanrisuru::VERSION).not_to be nil
+  end
+end

data/spec/unit/mode_spec.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Mode do
+  it 'parses int mode' do
+    mode = described_class.new('644')
+    expect(mode.directory?).to eq(false)
+
+    expect(mode.owner.read?).to eq(true)
+    expect(mode.owner.write?).to eq(true)
+    expect(mode.owner.execute?).to eq(false)
+    expect(mode.owner.all?).to eq(false)
+    expect(mode.owner.to_i).to eq(6)
+    expect(mode.owner.symbolic).to eq('rw-')
+
+    expect(mode.group.read?).to eq(true)
+    expect(mode.group.write?).to eq(false)
+    expect(mode.group.execute?).to eq(false)
+    expect(mode.group.all?).to eq(false)
+    expect(mode.group.to_i).to eq(4)
+    expect(mode.group.symbolic).to eq('r--')
+
+    expect(mode.other.read?).to eq(true)
+    expect(mode.other.write?).to eq(false)
+    expect(mode.other.execute?).to eq(false)
+    expect(mode.other.all?).to eq(false)
+    expect(mode.other.to_i).to eq(4)
+    expect(mode.other.symbolic).to eq('r--')
+  end
+
+  it 'parses int mode octal' do
+    mode = described_class.new(0o644)
+    expect(mode.directory?).to eq(false)
+
+    expect(mode.owner.read?).to eq(true)
+    expect(mode.owner.write?).to eq(true)
+    expect(mode.owner.execute?).to eq(false)
+    expect(mode.owner.all?).to eq(false)
+    expect(mode.owner.to_i).to eq(6)
+    expect(mode.owner.symbolic).to eq('rw-')
+
+    expect(mode.group.read?).to eq(true)
+    expect(mode.group.write?).to eq(false)
+    expect(mode.group.execute?).to eq(false)
+    expect(mode.group.all?).to eq(false)
+    expect(mode.group.to_i).to eq(4)
+    expect(mode.group.symbolic).to eq('r--')
+
+    expect(mode.other.read?).to eq(true)
+    expect(mode.other.write?).to eq(false)
+    expect(mode.other.execute?).to eq(false)
+    expect(mode.other.all?).to eq(false)
+    expect(mode.other.to_i).to eq(4)
+    expect(mode.other.symbolic).to eq('r--')
+  end
+
+  it 'parses ref mode' do
+    mode = described_class.new('drwxrwxrwx')
+    expect(mode.directory?).to eq(true)
+
+    expect(mode.owner.read?).to eq(true)
+    expect(mode.owner.write?).to eq(true)
+    expect(mode.owner.execute?).to eq(true)
+    expect(mode.owner.all?).to eq(true)
+    expect(mode.owner.to_i).to eq(7)
+    expect(mode.owner.symbolic).to eq('rwx')
+
+    expect(mode.group.read?).to eq(true)
+    expect(mode.group.write?).to eq(true)
+    expect(mode.group.execute?).to eq(true)
+    expect(mode.group.all?).to eq(true)
+    expect(mode.group.to_i).to eq(7)
+    expect(mode.group.symbolic).to eq('rwx')
+
+    expect(mode.other.read?).to eq(true)
+    expect(mode.other.write?).to eq(true)
+    expect(mode.other.execute?).to eq(true)
+    expect(mode.other.all?).to eq(true)
+    expect(mode.other.to_i).to eq(7)
+    expect(mode.other.symbolic).to eq('rwx')
+  end
+
+  it 'changes mode numerically globally' do
+    mode = described_class.new(0o600)
+
+    expect(mode.owner.read?).to eq(true)
+    expect(mode.group.read?).to eq(false)
+    expect(mode.other.read?).to eq(false)
+    expect(mode.symbolic).to eq('-rw-------')
+
+    mode.numeric = 0o644
+
+    expect(mode.owner.read?).to eq(true)
+    expect(mode.group.read?).to eq(true)
+    expect(mode.other.read?).to eq(true)
+
+    expect(mode.symbolic).to eq('-rw-r--r--')
+    expect(mode.to_s).to eq('-rw-r--r--')
+    expect(mode.numeric).to eq('644')
+    expect(mode.to_i).to eq(0o644)
+  end
+
+  it 'changes mode symbolically globally' do
+    mode = described_class.new(0o600)
+
+    expect(mode.owner.read?).to eq(true)
+    expect(mode.group.read?).to eq(false)
+    expect(mode.other.read?).to eq(false)
+    expect(mode.symbolic).to eq('-rw-------')
+
+    mode.symbolic = '-rw-r--r--'
+
+    expect(mode.owner.read?).to eq(true)
+    expect(mode.group.read?).to eq(true)
+    expect(mode.other.read?).to eq(true)
+
+    expect(mode.symbolic).to eq('-rw-r--r--')
+    expect(mode.to_s).to eq('-rw-r--r--')
+    expect(mode.numeric).to eq('644')
+    expect(mode.to_i).to eq(0o644)
+  end
+
+  it 'changes mode numerically each permission level boolean' do
+    mode = described_class.new(0o600)
+
+    expect(mode.other.read?).to eq(false)
+    expect(mode.group.read?).to eq(false)
+
+    mode.group.read = true
+    mode.other.read = true
+
+    expect(mode.group.read?).to eq(true)
+    expect(mode.other.read?).to eq(true)
+
+    expect(mode.symbolic).to eq('-rw-r--r--')
+    expect(mode.to_s).to eq('-rw-r--r--')
+    expect(mode.numeric).to eq('644')
+    expect(mode.to_i).to eq(0o644)
+  end
+
+  it 'changes mode on each permission level symbolic' do
+    mode = described_class.new(0o600)
+
+    expect(mode.other.read?).to eq(false)
+    expect(mode.group.read?).to eq(false)
+
+    mode.group.symbolic = 'rw-'
+    mode.other.symbolic = 'r--'
+
+    expect(mode.group.read?).to eq(true)
+    expect(mode.group.write?).to eq(true)
+    expect(mode.other.read?).to eq(true)
+
+    expect(mode.symbolic).to eq('-rw-rw-r--')
+    expect(mode.to_s).to eq('-rw-rw-r--')
+    expect(mode.numeric).to eq('664')
+    expect(mode.to_i).to eq(0o664)
+  end
+
+  it 'changes mode globally using symoblic operator' do
+    mode = described_class.new(0o601)
+
+    expect(mode.other.read?).to eq(false)
+    expect(mode.group.read?).to eq(false)
+    expect(mode.symbolic).to eq('-rw------x')
+
+    mode.symbolic = 'u=rwx,g+w,o-x'
+    expect(mode.numeric).to eq('720')
+    expect(mode.symbolic).to eq('-rwx-w----')
+
+    mode.symbolic = 'a=r'
+    expect(mode.symbolic).to eq('-r--r--r--')
+    expect(mode.to_i).to eq(0o444)
+
+    mode.symbolic = 'u-r,gu+x,a+w'
+    expect(mode.numeric).to eq('376')
+    expect(mode.symbolic).to eq('--wxrwxrw-')
+
+    mode.symbolic = '-w'
+    expect(mode.symbolic).to eq('---xr-xr--')
+  end
+end

data/spec/unit/template_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Template do
+  it 'reads template file' do
+    path = '/home/ubuntu/kanrisuru/templates/test.conf.erb'
+    template = described_class.new(path, array: %w[hello world])
+    template.trim_mode = '-'
+
+    puts template.render
+  end
+end

data/spec/unit/util_spec.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Util do
+  it 'gets present value' do
+    expect(described_class.present?(1)).to eq(true)
+    expect(described_class.present?(true)).to eq(true)
+    expect(described_class.present?('a')).to eq(true)
+    expect(described_class.present?(Class)).to eq(true)
+
+    expect(described_class.present?(false)).to eq(false)
+    expect(described_class.present?('')).to eq(false)
+    expect(described_class.present?([])).to eq(false)
+    expect(described_class.present?(nil)).to eq(false)
+  end
+
+  it 'camelizes strings' do
+    expect(described_class.camelize('hello_world')).to eq('HelloWorld')
+    expect(described_class.camelize('helloworld')).to eq('Helloworld')
+    expect(described_class.camelize('HelloWorld')).to eq('HelloWorld')
+  end
+
+  it 'gets os family' do
+    expect(Kanrisuru::Util::OsFamily['debian']).to match({
+                                                           name: 'Debian',
+                                                           os_family: 'linux',
+                                                           upstream: 'linux',
+                                                           model: 'open_source',
+                                                           state: 'current',
+                                                           type: 'distribution'
+                                                         })
+  end
+
+  it 'detects family inclusion of distribution' do
+    expect(Kanrisuru::Util::OsFamily.family_include_distribution?('linux', 'centos')).to eq(true)
+    expect(Kanrisuru::Util::OsFamily.family_include_distribution?('unix_like', 'centos')).to eq(true)
+    expect(Kanrisuru::Util::OsFamily.family_include_distribution?('unix', 'centos')).to eq(true)
+    expect(Kanrisuru::Util::OsFamily.family_include_distribution?('unix_like', 'linux')).to eq(true)
+
+    expect(Kanrisuru::Util::OsFamily.family_include_distribution?('linux', 'ubuntu')).to eq(true)
+    expect(Kanrisuru::Util::OsFamily.family_include_distribution?('linux', 'debian')).to eq(true)
+    expect(Kanrisuru::Util::OsFamily.family_include_distribution?('linux', 'linux_mint')).to eq(true)
+
+    expect(Kanrisuru::Util::OsFamily.family_include_distribution?('unix', 'bsd')).to eq(true)
+    expect(Kanrisuru::Util::OsFamily.family_include_distribution?('unix_like', 'open_bsd')).to eq(true)
+
+    expect(Kanrisuru::Util::OsFamily.family_include_distribution?('unix_like', 'darwin')).to eq(true)
+    expect(Kanrisuru::Util::OsFamily.family_include_distribution?('unix_like', 'pure_darwin')).to eq(true)
+
+    expect(Kanrisuru::Util::OsFamily.family_include_distribution?('linux', 'redhat')).to eq(true)
+
+    expect(Kanrisuru::Util::OsFamily.family_include_distribution?('fedora', 'redhat')).to eq(false)
+  end
+
+  it 'detects upstream inclusion of distribution' do
+    expect(Kanrisuru::Util::OsFamily.upstream_include_distribution?('debian', 'ubuntu')).to eq(true)
+    expect(Kanrisuru::Util::OsFamily.upstream_include_distribution?('debian', 'linux_mint')).to eq(true)
+    expect(Kanrisuru::Util::OsFamily.upstream_include_distribution?('linux', 'linux_mint')).to eq(true)
+
+    expect(Kanrisuru::Util::OsFamily.upstream_include_distribution?('fedora', 'redhat')).to eq(true)
+    expect(Kanrisuru::Util::OsFamily.upstream_include_distribution?('fedora', 'centos')).to eq(true)
+
+    expect(Kanrisuru::Util::OsFamily.upstream_include_distribution?('unix_like', 'linux_mint')).to eq(false)
+  end
+
+  it 'converts from methods' do
+    expect(Kanrisuru::Util::Bits.convert_from_kb(1_000, :mb)).to eq(1)
+    expect(Kanrisuru::Util::Bits.convert_from_mb(1_000, :gb)).to eq(1)
+    expect(Kanrisuru::Util::Bits.convert_from_gb(1_000, :tb)).to eq(1)
+    expect(Kanrisuru::Util::Bits.convert_from_tb(1_000, :pb)).to eq(1)
+    expect(Kanrisuru::Util::Bits.convert_from_pb(1_000, :pb)).to eq(1_000)
+  end
+
+  it 'converts bytes and bits' do
+    expect(Kanrisuru::Util::Bits.convert_bytes(1_000, :kilobyte, :kilobyte)).to eq(1000)
+    expect(Kanrisuru::Util::Bits.convert_bytes(1_000, :kilobyte, :kb)).to eq(1000)
+    expect(Kanrisuru::Util::Bits.convert_bytes(100, :kilobit, :kilobit)).to eq(100)
+    expect(Kanrisuru::Util::Bits.convert_bytes(800, :kilobit, :kilobyte)).to eq(100)
+    expect(Kanrisuru::Util::Bits.convert_bytes(100, :kilobyte, :kilobit)).to eq(800)
+
+    expect { Kanrisuru::Util::Bits.convert_bytes(100, :kilobyte, :kilobitt) }.to raise_error(ArgumentError)
+    expect { Kanrisuru::Util::Bits.convert_bytes(100, :kilobytee, :kilobit) }.to raise_error(ArgumentError)
+  end
+
+  it 'converts power' do
+    expect(Kanrisuru::Util::Bits.convert_power(:deca, :deca)).to eq(0)
+    expect(Kanrisuru::Util::Bits.convert_power(:deca, :kilo)).to eq(-1)
+    expect(Kanrisuru::Util::Bits.convert_power(:deca, :mega)).to eq(-2)
+    expect(Kanrisuru::Util::Bits.convert_power(:deca, :giga)).to eq(-3)
+    expect(Kanrisuru::Util::Bits.convert_power(:deca, :tera)).to eq(-4)
+    expect(Kanrisuru::Util::Bits.convert_power(:deca, :peta)).to eq(-5)
+    expect(Kanrisuru::Util::Bits.convert_power(:deca, :exa)).to eq(-6)
+    expect(Kanrisuru::Util::Bits.convert_power(:deca, :zetta)).to eq(-7)
+    expect(Kanrisuru::Util::Bits.convert_power(:deca, :yotta)).to eq(-8)
+
+    expect(Kanrisuru::Util::Bits.convert_power(:kilo, :deca)).to eq(1)
+    expect(Kanrisuru::Util::Bits.convert_power(:kilo, :kilo)).to eq(0)
+    expect(Kanrisuru::Util::Bits.convert_power(:kilo, :mega)).to eq(-1)
+    expect(Kanrisuru::Util::Bits.convert_power(:kilo, :giga)).to eq(-2)
+    expect(Kanrisuru::Util::Bits.convert_power(:kilo, :tera)).to eq(-3)
+    expect(Kanrisuru::Util::Bits.convert_power(:kilo, :peta)).to eq(-4)
+    expect(Kanrisuru::Util::Bits.convert_power(:kilo, :exa)).to eq(-5)
+    expect(Kanrisuru::Util::Bits.convert_power(:kilo, :zetta)).to eq(-6)
+    expect(Kanrisuru::Util::Bits.convert_power(:kilo, :yotta)).to eq(-7)
+
+    expect(Kanrisuru::Util::Bits.convert_power(:mega, :deca)).to eq(2)
+    expect(Kanrisuru::Util::Bits.convert_power(:mega, :kilo)).to eq(1)
+    expect(Kanrisuru::Util::Bits.convert_power(:mega, :mega)).to eq(0)
+    expect(Kanrisuru::Util::Bits.convert_power(:mega, :giga)).to eq(-1)
+    expect(Kanrisuru::Util::Bits.convert_power(:mega, :tera)).to eq(-2)
+    expect(Kanrisuru::Util::Bits.convert_power(:mega, :peta)).to eq(-3)
+    expect(Kanrisuru::Util::Bits.convert_power(:mega, :exa)).to eq(-4)
+    expect(Kanrisuru::Util::Bits.convert_power(:mega, :zetta)).to eq(-5)
+    expect(Kanrisuru::Util::Bits.convert_power(:mega, :yotta)).to eq(-6)
+
+    expect(Kanrisuru::Util::Bits.convert_power(:giga, :deca)).to eq(3)
+    expect(Kanrisuru::Util::Bits.convert_power(:giga, :kilo)).to eq(2)
+    expect(Kanrisuru::Util::Bits.convert_power(:giga, :mega)).to eq(1)
+    expect(Kanrisuru::Util::Bits.convert_power(:giga, :giga)).to eq(0)
+    expect(Kanrisuru::Util::Bits.convert_power(:giga, :tera)).to eq(-1)
+    expect(Kanrisuru::Util::Bits.convert_power(:giga, :peta)).to eq(-2)
+    expect(Kanrisuru::Util::Bits.convert_power(:giga, :exa)).to eq(-3)
+    expect(Kanrisuru::Util::Bits.convert_power(:giga, :zetta)).to eq(-4)
+    expect(Kanrisuru::Util::Bits.convert_power(:giga, :yotta)).to eq(-5)
+
+    expect(Kanrisuru::Util::Bits.convert_power(:tera, :deca)).to eq(4)
+    expect(Kanrisuru::Util::Bits.convert_power(:tera, :kilo)).to eq(3)
+    expect(Kanrisuru::Util::Bits.convert_power(:tera, :mega)).to eq(2)
+    expect(Kanrisuru::Util::Bits.convert_power(:tera, :giga)).to eq(1)
+    expect(Kanrisuru::Util::Bits.convert_power(:tera, :tera)).to eq(0)
+    expect(Kanrisuru::Util::Bits.convert_power(:tera, :peta)).to eq(-1)
+    expect(Kanrisuru::Util::Bits.convert_power(:tera, :exa)).to eq(-2)
+    expect(Kanrisuru::Util::Bits.convert_power(:tera, :zetta)).to eq(-3)
+    expect(Kanrisuru::Util::Bits.convert_power(:tera, :yotta)).to eq(-4)
+
+    expect(Kanrisuru::Util::Bits.convert_power(:peta, :deca)).to eq(5)
+    expect(Kanrisuru::Util::Bits.convert_power(:peta, :kilo)).to eq(4)
+    expect(Kanrisuru::Util::Bits.convert_power(:peta, :mega)).to eq(3)
+    expect(Kanrisuru::Util::Bits.convert_power(:peta, :giga)).to eq(2)
+    expect(Kanrisuru::Util::Bits.convert_power(:peta, :tera)).to eq(1)
+    expect(Kanrisuru::Util::Bits.convert_power(:peta, :peta)).to eq(0)
+    expect(Kanrisuru::Util::Bits.convert_power(:peta, :exa)).to eq(-1)
+    expect(Kanrisuru::Util::Bits.convert_power(:peta, :zetta)).to eq(-2)
+    expect(Kanrisuru::Util::Bits.convert_power(:peta, :yotta)).to eq(-3)
+
+    expect(Kanrisuru::Util::Bits.convert_power(:exa, :deca)).to eq(6)
+    expect(Kanrisuru::Util::Bits.convert_power(:exa, :kilo)).to eq(5)
+    expect(Kanrisuru::Util::Bits.convert_power(:exa, :mega)).to eq(4)
+    expect(Kanrisuru::Util::Bits.convert_power(:exa, :giga)).to eq(3)
+    expect(Kanrisuru::Util::Bits.convert_power(:exa, :tera)).to eq(2)
+    expect(Kanrisuru::Util::Bits.convert_power(:exa, :peta)).to eq(1)
+    expect(Kanrisuru::Util::Bits.convert_power(:exa, :exa)).to eq(0)
+    expect(Kanrisuru::Util::Bits.convert_power(:exa, :zetta)).to eq(-1)
+    expect(Kanrisuru::Util::Bits.convert_power(:exa, :yotta)).to eq(-2)
+
+    expect(Kanrisuru::Util::Bits.convert_power(:zetta, :deca)).to eq(7)
+    expect(Kanrisuru::Util::Bits.convert_power(:zetta, :kilo)).to eq(6)
+    expect(Kanrisuru::Util::Bits.convert_power(:zetta, :mega)).to eq(5)
+    expect(Kanrisuru::Util::Bits.convert_power(:zetta, :giga)).to eq(4)
+    expect(Kanrisuru::Util::Bits.convert_power(:zetta, :tera)).to eq(3)
+    expect(Kanrisuru::Util::Bits.convert_power(:zetta, :peta)).to eq(2)
+    expect(Kanrisuru::Util::Bits.convert_power(:zetta, :exa)).to eq(1)
+    expect(Kanrisuru::Util::Bits.convert_power(:zetta, :zetta)).to eq(0)
+    expect(Kanrisuru::Util::Bits.convert_power(:zetta, :yotta)).to eq(-1)
+
+    expect(Kanrisuru::Util::Bits.convert_power(:yotta, :deca)).to eq(8)
+    expect(Kanrisuru::Util::Bits.convert_power(:yotta, :kilo)).to eq(7)
+    expect(Kanrisuru::Util::Bits.convert_power(:yotta, :mega)).to eq(6)
+    expect(Kanrisuru::Util::Bits.convert_power(:yotta, :giga)).to eq(5)
+    expect(Kanrisuru::Util::Bits.convert_power(:yotta, :tera)).to eq(4)
+    expect(Kanrisuru::Util::Bits.convert_power(:yotta, :peta)).to eq(3)
+    expect(Kanrisuru::Util::Bits.convert_power(:yotta, :exa)).to eq(2)
+    expect(Kanrisuru::Util::Bits.convert_power(:yotta, :zetta)).to eq(1)
+    expect(Kanrisuru::Util::Bits.convert_power(:yotta, :yotta)).to eq(0)
+  end
+end