siba 0.4.3

data/test/integration/i9n_test_unicode_files.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+
+require 'helper/require_integration'
+
+describe Siba::Backup do
+  before do
+    @yml_path = File.expand_path '../yml', __FILE__
+    @path_to_src_yml = File.join @yml_path, "valid.yml"
+    skip if SibaTest::IS_WINDOWS # Unicode paths do not work on Windows
+  end
+
+  it "should create folders and files with unicode names" do
+    dir_path = prepare_test_dir SibaTest::UNICODE_FILE_NAME
+    File.directory?(dir_path).must_equal true
+
+    file_path = prepare_test_file SibaTest::UNICODE_FILE_NAME
+    File.file?(file_path).must_equal true
+  end
+
+  it "should backup with unicode files and dirs" do
+    @backup = Siba::Backup.new
+    Siba::LoggerPlug.close
+    Siba::SibaLogger.quiet = true
+    src_dir = prepare_test_dir "bf-src-dir-#{SibaTest::UNICODE_FILE_NAME}"
+    prepare_test_dir SibaTest::UNICODE_FILE_NAME, src_dir
+    prepare_test_file SibaTest::UNICODE_FILE_NAME, src_dir
+    src_file = prepare_test_file "bf-src-file-#{SibaTest::UNICODE_FILE_NAME}"
+    dest_dir = mkdir_in_tmp_dir "bf-dest-dir-#{SibaTest::UNICODE_FILE_NAME}"
+
+    test_yml_path = prepare_yml @path_to_src_yml, 
+      { src_dir: src_dir,
+        src_file: src_file,
+        dest_dir: dest_dir }
+
+    log_file = File.join File.dirname(test_yml_path), "testlog.log"
+    @backup.backup test_yml_path, log_file
+    Siba::FileHelper.entries(dest_dir).find{|a| a =~ /\.gpg$/}.wont_be_nil
+    wont_log_from "warn"
+  end
+end

data/test/integration/i9n_tmp_dir.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+
+require 'helper/require_integration'
+
+describe Siba::TmpDir do
+  before do
+    @tmp_dir = Siba::TmpDir.new
+  end
+
+  after do
+    @tmp_dir.cleanup unless @tmp_dir.nil?
+  end
+
+  it "should get tmp dir" do
+    siba_file.file_directory?(@tmp_dir.get).must_equal true
+  end
+  
+  it "should get the same tmp on second call" do
+    dir1 = @tmp_dir.get
+    dir2 = @tmp_dir.get
+    dir1.must_equal dir2
+  end
+
+  it "should use dir specified in settings" do
+    test_dir = prepare_test_dir "tmp-dir"    
+    Siba.settings = {"tmp_dir"=>test_dir}
+    dir1 = @tmp_dir.get
+    dir1.must_match /^#{test_dir}/
+  end
+
+  it "should cleanup" do
+    dir = @tmp_dir.get
+    @tmp_dir.cleanup
+    siba_file.file_directory?(dir).must_equal false
+  end
+
+  it "should cleanup without calling get" do
+    @tmp_dir.cleanup
+  end
+
+  it "should call test_access" do
+    Siba::TmpDir.test_access
+  end
+end

data/test/integration/plugins/archive/tar/i9n_archive.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+require 'helper/require_integration'
+require 'siba/plugins/archive/tar/init'
+
+describe Siba::Archive::Tar::Archive do
+  it "should init with no compression" do
+    Siba::Archive::Tar::Archive.new "none"
+  end
+
+  it "should init with gzip" do
+    Siba::Archive::Tar::Archive.new "gzip"
+  end
+
+  it "should init with bzip2" do
+    Siba::Archive::Tar::Archive.new "bzip2"
+  end
+end

data/test/integration/plugins/destination/dir/i9n_dest_dir.rb

@@ -0,0 +1,52 @@
+# encoding: UTF-8
+
+require 'helper/require_integration'
+require 'siba/plugins/destination/dir/init'
+
+describe Siba::Destination::Dir::DestDir do
+  before do    
+    @cls = Siba::Destination::Dir::DestDir
+  end
+
+  it "should init" do
+    dest_dir = mkdir_in_tmp_dir "test-dest-dir"
+    @cls.new dest_dir
+
+    siba_file.file_directory?(dest_dir).must_equal true, "Should create dest dir on init"
+    Siba::FileHelper.dir_empty?(dest_dir).must_equal true, "Must remove test file from dest dir"
+  end
+
+  it "should copy backup to dest dir" do
+    dest_dir = mkdir_in_tmp_dir "test-dest-dir"
+    dir_dest = @cls.new dest_dir
+    backup_file = prepare_test_file "destination-dir-backup"
+    dir_dest.copy_backup_to_dest backup_file
+    path_to_dest_file = File.join dest_dir, File.basename(backup_file)
+    siba_file.file_file?(path_to_dest_file).must_equal true
+    siba_file.file_utils_compare_file(backup_file, path_to_dest_file).must_equal true
+  end
+
+  it "should get list of backups and restore them to dir" do
+    prefix = "bak"
+    prepare_test_file prefix
+    file_to_restore = prepare_test_file prefix
+    prepare_test_file prefix
+    prepare_test_file "different"
+    @obj = @cls.new SibaTest.tmp_dir
+    list = @obj.get_backups_list prefix
+    list.must_be_instance_of Array
+    list.size.must_equal 3
+    list[0].size.must_equal 2
+    list[0][0].must_be_instance_of String
+    list[0][1].must_be_instance_of Time
+
+    # Restore backups to dir
+    file_name = File.basename file_to_restore
+    restore_dir = mkdir_in_tmp_dir "rst"
+    @obj.restore_backup_to_dir file_name, restore_dir
+    file_restored = File.join restore_dir, file_name
+    File.file?(file_restored).must_equal true
+    file_to_restore.wont_equal file_restored
+    FileUtils.compare_file(file_to_restore, file_restored).must_equal true
+  end
+end

data/test/integration/plugins/encryption/gpg/i9n_encryption.rb

@@ -0,0 +1,87 @@
+# encoding: UTF-8
+
+require 'helper/require_integration'
+require 'siba/plugins/encryption/gpg/init'
+
+describe Siba::Encryption::Gpg::Encryption do
+  before do
+    @passphrase = %(my pass "Word$)
+  end
+
+  it "init should fail if cipher is not supported" do
+    ->{Siba::Encryption::Gpg::Encryption.new @passphrase, "unknown_cipher"}.must_raise Siba::CheckError
+  end
+  
+  it "init should assign default cipher if it's not supplied" do
+    encryption = Siba::Encryption::Gpg::Encryption.new @passphrase
+    encryption.cipher.wont_be_nil
+  end
+
+  it "should encrypt and decrypt" do
+    encryption = Siba::Encryption::Gpg::Encryption.new @passphrase
+    path_to_source_file = prepare_test_file "encryption-gpg-1"
+    path_to_encrypted_file = encryption.encrypt path_to_source_file
+    path_to_encrypted_file.must_equal "#{path_to_source_file}.gpg"
+    siba_file.file_file?(path_to_encrypted_file).must_equal true
+    siba_file.file_utils_compare_file(path_to_source_file, path_to_encrypted_file).must_equal false
+
+    # decrypt
+    path_to_output_file = "#{path_to_source_file}.decrypted"
+    path_to_decrypted_file = encryption.decrypt path_to_encrypted_file, path_to_output_file
+    path_to_decrypted_file.must_equal path_to_output_file
+    siba_file.file_utils_compare_file(path_to_source_file, path_to_decrypted_file).must_equal true
+
+   
+    # decrypt without output file parameter
+    ->{encryption.decrypt path_to_encrypted_file}.must_raise Siba::Error, "Should fail to decrypt if file already exists"
+    FileUtils.mv path_to_source_file, path_to_source_file + "new"
+    path_to_decrypted_file = encryption.decrypt path_to_encrypted_file
+    path_to_decrypted_file.must_equal path_to_source_file
+
+    # should fail to decrypt with incorrect passphrase 
+    encryption.passphrase = "incorrect"
+    ->{encryption.decrypt path_to_encrypted_file}.must_raise Siba::Error
+  end
+
+  it "should raise error if encrypted file exists" do
+    encryption = Siba::Encryption::Gpg::Encryption.new @passphrase
+    path_to_source_file = prepare_test_file "encyptor-gpg-exists"
+    path_to_encrypted_file = path_to_source_file + ".gpg"
+    siba_file.file_utils_touch path_to_encrypted_file
+    ->{encryption.encrypt path_to_source_file}.must_raise Siba::Error
+  end
+
+  it "should get cipher names" do
+    names = Siba::Encryption::Gpg::Encryption.get_cipher_names
+    names.must_be_instance_of Array
+    names.wont_be_empty
+    names[0].must_equal names[0].upcase
+  end
+
+  it "must call check_cipher" do
+    names = Siba::Encryption::Gpg::Encryption.get_cipher_names
+    cipher = names.sample.upcase
+    Siba::Encryption::Gpg::Encryption.check_cipher(cipher).must_equal(cipher.upcase)
+
+    cipher = names.sample.downcase
+    Siba::Encryption::Gpg::Encryption.check_cipher(cipher).must_equal(cipher.upcase)
+  end
+
+  it "check_cipher must return default cipher if none is supplied" do
+    names = Siba::Encryption::Gpg::Encryption.get_cipher_names
+    default = Siba::Encryption::Gpg::Encryption.check_cipher(nil)
+    names.must_include default
+  end
+
+  it "check_cipher must raise error if default cipher is not supported" do
+    old_cipher = Siba::Encryption::Gpg::Encryption::DEFAULT_CIPHER
+    SibaTest::RemovableConstants.redef_without_warning Siba::Encryption::Gpg::Encryption, "DEFAULT_CIPHER", "NEW_CIPHER"
+    names = Siba::Encryption::Gpg::Encryption.get_cipher_names
+    ->{Siba::Encryption::Gpg::Encryption.check_cipher(nil)}.must_raise Siba::CheckError
+    SibaTest::RemovableConstants.redef_without_warning Siba::Encryption::Gpg::Encryption, "DEFAULT_CIPHER", old_cipher
+  end
+  
+  it "check_cipher must fail if unknown cipher is used" do
+    ->{Siba::Encryption::Gpg::Encryption.check_cipher("incorrect")}.must_raise Siba::CheckError
+  end
+end

data/test/integration/plugins/i9n_installed_plugins.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+require 'helper/require_integration'
+
+describe Siba::InstalledPlugins do
+  before do
+    @cls = Siba::InstalledPlugins
+  end
+
+  it "should return plugin path" do
+    File.directory?(@cls.plugin_path("source", "files")).must_equal true
+  end
+end

data/test/integration/plugins/source/files/i9n_files.rb

@@ -0,0 +1,146 @@
+# encoding: UTF-8
+
+require 'helper/require_integration'
+require 'siba/plugins/source/files/files'
+
+describe Siba::Source::Files::Files do
+  before do
+    @files = Siba::Source::Files::Files
+  end
+
+  it "should run copy_file" do
+    src_file = prepare_test_file "s-f"
+    dest_dir = mkdir_in_tmp_dir "s-f-dest"
+    f = @files.new [],[],true
+    f.copy_file src_file, dest_dir
+    dest_file = File.join dest_dir, File.basename(src_file)
+    src_file.wont_equal dest_file
+    siba_file.file_file?(dest_file).must_equal true
+    siba_file.file_utils_compare_file(src_file, dest_file).must_equal true
+  end
+
+  it "copy_file should not copy file if it's ignored" do
+    src_file = prepare_test_file "s-f"
+    dest_dir = mkdir_in_tmp_dir "s-f-dest"
+    f = @files.new [],["*"],true
+    f.copy_file src_file, dest_dir
+    dest_file = File.join dest_dir, File.basename(src_file)
+    src_file.wont_equal dest_file
+    siba_file.file_file?(dest_file).must_equal false
+  end
+
+  it "should run copy_dir" do
+    src_dir = prepare_test_dir "s-f-src-dir"
+    dest_dir = mkdir_in_tmp_dir "s-f-dest-dir"
+    f = @files.new [],[],true
+    f.copy_dir src_dir, dest_dir, true
+    dest_sub_dir = File.join dest_dir, File.basename(src_dir)
+    siba_file.file_directory?(dest_sub_dir).must_equal true
+    dirs_same? src_dir, dest_sub_dir
+  end
+
+  it "run copy_dir wihout including subdirs" do
+    src_dir = prepare_test_dir "s-f-src-dir"
+    dest_dir = mkdir_in_tmp_dir "s-f-dest-dir"
+    f = @files.new [],[],false
+    f.copy_dir src_dir, dest_dir, true
+    dest_sub_dir = File.join dest_dir, File.basename(src_dir)
+    Siba::FileHelper.entries(src_dir).each do |entry|
+      entry_path = File.join src_dir, entry
+      siba_file.file_utils_remove_entry_secure entry_path if siba_file.file_directory?(entry_path) 
+    end
+    siba_file.file_directory?(dest_sub_dir).must_equal true
+    dirs_same? src_dir, dest_sub_dir
+  end
+
+  it "copy_dir should not copy if it's ignored" do
+    src_dir = prepare_test_dir "s-f-src-dir"
+    dest_dir = mkdir_in_tmp_dir "s-f-dest-dir"
+    f = @files.new [],["*"],true
+    f.copy_dir src_dir, dest_dir, true
+    dest_sub_dir = File.join dest_dir, File.basename(src_dir)
+    siba_file.file_directory?(dest_sub_dir).must_equal false
+  end
+
+  it "copy_dir should not create a sub dir" do
+    src_dir = prepare_test_dir "s-f-src-dir"
+    dest_dir = mkdir_in_tmp_dir "s-f-dest-dir"
+    f = @files.new [],[],true
+    f.copy_dir src_dir, dest_dir, false
+    dirs_same? src_dir, dest_dir
+  end
+
+  it "backup should copy dir and file" do
+    src_dir = prepare_test_dir "s-f-src-dir"
+    src_file = prepare_test_file "s-f-src-file"
+    f = @files.new [src_dir, src_file],[],true
+
+    dest_dir = mkdir_in_tmp_dir "s-f-dest-dir"
+    f.backup dest_dir
+   
+    # compare dir 
+    backup_dir = @files.sub_dir_name 1, 1, false, File.basename(src_dir), dest_dir
+    dirs_same? src_dir, backup_dir
+
+    # compare file
+    backup_file_dir = @files.sub_dir_name 2, 1, true, File.basename(src_file), dest_dir
+    backup_file = File.join backup_file_dir, File.basename(src_file)
+    siba_file.file_utils_compare_file(src_file, backup_file).must_equal true
+
+    Siba::FileHelper.dirs_count(dest_dir).must_equal 2, "Should create two folders for each source"
+  end
+  
+  it "backup should log error message if one of the sources is not found" do
+    src_dir = prepare_test_dir "s-f-src-dir"
+    f = @files.new ["/non-existing-file", src_dir],[],true
+
+    dest_dir = mkdir_in_tmp_dir "s-f-dest-dir"
+    f.backup dest_dir
+
+    # The existing dir must be copied 
+    backup_dir = @files.sub_dir_name 2, 1, false, File.basename(src_dir), dest_dir
+    dirs_same? src_dir, backup_dir
+
+    Siba::FileHelper.dirs_count(dest_dir).must_equal 1, "Only valid source must be copies"
+    must_log "error"
+  end
+
+  it "backup should NOT copy if ignored" do
+    src_dir = prepare_test_dir "s-f-src-dir"
+    src_file = prepare_test_file "s-f-src-file"
+    f = @files.new [src_dir, src_file],["*"],true
+    dest_dir = mkdir_in_tmp_dir "s-f-dest-dir"
+    f.backup dest_dir
+    Siba::FileHelper.dir_empty?(dest_dir).must_equal true
+  end
+
+  it "should restore" do
+    backup_root = mkdir_in_tmp_dir "restore-backup"
+
+    sub_dir1_name = File.basename @files.sub_dir_name(1,1,false,"backup",backup_root)
+    backup_dir1 = prepare_test_dir sub_dir1_name, backup_root
+
+    sub_dir2_name = File.basename @files.sub_dir_name(2,1,true,"backup-dir",backup_root)
+    backup_dir2 = mkdir_in_tmp_dir sub_dir2_name, backup_root
+    backup_file = prepare_test_file "backup-file", backup_dir2
+    backup_file_name = File.basename backup_file
+
+    backup_source_dir = mkdir_in_tmp_dir "restore-bk-source"
+    restore_dir1 = mkdir_in_tmp_dir "restore-dir", backup_source_dir
+    restore_file = File.join(backup_source_dir, backup_file_name)
+
+    @obj = @files.new [restore_dir1, restore_file],[],true
+    @obj.restore(backup_root)
+
+    Siba::FileHelper.entries(backup_source_dir).size.must_equal 2
+
+    # Compare dirs
+    restore_dir1.wont_equal backup_dir1
+    dirs_same? restore_dir1, backup_dir1 
+
+    # Compare file
+    restore_file.wont_equal backup_file
+    FileUtils.compare_file(restore_file, backup_file).must_equal true
+    wont_log_from "warn"
+  end
+end

data/test/integration/tasks/i9n_siba_tasks.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+require 'helper/require_integration'
+
+describe Siba::SibaTasks do
+  before do
+    @yml_path = File.expand_path '../../yml', __FILE__
+    @path_to_src_yml = File.join @yml_path, "valid.yml"
+  end
+
+  it "should backup and testore tasks" do
+    src_dir = prepare_test_dir "b-src-dir" 
+    src_file = prepare_test_file "b-src-file"
+    dest_dir = mkdir_in_tmp_dir "b-dest-dir"
+
+    path_to_test_yml = prepare_yml @path_to_src_yml,
+      { src_dir: src_dir,
+        src_file: src_file,
+        dest_dir: dest_dir }
+
+    options = SibaTest.load_options path_to_test_yml
+
+    tasks = Siba::SibaTasks.new options, path_to_test_yml, false
+    tasks.backup 
+
+    backup_file_name = Siba::FileHelper.entries(dest_dir)[0]
+    tasks = Siba::SibaTasks.new options, path_to_test_yml, true
+    tasks.restore backup_file_name
+  end
+end

data/test/integration/yml/valid.yml

@@ -0,0 +1,16 @@
+source:
+  type: files
+  include:
+    - #_replace_src_dir
+    - #_replace_src_file
+
+archive:
+  type: tar
+
+encryption:
+  type: gpg
+  passphrase: "this is a password"
+
+destination:
+  type: dir
+  dir: #_replace_dest_dir