kanrisuru 0.10.0 → 0.12.1

data/spec/functional/core/archive_spec.rb

@@ -2,10 +2,10 @@
 
 require 'spec_helper'
 
-RSpec.describe Kanrisuru::Core::Apt do
+RSpec.describe Kanrisuru::Core::Archive do
   before(:all) do
     StubNetwork.stub!
-    StubNetwork.stub_command!(:realpath) do |args|
+    StubNetwork.stub_command!(:realpath) do |_args|
       Kanrisuru::Core::Path::FilePath.new(directory)
     end
   end
@@ -26,169 +26,145 @@ RSpec.describe Kanrisuru::Core::Apt do
   let(:directory) { '/home/ubuntu/dir' }
 
   it 'prepares tar list command' do
-    ['list', 't'].each do |action_variant|
-      expect_command(host.tar(action_variant, 'file.txt'), 
-        'tar --restrict -f file.txt -t'
-      )
-
-      expect_command(host.tar(action_variant, '~/file.txt', 
-          compress: 'bzip2',
-          directory: directory,
-          occurrence: 1,
-          label: true,
-          multi_volume: true
-        ), 
-        'tar --restrict -C /home/ubuntu/dir -f ~/file.txt -j -t --occurrence 1 --label --multi-volume'
-      )
+    %w[list t].each do |action_variant|
+      expect_command(host.tar(action_variant, 'file.txt'),
+                     'tar --restrict -f file.txt -t')
+
+      expect_command(host.tar(action_variant, '~/file.txt',
+                              compress: 'bzip2',
+                              directory: directory,
+                              occurrence: 1,
+                              label: true,
+                              multi_volume: true),
+                     'tar --restrict -C /home/ubuntu/dir -f ~/file.txt -j -t --occurrence 1 --label --multi-volume')
     end
   end
 
   it 'prepares tar extract command' do
-    ['extract', 'get', 'x'].each do |action_variant|
-      expect_command(host.tar(action_variant, 'archive.tar'), 
-        'tar --restrict -f archive.tar -x'
-      )
+    %w[extract get x].each do |action_variant|
+      expect_command(host.tar(action_variant, 'archive.tar'),
+                     'tar --restrict -f archive.tar -x')
 
       expect_command(host.tar(action_variant, 'archive.tar',
-          compress: 'xz',
-          directory: directory,
-          occurrence: 2,
-          no_same_owner: true,
-          no_same_permissions: true,
-          no_selinux: true,
-          no_xattrs: true,
-          multi_volume: true,
-          label: true,
-          skip_old_files: true,
-          overwrite: true,
-          overwrite_dir: true,
-          unlink_first: true,
-          recursive_unlink: true,
-          paths: 'file.txt'
-        ), 
-        'tar --restrict -C /home/ubuntu/dir -f archive.tar -J -x --occurrence 2 --no-same-owner --no-same-permissions --no-selinux --no-xattrs --multi-volume --label --skip-old-files --overwrite --overwrite-dir --unlink-first --recursive-unlink file.txt'
-      )
+                              compress: 'xz',
+                              directory: directory,
+                              occurrence: 2,
+                              no_same_owner: true,
+                              no_same_permissions: true,
+                              no_selinux: true,
+                              no_xattrs: true,
+                              multi_volume: true,
+                              label: true,
+                              skip_old_files: true,
+                              overwrite: true,
+                              overwrite_dir: true,
+                              unlink_first: true,
+                              recursive_unlink: true,
+                              paths: 'file.txt'),
+                     'tar --restrict -C /home/ubuntu/dir -f archive.tar -J -x --occurrence 2 --no-same-owner --no-same-permissions --no-selinux --no-xattrs --multi-volume --label --skip-old-files --overwrite --overwrite-dir --unlink-first --recursive-unlink file.txt')
 
       expect_command(host.tar(action_variant, 'archive.tar',
-          preserve_permissions: true,
-          same_owners: true,
-          one_file_system: true,
-          keep_old_files: true,
-          paths: ['file1.txt', 'file2.txt']
-        ),
-        'tar --restrict -f archive.tar -x --preserve-permissions --same-owner --one-file-system --keep-old-files file1.txt file2.txt'
-      )
+                              preserve_permissions: true,
+                              same_owners: true,
+                              one_file_system: true,
+                              keep_old_files: true,
+                              paths: ['file1.txt', 'file2.txt']),
+                     'tar --restrict -f archive.tar -x --preserve-permissions --same-owner --one-file-system --keep-old-files file1.txt file2.txt')
     end
   end
 
   it 'prepares tar create command' do
-    ['create', 'c'].each do |action_variant|
-      expect_command(host.tar(action_variant, 'archive.lzma', compress: 'lzma'), 'tar --restrict -f archive.lzma --lzma -c')
-      expect_command(host.tar(action_variant, 'archive.gz'), 'tar --restrict -f archive.gz -c') 
-
-      expect_command(host.tar(action_variant, 'archive.gz', 
-          directory: directory,
-          compress: 'gzip',
-          exclude: 'file2.txt',
-          paths: 'file1.txt' 
-        ),
-        'tar --restrict -C /home/ubuntu/dir -f archive.gz -z -c --exclude=file2.txt file1.txt'
-      )
-
-      expect_command(host.tar(action_variant, 'archive.gz', 
-          compress: 'gzip',
-          exclude: ['file2.txt', 'file4.txt'],
-          paths: ['file1.txt', 'file3.txt']
-        ),
-        'tar --restrict -f archive.gz -z -c --exclude=file2.txt --exclude=file4.txt file1.txt file3.txt'
-      )
+    %w[create c].each do |action_variant|
+      expect_command(host.tar(action_variant, 'archive.lzma', compress: 'lzma'),
+                     'tar --restrict -f archive.lzma --lzma -c')
+      expect_command(host.tar(action_variant, 'archive.gz'), 'tar --restrict -f archive.gz -c')
+
+      expect_command(host.tar(action_variant, 'archive.gz',
+                              directory: directory,
+                              compress: 'gzip',
+                              exclude: 'file2.txt',
+                              paths: 'file1.txt'),
+                     'tar --restrict -C /home/ubuntu/dir -f archive.gz -z -c --exclude=file2.txt file1.txt')
+
+      expect_command(host.tar(action_variant, 'archive.gz',
+                              compress: 'gzip',
+                              exclude: ['file2.txt', 'file4.txt'],
+                              paths: ['file1.txt', 'file3.txt']),
+                     'tar --restrict -f archive.gz -z -c --exclude=file2.txt --exclude=file4.txt file1.txt file3.txt')
     end
   end
 
   it 'prepares tar append command' do
-    ['append', 'r'].each do |action_variant|
+    %w[append r].each do |action_variant|
       expect_command(host.tar(action_variant, 'archive.tar'), 'tar --restrict -f archive.tar -r')
 
-      expect_command(host.tar(action_variant, 'archive.tar', 
-          directory: directory,
-          paths: 'main.conf'
-        ), 
-        'tar --restrict -C /home/ubuntu/dir -f archive.tar -r main.conf'
-      )
-
-      expect_command(host.tar(action_variant, 'archive.tar', 
-          paths: ['main.conf', 'main2.conf']
-        ), 
-        'tar --restrict -f archive.tar -r main.conf main2.conf'
-      ) 
-    end 
+      expect_command(host.tar(action_variant, 'archive.tar',
+                              directory: directory,
+                              paths: 'main.conf'),
+                     'tar --restrict -C /home/ubuntu/dir -f archive.tar -r main.conf')
+
+      expect_command(host.tar(action_variant, 'archive.tar',
+                              paths: ['main.conf', 'main2.conf']),
+                     'tar --restrict -f archive.tar -r main.conf main2.conf')
+    end
   end
 
   it 'prepares tar concat command' do
-    ['catenate', 'concat', 'A'].each do |action_variant|
+    %w[catenate concat A].each do |action_variant|
       expect_command(host.tar(action_variant, 'archive.tar'), 'tar --restrict -f archive.tar -A')
       expect_command(host.tar(action_variant, 'archive.tar',
-          directory: directory,
-          paths: 'archive2.tar'
-        ),
-        'tar --restrict -C /home/ubuntu/dir -f archive.tar -A archive2.tar'
-      )
+                              directory: directory,
+                              paths: 'archive2.tar'),
+                     'tar --restrict -C /home/ubuntu/dir -f archive.tar -A archive2.tar')
 
       expect_command(host.tar(action_variant, 'archive.tar',
-          directory: directory,
-          paths: ['archive2.tar', 'archive3.tar']
-        ),
-        'tar --restrict -C /home/ubuntu/dir -f archive.tar -A archive2.tar archive3.tar'
-      )
+                              directory: directory,
+                              paths: ['archive2.tar', 'archive3.tar']),
+                     'tar --restrict -C /home/ubuntu/dir -f archive.tar -A archive2.tar archive3.tar')
     end
   end
 
   it 'prepares tar update command' do
-    ['update', 'u'].each do |action_variant|
+    %w[update u].each do |action_variant|
       expect_command(host.tar(action_variant, 'archive',
-          paths: 'file1.txt'
-        ),
-        'tar --restrict -f archive -u file1.txt'
-      )
+                              paths: 'file1.txt'),
+                     'tar --restrict -f archive -u file1.txt')
 
       expect_command(host.tar(action_variant, 'archive',
-          directory: directory,
-          paths: ['file1.txt', 'file2.txt']
-        ),
-        'tar --restrict -C /home/ubuntu/dir -f archive -u file1.txt file2.txt'
-      )
+                              directory: directory,
+                              paths: ['file1.txt', 'file2.txt']),
+                     'tar --restrict -C /home/ubuntu/dir -f archive -u file1.txt file2.txt')
     end
   end
 
   it 'prepares tar diff command' do
-    ['diff', 'compare', 'd'].each do |action_variant|
-      expect_command(host.tar(action_variant, 'archive.tar', directory: directory), 'tar --restrict -C /home/ubuntu/dir -f archive.tar -d')
-      expect_command(host.tar(action_variant, 'archive.tar', 
-          directory: directory,
-          occurrence: 4
-        ), 
-        'tar --restrict -C /home/ubuntu/dir -f archive.tar -d --occurrence 4'
-      )
+    %w[diff compare d].each do |action_variant|
+      expect_command(host.tar(action_variant, 'archive.tar', directory: directory),
+                     'tar --restrict -C /home/ubuntu/dir -f archive.tar -d')
+
+      expect_command(host.tar(action_variant, 'archive.tar',
+                              directory: directory,
+                              occurrence: 4),
+                     'tar --restrict -C /home/ubuntu/dir -f archive.tar -d --occurrence 4')
     end
   end
 
   it 'prepares tar delete command' do
-    expect_command(host.tar('delete', 'archive.tar', paths: 'file1.txt'), 'tar --restrict -f archive.tar --delete file1.txt')
-    expect_command(host.tar('delete', 'archive.tar', 
-        paths: ['file1.txt', 'file2.txt'],
-        occurrence: 3
-      ), 
-      'tar --restrict -f archive.tar --delete --occurrence 3 file1.txt file2.txt'
-    )
+    expect_command(host.tar('delete', 'archive.tar', paths: 'file1.txt'),
+                   'tar --restrict -f archive.tar --delete file1.txt')
+    expect_command(host.tar('delete', 'archive.tar',
+                            paths: ['file1.txt', 'file2.txt'],
+                            occurrence: 3),
+                   'tar --restrict -f archive.tar --delete --occurrence 3 file1.txt file2.txt')
   end
 
   it 'prepares invalid tar command' do
-    expect {
+    expect do
       host.tar('abc', 'file1.txt')
-    }.to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
 
-    expect {
+    expect do
       host.tar('create', 'archive.tar', compress: 'xip')
-    }.to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 end

data/spec/functional/core/find_spec.rb

@@ -20,150 +20,131 @@ RSpec.describe Kanrisuru::Core::Find do
   end
 
   it 'prepares find command' do
-    expect_command(host.find, "find")
+    expect_command(host.find, 'find')
 
-    expect_command(host.find(follow: 'never'), "find -P")
-    expect_command(host.find(follow: 'always'), "find -L")
-    expect_command(host.find(follow: 'command'), "find -H")
+    expect_command(host.find(follow: 'never'), 'find -P')
+    expect_command(host.find(follow: 'always'), 'find -L')
+    expect_command(host.find(follow: 'command'), 'find -H')
 
-    expect_command(host.find(paths: '/etc'), "find /etc")
-    expect_command(host.find(paths: ['/etc', '/var', '/home']), "find /etc /var /home")
+    expect_command(host.find(paths: '/etc'), 'find /etc')
+    expect_command(host.find(paths: ['/etc', '/var', '/home']), 'find /etc /var /home')
 
-    expect {
+    expect do
       host.find(paths: 1)
-    }.to raise_error(ArgumentError)
-
-    expect_command(host.find(paths: '/', 
-        executable: true,
-        empty: true,
-        readable: true,
-        writeable: true,
-        nogroup: true,
-        nouser: true,
-        mount: true
-      ), 
-      "find / -executable -empty -readable -nogroup -nouser -mount"
-    )
-
-    expect_command(host.find(paths: '/', 
-        path: "/lib",
-        name: '*.so',
-        gid: 0,
-        uid: 0,
-        user: 'root',
-        group: 'root',
-        links: 2,
-        mindepth: 0,
-        maxdepth: 100   
-      ),
-      "find / -path /lib -name *.so -gid 0 -uid 0 -user root -group root -links 2 -maxdepth 100 -mindepth 0"
-    )
+    end.to raise_error(ArgumentError)
+
+    expect_command(host.find(paths: '/',
+                             executable: true,
+                             empty: true,
+                             readable: true,
+                             writeable: true,
+                             nogroup: true,
+                             nouser: true,
+                             mount: true),
+                   'find / -executable -empty -readable -nogroup -nouser -mount')
+
+    expect_command(host.find(paths: '/',
+                             path: '/lib',
+                             name: '*.so',
+                             gid: 0,
+                             uid: 0,
+                             user: 'root',
+                             group: 'root',
+                             links: 2,
+                             mindepth: 0,
+                             maxdepth: 100),
+                   'find / -path /lib -name *.so -gid 0 -uid 0 -user root -group root -links 2 -maxdepth 100 -mindepth 0')
 
     expect_command(host.find(paths: '/var/log',
-        atime: '+1',
-        ctime: '+2',
-        mtime: '+3',
-        amin: '100',
-        cmin: '200',
-        mmin: '300'
-      ),
-      "find /var/log -atime +1 -ctime +2 -mtime +3 -amin 100 -cmin 200 -mmin 300"
-    )
+                             atime: '+1',
+                             ctime: '+2',
+                             mtime: '+3',
+                             amin: '100',
+                             cmin: '200',
+                             mmin: '300'),
+                   'find /var/log -atime +1 -ctime +2 -mtime +3 -amin 100 -cmin 200 -mmin 300')
 
     expect_command(host.find(
-        paths: '/dev', 
-        regex: '/dev/tty[0-9]*'
-      ), 
-      "find /dev -regex '/dev/tty[0-9]*'"
-    )
+                     paths: '/dev',
+                     regex: '/dev/tty[0-9]*'
+                   ),
+                   "find /dev -regex '/dev/tty[0-9]*'")
 
     expect_command(host.find(
-        paths: '/dev', 
-        regex_type: 'posix-egrep',
-        regex: '/dev/tty[0-9]*'
-      ), 
-      "find /dev -regextype posix-egrep -regex '/dev/tty[0-9]*'"
-    )
+                     paths: '/dev',
+                     regex_type: 'posix-egrep',
+                     regex: '/dev/tty[0-9]*'
+                   ),
+                   "find /dev -regextype posix-egrep -regex '/dev/tty[0-9]*'")
 
     expect_command(host.find(
-        paths: '/var/log',
-        size: 100
-      ),
-      "find /var/log -size 100"
-    )
+                     paths: '/var/log',
+                     size: 100
+                   ),
+                   'find /var/log -size 100')
 
     expect_command(host.find(
-        paths: '/var/log',
-        size: "100"
-      ),
-      "find /var/log -size 100"
-    )
-    
-    expect {
-      host.find(size: "100n")
-    }.to raise_error(ArgumentError)
+                     paths: '/var/log',
+                     size: '100'
+                   ),
+                   'find /var/log -size 100')
+
+    expect do
+      host.find(size: '100n')
+    end.to raise_error(ArgumentError)
 
     expect_command(host.find(
-        paths: '/var/log',
-        size: "-100k"
-      ),
-      "find /var/log -size -100k"
-    )
+                     paths: '/var/log',
+                     size: '-100k'
+                   ),
+                   'find /var/log -size -100k')
 
     expect_command(host.find(
-        paths: '/var/log',
-        size: "+10M"
-      ),
-      "find /var/log -size +10M"
-    )
+                     paths: '/var/log',
+                     size: '+10M'
+                   ),
+                   'find /var/log -size +10M')
 
     expect_command(host.find(
-        paths: "/dev",
-        type: 'directory' 
-      ),
-      "find /dev -type d"
-    )
+                     paths: '/dev',
+                     type: 'directory'
+                   ),
+                   'find /dev -type d')
 
     expect_command(host.find(
-        paths: "/dev",
-        type: 'file' 
-      ),
-      "find /dev -type f"
-    )
+                     paths: '/dev',
+                     type: 'file'
+                   ),
+                   'find /dev -type f')
 
     expect_command(host.find(
-        paths: "/dev",
-        type: 'symlinks' 
-      ),
-      "find /dev -type l"
-    )
+                     paths: '/dev',
+                     type: 'symlinks'
+                   ),
+                   'find /dev -type l')
 
     expect_command(host.find(
-        paths: "/dev",
-        type: 'block'
-      ),
-      "find /dev -type b"
-    )
+                     paths: '/dev',
+                     type: 'block'
+                   ),
+                   'find /dev -type b')
 
     expect_command(host.find(
-        paths: "/dev",
-        type: 'character'
-      ),
-      "find /dev -type c"
-    )
+                     paths: '/dev',
+                     type: 'character'
+                   ),
+                   'find /dev -type c')
 
     expect_command(host.find(
-        paths: "/dev",
-        type: 'pipe'
-      ),
-      "find /dev -type p"
-    )
+                     paths: '/dev',
+                     type: 'pipe'
+                   ),
+                   'find /dev -type p')
 
     expect_command(host.find(
-        paths: "/dev",
-        type: 'socket'
-      ),
-      "find /dev -type s"
-    )
+                     paths: '/dev',
+                     type: 'socket'
+                   ),
+                   'find /dev -type s')
   end
 end

data/spec/functional/core/mount_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Core::Mount do
+  before(:all) do
+    StubNetwork.stub!
+  end
+
+  after(:all) do
+    StubNetwork.unstub!
+  end
+
+  let(:host) do
+    Kanrisuru::Remote::Host.new(
+      host: 'localhost',
+      username: 'ubuntu',
+      keys: ['id_rsa']
+    )
+  end
+
+  it 'prepares mount command' do
+    expect_command(host.mount, 'mount')
+    expect_command(host.mount(bind_old: '/mnt/dira', bind_new: '/mnt/dirb'), 'mount --bind /mnt/dira /mnt/dirb')
+    expect_command(host.mount(rbind_old: '/mnt/dira', rbind_new: '/mnt/dirb'), 'mount --rbind /mnt/dira /mnt/dirb')
+    expect_command(host.mount(move_old: '/mnt/dira', move_new: '/mnt/dirb'), 'mount --move /mnt/dira /mnt/dirb')
+    expect_command(host.mount(
+                     label: 'cloudimg-rootfs',
+                     uuid: '5fbaea960d09e2ad',
+                     sloppy: true,
+                     internal_only: true,
+                     fake: true,
+                     no_mtab: true,
+                     no_canonicalize: true,
+                     device: '/dev/vda9',
+                     directory: '/mnt/dir1'
+                   ), 'mount -L cloudimg-rootfs -U 5fbaea960d09e2ad -f -i -s --no-mtab --no-canonicalize /dev/vda9 /mnt/dir1')
+
+    expect_command(host.mount(
+                     fs_opts: { async: true, auto: true, group: true, relatime: true, owner: true },
+                     device: '/dev/tty',
+                     directory: '/mnt/dir2'
+                   ), 'mount -o async,auto,group,relatime,owner /dev/tty /mnt/dir2')
+
+    expect do
+      host.mount(fs_opts: { value: true }, device: '/home/ubuntu/dir', directory: '/mnt/dir3')
+    end.to raise_error(ArgumentError)
+
+    expect_command(host.mount(
+                     type: 'ext2',
+                     device: '/dev/tty',
+                     directory: '/mnt/dir2'
+                   ), 'mount -t ext2 /dev/tty /mnt/dir2')
+
+    expect_command(host.mount(
+                     type: 'ext4',
+                     fs_opts: { acl: true, journal: 'update', usrquota: true, async: true, owner: true, group: true },
+                     device: '/dev/tty',
+                     directory: '/mnt/dir2'
+                   ), 'mount -t ext4 -o acl,journal=update,usrquota,async,owner,group /dev/tty /mnt/dir2')
+
+    expect_command(host.mount(type: 'nontfs,xfs', all: true), 'mount -t nontfs,xfs -a')
+    expect_command(host.mount(type: 'fat,xfs', all: true), 'mount -t fat,xfs -a')
+
+    expect do
+      host.mount(
+        type: 'ext2',
+        fs_opts: { acl: true, journal: 'update', usrquota: true, async: true, owner: true, group: true },
+        device: '/dev/tty',
+        directory: '/mnt/dir2'
+      )
+    end.to raise_error(ArgumentError)
+
+    expect do
+      host.mount(
+        type: 'ext4',
+        fs_opts: { acl: true, journal: true, usrquota: true, async: true, owner: true, group: true },
+        device: '/dev/tty',
+        directory: '/mnt/dir2'
+      )
+    end.to raise_error(ArgumentError)
+
+    expect_command(host.mount(all: true, test_opts: { _netdev: true }), 'mount -a -O _netdev')
+    expect_command(host.mount(all: true, test_opts: { async: true, blocksize: 512, uid: 0, gid: 0, dots: true }, type: 'fat'),
+                   'mount -t fat -a -O async,blocksize=512,uid=0,gid=0,dots')
+
+    expect_command(host.mount(
+                     type: 'loop',
+                     fs_opts: { loop: '/dev/loop3' },
+                     device: '/mnt',
+                     directory: '/tmp/fdimage'
+                   ),
+                   'mount -t loop -o loop=/dev/loop3 /mnt /tmp/fdimage')
+  end
+
+  it 'prepares umount command' do
+    expect_command(host.umount, 'umount')
+    expect_command(host.umount(
+                     fake: true,
+                     no_canonicalize: true,
+                     no_mtab: true,
+                     fail_remount_readonly: true,
+                     free_loopback: true,
+                     lazy: true,
+                     force: true,
+                     device: '/dev/vda1'
+                   ),
+                   'umount --fake --no-canonicalize -n -r -d -l -f /dev/vda1')
+
+    expect_command(host.umount(
+                     all: true,
+                     type: 'ext4,nofat'
+                   ), 'umount -a -t ext4,nofat')
+
+    expect_command(host.umount(
+                     all: true,
+                     type: 'ext4',
+                     test_opts: { barrier: 1, nouid32: true }
+                   ), 'umount -a -t ext4 -O barrier=1,nouid32')
+  end
+end