bovem 0.8.1 → 1.0.0

data/lib/bovem/version.rb

@@ -11,13 +11,13 @@ module Bovem
   # @see http://semver.org
   module Version
     # The major version.
-    MAJOR = 0
+    MAJOR = 1
 
     # The minor version.
-    MINOR = 8
+    MINOR = 0
 
     # The patch version.
-    PATCH = 1
+    PATCH = 0
 
     # The current version number of Bovem.
     STRING = [MAJOR, MINOR, PATCH].compact.join(".")

data/spec/bovem/console_spec.rb

@@ -61,7 +61,7 @@ describe Bovem::Console do
 
   describe "#get_screen_width" do
     it "should execute tput cols" do
-      ::Bovem::Console.should_receive("execute").with("tput cols")
+      ::Bovem::Console.should_receive(:execute).with("tput cols")
       console.get_screen_width
     end
 
@@ -159,7 +159,7 @@ describe Bovem::Console do
 
   describe "#replace_markers" do
     it "should just forwards to .replace_markers" do
-      ::Bovem::Console.should_receive("replace_markers").with("A", "B")
+      ::Bovem::Console.should_receive(:replace_markers).with("A", "B")
       console.replace_markers("A", "B")
     end
   end
@@ -181,7 +181,7 @@ describe Bovem::Console do
 
   describe "#write" do
     it "should call #format" do
-      console.should_receive("format").with("A", "B", "C", "D", "E")
+      console.should_receive(:format).with("A", "B", "C", "D", "E")
       console.write("A", "B", "C", "D", "E")
     end
   end
@@ -199,85 +199,84 @@ describe Bovem::Console do
 
   describe "#info" do
     it "should forward everything to #get_banner" do
-      console.should_receive("get_banner").with(" INFO", "bright cyan", false).at_least(1).and_return("")
+      console.should_receive(:get_banner).with(" INFO", "bright cyan", false).at_least(1).and_return("")
       console.info("OK", "\n", true, false, false, false, false, false)
-      console.should_receive("get_banner").with(" INFO", "bright cyan", true).at_least(1).and_return("")
+      console.should_receive(:get_banner).with(" INFO", "bright cyan", true).at_least(1).and_return("")
       console.info("OK", "\n", true, false, false, false, true, false)
     end
 
     it "should forward everything to #write" do
-      console.should_receive("write").with(/.+/, "B", "C", "D", "E", false)
+      console.should_receive(:write).with(/.+/, "B", "C", "D", "E", false)
       console.info("A", "B", "C", "D", "E", "F", "G", false)
     end
   end
 
   describe "#begin" do
     it "should forward everything to #get_banner" do
-      console.should_receive("get_banner").with("*", "bright green").at_least(1).and_return("")
+      console.should_receive(:get_banner).with("*", "bright green").at_least(1).and_return("")
       console.begin("OK", "\n", true, false, false, false, false, false)
     end
 
     it "should forward everything to #write" do
-      console.should_receive("write").with(/.+/, "B", "C", "D", "E", false)
+      console.should_receive(:write).with(/.+/, "B", "C", "D", "E", false)
       console.begin("A", "B", "C", "D", "E", "F", "G", false)
     end
   end
 
   describe "#warn" do
     it "should forward everything to #get_banner" do
-      console.should_receive("get_banner").with(" WARN", "bright yellow", false).at_least(1).and_return("")
+      console.should_receive(:get_banner).with(" WARN", "bright yellow", false).at_least(1).and_return("")
       console.warn("OK", "\n", true, false, false, false, false, false)
-      console.should_receive("get_banner").with(" WARN", "bright yellow", true).at_least(1).and_return("")
+      console.should_receive(:get_banner).with(" WARN", "bright yellow", true).at_least(1).and_return("")
       console.warn("OK", "\n", true, false, false, false, true, false)
     end
 
     it "should forward everything to #write" do
-      console.should_receive("write").with(/.+/, "B", "C", "D", "E", false)
+      console.should_receive(:write).with(/.+/, "B", "C", "D", "E", false)
       console.warn("A", "B", "C", "D", "E", "F", "G", false)
     end
   end
 
   describe "#error" do
     it "should forward everything to #get_banner" do
-      console.should_receive("get_banner").with("ERROR", "bright red", false).at_least(1).and_return("")
+      console.should_receive(:get_banner).with("ERROR", "bright red", false).at_least(1).and_return("")
       console.error("OK", "\n", true, false, false, false, false, false)
-      console.should_receive("get_banner").with("ERROR", "bright red", true).at_least(1).and_return("")
+      console.should_receive(:get_banner).with("ERROR", "bright red", true).at_least(1).and_return("")
       console.error("OK", "\n", true, false, false, false, true, false)
     end
 
     it "should forward everything to #write" do
-      console.should_receive("write").with(/.+/, "B", "C", "D", "E", false)
+      console.should_receive(:write).with(/.+/, "B", "C", "D", "E", false)
       console.error("A", "B", "C", "D", "E", "F", "G", false)
     end
   end
 
   describe "#fatal" do
     it "should forward anything to #error" do
-      Kernel.stub(:abort).and_return(true)
-      console.should_receive("error").with("A", "B", "C", "D", "E", "F", "G", false)
+      Kernel.stub(:exit).and_return(true)
+      console.should_receive(:error).with("A", "B", "C", "D", "E", "F", "G", false)
       console.fatal("A", "B", "C", "D", "E", "F", "G", "H", false)
     end
 
     it "should call abort with the right error code" do
-      Kernel.stub(:abort).and_return(true)
+      Kernel.stub(:exit).and_return(true)
 
-      Kernel.should_receive("abort").with(-1).at_least(1)
+      Kernel.should_receive(:exit).with(-1).exactly(2)
       console.fatal("A", "B", "C", "D", "E", "F", "G", -1, false)
-      Kernel.should_receive("abort").with("H").at_least(1)
       console.fatal("A", "B", "C", "D", "E", "F", "G", "H", false)
     end
   end
 
   describe "#debug" do
     it "should forward everything to #get_banner" do
-      console.should_receive("get_banner").with("DEBUG", "bright magenta", false).at_least(1).and_return("")
+      console.should_receive(:get_banner).with("DEBUG", "bright magenta", false).at_least(1).and_return("")
       console.debug("OK", "\n", true, false, false, false, false, false)
-      console.should_receive("get_banner").with("DEBUG", "bright magenta", true).at_least(1).and_return("")
+      console.should_receive(:get_banner).with("DEBUG", "bright magenta", true).at_least(1).and_return("")
       console.debug("OK", "\n", true, false, false, false, true, false)
     end
 
     it "should forward everything to #write" do
-      console.should_receive("write").with(/.+/, "B", "C", "D", "E", false)
+      console.should_receive(:write).with(/.+/, "B", "C", "D", "E", false)
       console.debug("A", "B", "C", "D", "E", "F", "G", false)
     end
   end
@@ -288,29 +287,31 @@ describe Bovem::Console do
       expect(console.status(:pass, false, true, false)).to eq({:label => "PASS", :color => "bright cyan"})
       expect(console.status(:warn, false, true, false)).to eq({:label => "WARN", :color => "bright yellow"})
       expect(console.status(:fail, false, true, false)).to eq({:label => "FAIL", :color => "bright red"})
-      expect(console.status("NO", false, true, false)).to eq({:label => "PASS", :color => "bright cyan"})
-      expect(console.status(nil, false, true, false)).to eq({:label => "PASS", :color => "bright cyan"})
+      expect(console.status("NO", false, true, false)).to eq({:label => " OK ", :color => "bright green"})
+      expect(console.status(nil, false, true, false)).to eq({:label => " OK ", :color => "bright green"})
     end
 
     it "should create the banner" do
-      console.should_receive("get_banner").with(" OK ", "bright green").and_return("")
+      console.should_receive(:get_banner).with(" OK ", "bright green").and_return("")
       console.status(:ok)
     end
 
     it "should format correctly" do
-      console.should_receive("format_right").with(/.+/, true, true, false)
+      console.should_receive(:format_right).with(/.+/, true, true, false)
       console.status(:ok, false, true)
-      console.should_receive("format").with(/.+/, "\n", true, true, false)
+      console.should_receive(:format).with(/.+/, "\n", true, true, false)
       console.status(:ok, false, true, false)
     end
   end
 
   describe "#read" do
     it "should show a prompt" do
+      Kernel.stub(:gets).and_return("VALUE\n")
+
       prompt = "PROMPT"
-      Kernel.should_receive("print").with("Please insert a value: ")
+      Kernel.should_receive(:print).with("Please insert a value: ")
       console.read(true)
-      Kernel.should_receive("print").with(prompt + ": ")
+      Kernel.should_receive(:print).with(prompt + ": ")
       console.read(prompt)
       Kernel.should_not_receive("print")
       console.read(nil)
@@ -340,7 +341,7 @@ describe Bovem::Console do
         end
       end
 
-      console.should_receive("write").with("Sorry, your reply was not understood. Please try again.", false, false).exactly(4)
+      console.should_receive(:write).with("Sorry, your reply was not understood. Please try again.", false, false).exactly(4)
       count = 0
       console.read(nil, nil, "A")
       count = 0
@@ -363,25 +364,27 @@ describe Bovem::Console do
         end
       end
 
-      console.should_receive("write").with("Sorry, your reply was not understood. Please try again.", false, false)
+      console.should_receive(:write).with("Sorry, your reply was not understood. Please try again.", false, false)
       console.read(nil, nil, /[abc]/)
     end
 
     it "should hide echo to the user when the terminal shows echo" do
+      Kernel.stub(:gets).and_return("VALUE\n")
       stty = %x{which stty}.strip
 
-      ::Bovem::Console.should_receive("execute").with("which stty").and_return(stty)
-      ::Bovem::Console.should_receive("execute").with(stty).and_return("speed 9600 baud;\nlflags: echoe echoke echoctl pendin\niflags: iutf8\noflags: -oxtabs\ncflags: cs8 -parenb")
-      ::Bovem::Console.should_receive("execute").with("#{stty} -echo")
-      ::Bovem::Console.should_receive("execute").with("#{stty} echo")
+      ::Bovem::Console.should_receive(:execute).with("which stty").and_return(stty)
+      ::Bovem::Console.should_receive(:execute).with(stty).and_return("speed 9600 baud;\nlflags: echoe echoke echoctl pendin\niflags: iutf8\noflags: -oxtabs\ncflags: cs8 -parenb")
+      ::Bovem::Console.should_receive(:execute).with("#{stty} -echo")
+      ::Bovem::Console.should_receive(:execute).with("#{stty} echo")
       console.read(nil, nil, nil, false)
     end
 
     it "shouldn't hide echo again when the terminal already hides it" do
+      Kernel.stub(:gets).and_return("VALUE\n")
       stty = %x{which stty}.strip
 
-      ::Bovem::Console.should_receive("execute").with("which stty").and_return(stty)
-      ::Bovem::Console.should_receive("execute").with(stty).and_return("speed 9600 baud;\nlflags: -echo echoe echoke echoctl pendin\niflags: iutf8\noflags: -oxtabs\ncflags: cs8 -parenb")
+      ::Bovem::Console.should_receive(:execute).with("which stty").and_return(stty)
+      ::Bovem::Console.should_receive(:execute).with(stty).and_return("speed 9600 baud;\nlflags: -echo echoe echoke echoctl pendin\niflags: iutf8\noflags: -oxtabs\ncflags: cs8 -parenb")
       ::Bovem::Console.should_not_receive("execute").with("#{stty} -echo")
       ::Bovem::Console.should_not_receive("execute").with("#{stty} echo")
       console.read(nil, nil, nil, false)
@@ -395,13 +398,13 @@ describe Bovem::Console do
     end
 
     it "should print the message and indentate correctly" do
-      console.should_receive("begin").with("A", "B", "C", "D", "E", "F", "G")
-      console.should_receive("with_indentation").with("H", "I")
+      console.should_receive(:begin).with("A", "B", "C", "D", "E", "F", "G")
+      console.should_receive(:with_indentation).with("H", "I")
       console.task("A", "B", "C", "D", "E", "F", "G", "H", "I") { :ok }
     end
 
     it "should execute the given block" do
-      ::Bovem::Console.should_receive("foo")
+      ::Bovem::Console.should_receive(:foo)
       console.task { ::Bovem::Console.foo }
     end
 

data/spec/bovem/shell_spec.rb

@@ -0,0 +1,473 @@
+# encoding: utf-8
+#
+# This file is part of the bovem gem. Copyright (C) 2012 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+require "spec_helper"
+
+describe Bovem::Shell do
+  let(:shell) { ::Bovem::Shell.new }
+  let(:temp_file_1) { "/tmp/bovem-test-1-#{Time.now.strftime("%Y%m%d-%H%M%S")}" }
+  let(:temp_file_2) { "/tmp/bovem-test-2-#{Time.now.strftime("%Y%m%d-%H%M%S")}" }
+  let(:temp_file_3) { "/tmp/bovem-test-3-#{Time.now.strftime("%Y%m%d-%H%M%S")}" }
+  let(:temp_dir_1) { "/tmp/bovem-test-dir-1-#{Time.now.strftime("%Y%m%d-%H%M%S")}" }
+  let(:temp_dir_2) { "/tmp/bovem-test-dir-2-#{Time.now.strftime("%Y%m%d-%H%M%S")}" }
+
+  before(:each) do
+    Kernel.stub(:puts).and_return(nil)
+  end
+
+  describe ".instance" do
+    it "should always return the same instance" do
+      instance = ::Bovem::Shell.instance
+      expect(::Bovem::Shell.instance).to be(instance)
+    end
+  end
+
+  describe "#initialize" do
+    it "should correctly set defaults" do
+      expect(shell.console).to eq(::Bovem::Console.instance)
+    end
+  end
+
+  describe "#run" do
+    it "should show a message" do
+      shell.console.should_receive("begin").with("MESSAGE")
+      shell.run("echo OK", "MESSAGE", true, false)
+      shell.console.should_not_receive("begin").with("MESSAGE")
+      shell.run("echo OK", nil, true, false)
+    end
+
+    it "should only print the command" do
+      shell.console.should_receive("warn").with("Will run command: {mark=bright}\"echo OK\"{/mark}...")
+      ::Open4.should_not_receive("open4")
+      shell.run("echo OK", nil, false, false)
+    end
+
+    it "should only execute a command" do
+      shell.console.should_not_receive("warn").with("Will run command: {mark=bright}\"echo OK\"{/mark}...")
+      ::Open4.should_receive("open4").and_return(::OpenStruct.new(:exitstatus => 0))
+      shell.run("echo OK", nil, true, false)
+    end
+
+    it "should show a exit message" do
+      shell.console.should_receive(:status).with(:ok)
+      shell.run("echo OK", nil, true, true)
+      shell.console.should_receive(:status).with(:fail)
+      shell.run("echo1 OK", nil, true, true, false, false)
+    end
+
+    it "should print output" do
+      Kernel.should_receive("print").with("OK\n")
+      shell.run("echo OK", nil, true, false, true)
+    end
+
+    it "should raise a exception for failures" do
+      expect { shell.run("echo1 OK", nil, true, false, false, false) }.to_not raise_error(SystemExit)
+      expect { shell.run("echo1 OK", nil, true, false, false) }.to raise_error(SystemExit)
+    end
+  end
+
+  describe "#check" do
+    it "executes all tests" do
+      expect(shell.check("/", [:read, :dir])).to be_true
+      expect(shell.check("/dev/null", :write)).to be_true
+      expect(shell.check("/bin/sh", [:execute, :exec])).to be_true
+      expect(shell.check("/", [:read, :directory])).to be_true
+      expect(shell.check("/", [:writable?, :directory?])).to be_false
+    end
+
+    it "returns false when some tests are invalid" do
+      expect(shell.check("/", [:read, :none])).to be_false
+    end
+  end
+
+  describe "#delete" do
+    it "should delete files" do
+      File.unlink(temp_file_1) if File.exists?(temp_file_1)
+      File.open(temp_file_1, "w") {|f| f.write("OK") }
+
+      expect(File.exists?(temp_file_1)).to be_true
+      expect(shell.delete(temp_file_1, true, false)).to be_true
+      expect(File.exists?(temp_file_1)).to be_false
+      File.unlink(temp_file_1) if File.exists?(temp_file_1)
+    end
+
+    it "should only print the list of files" do
+      shell.console.should_receive(:warn).with("Will remove file(s):")
+      FileUtils.should_not_receive(:rm_r)
+      expect(shell.delete(temp_file_1, false)).to be_true
+    end
+
+    it "should complain about non existing files" do
+      shell.console.should_receive(:error).with("Cannot remove following non existent file: {mark=bright}#{temp_file_1}{/mark}")
+      expect(shell.delete(temp_file_1, true, true, false)).to be_false
+    end
+
+    it "should complain about non writeable files" do
+      shell.console.should_receive(:error).with("Cannot remove following non writable file: {mark=bright}/dev/null{/mark}")
+      expect(shell.delete("/dev/null", true, true, false)).to be_false
+    end
+
+    it "should complain about other exceptions" do
+      FileUtils.stub(:rm_r).and_raise(ArgumentError.new("ERROR"))
+      shell.console.should_receive(:error).with("Cannot remove following file(s):")
+      shell.console.should_receive(:write).at_least(2)
+      expect(shell.delete("/dev/null", true, true, false)).to be_false
+    end
+
+    describe "should exit when requested to" do
+      it "by calling :fatal" do
+        shell.console.should_receive(:fatal).with("Cannot remove following non writable file: {mark=bright}/dev/null{/mark}")
+        expect(shell.delete("/dev/null")).to be_false
+      end
+
+      it "by calling Kernel#exit" do
+        FileUtils.stub(:rm_r).and_raise(ArgumentError.new("ERROR"))
+        Kernel.should_receive(:exit).with(-1)
+        expect(shell.delete("/dev/null", true, true)).to be_false
+      end
+    end
+  end
+
+  describe "#copy_or_move" do
+    before(:each) do
+      FileUtils.rm_r(temp_file_1) if File.exists?(temp_file_1)
+      FileUtils.rm_r(temp_file_2) if File.exists?(temp_file_2)
+      FileUtils.rm_r(temp_file_3) if File.exists?(temp_file_3)
+      FileUtils.rm_r(temp_dir_1) if File.exists?(temp_dir_1)
+      FileUtils.rm_r(temp_dir_2) if File.exists?(temp_dir_2)
+    end
+
+    after(:each) do
+      FileUtils.rm_r(temp_file_1) if File.exists?(temp_file_1)
+      FileUtils.rm_r(temp_file_2) if File.exists?(temp_file_2)
+      FileUtils.rm_r(temp_file_3) if File.exists?(temp_file_3)
+      FileUtils.rm_r(temp_dir_1) if File.exists?(temp_dir_1)
+      FileUtils.rm_r(temp_dir_2) if File.exists?(temp_dir_2)
+    end
+
+    it "should copy a file" do
+      File.open(temp_file_1, "w") {|f| f.write("OK") }
+      expect(shell.copy_or_move(temp_file_1, temp_file_2, :copy)).to eq(true)
+      expect(File.exists?(temp_file_1)).to be_true
+      expect(File.exists?(temp_file_2)).to be_true
+    end
+
+    it "should move a file" do
+      File.open(temp_file_1, "w") {|f| f.write("OK") }
+      expect(shell.copy_or_move(temp_file_1, temp_file_2, :move, true)).to eq(true)
+      expect(File.exists?(temp_file_1)).to be_false
+      expect(File.exists?(temp_file_2)).to be_true
+    end
+
+    it "should copy multiple entries" do
+      File.open(temp_file_1, "w") {|f| f.write("OK") }
+      File.open(temp_file_2, "w") {|f| f.write("OK") }
+      shell.create_directories(temp_dir_1)
+      File.open(temp_dir_1 + "/temp", "w") {|f| f.write("OK") }
+
+      expect(shell.copy_or_move([temp_file_1, temp_file_2, temp_dir_1], temp_dir_2, :copy)).to be_true
+      expect(File.exists?(temp_dir_2 + "/" + File.basename(temp_file_1))).to be_true
+      expect(File.exists?(temp_dir_2 + "/" + File.basename(temp_file_2))).to be_true
+      expect(File.exists?(temp_dir_2 + "/" + File.basename(temp_dir_1))).to be_true
+      expect(File.exists?(temp_dir_2 + "/" + File.basename(temp_dir_1) + "/temp")).to be_true
+    end
+
+    it "should move multiple entries" do
+      File.open(temp_file_1, "w") {|f| f.write("OK") }
+      File.open(temp_file_2, "w") {|f| f.write("OK") }
+      shell.create_directories(temp_dir_1)
+      File.open(temp_dir_1 + "/temp", "w") {|f| f.write("OK") }
+
+      expect(shell.copy_or_move([temp_file_1, temp_file_2, temp_dir_1], temp_dir_2, :move, true)).to be_true
+      expect(File.exists?(temp_dir_2 + "/" + File.basename(temp_file_1))).to be_true
+      expect(File.exists?(temp_dir_2 + "/" + File.basename(temp_file_2))).to be_true
+      expect(File.exists?(temp_dir_2 + "/" + File.basename(temp_dir_1))).to be_true
+      expect(File.exists?(temp_dir_2 + "/" + File.basename(temp_dir_1) + "/temp")).to be_true
+      expect(File.exists?(temp_file_1)).to be_false
+      expect(File.exists?(temp_file_2)).to be_false
+      expect(File.exists?(temp_dir_1)).to be_false
+      expect(File.exists?(temp_dir_1 + "/temp")).to be_false
+    end
+
+    it "should complain about non existing source" do
+      shell.console.should_receive(:error).with("Cannot copy non existent file {mark=bright}#{temp_file_1}{/mark}.")
+      expect(shell.copy_or_move(temp_file_1, temp_file_2, :copy, true, false, false)).to be_false
+
+      shell.console.should_receive(:error).with("Cannot move non existent file {mark=bright}#{temp_file_1}{/mark}.")
+      expect(shell.copy_or_move(temp_file_1, temp_file_2, :move, true, false, false)).to be_false
+    end
+
+    it "should not copy a file to a path which is currently a directory" do
+      File.open(temp_file_1, "w") {|f| f.write("OK") }
+      shell.create_directories(temp_file_2)
+
+      shell.console.should_receive(:error).with("Cannot copy file {mark=bright}#{temp_file_1}{/mark} to {mark=bright}#{temp_file_2}{/mark} because it is currently a directory.")
+      expect(shell.copy_or_move(temp_file_1, temp_file_2, :copy, true, false, false)).to be_false
+
+      shell.console.should_receive(:error).with("Cannot move file {mark=bright}#{temp_file_1}{/mark} to {mark=bright}#{temp_file_2}{/mark} because it is currently a directory.")
+      expect(shell.copy_or_move(temp_file_1, temp_file_2, :move, true, false, false)).to be_false
+    end
+
+    it "should create the parent directory if needed" do
+      expect(shell.check(temp_dir_1, :dir)).to be_false
+
+      shell.should_receive(:create_directories).exactly(2)
+      expect(shell.copy_or_move(temp_file_1, temp_dir_1 + "/test-1", :copy)).to be_false
+      expect(shell.copy_or_move(temp_file_1, temp_dir_1 + "/test-1", :move)).to be_false
+    end
+
+    it "should only print the list of files" do
+      FileUtils.should_not_receive(:cp_r)
+      FileUtils.should_not_receive(:move)
+
+      shell.console.should_receive(:warn).with("Will copy a file:")
+      expect(shell.copy_or_move(temp_file_1, temp_file_2, :copy, false)).to be_true
+      shell.console.should_receive(:warn).with("Will copy following entries:")
+      expect(shell.copy_or_move([temp_file_1, temp_file_2], temp_dir_1, :copy, false)).to be_true
+
+      shell.console.should_receive(:warn).with("Will move a file:")
+      expect(shell.copy_or_move(temp_file_1, temp_file_2, :move, false)).to be_true
+      shell.console.should_receive(:warn).with("Will move following entries:")
+      expect(shell.copy_or_move([temp_file_1, temp_file_2], temp_dir_1, :move, false)).to be_true
+    end
+
+    it "should complain about non writeable parent directory" do
+      File.open(temp_file_1, "w") {|f| f.write("OK") }
+
+      shell.console.should_receive(:error).with("Cannot copy file {mark=bright}#{temp_file_1}{/mark} to non writable directory {mark=bright}/dev{/mark}.")
+      expect(shell.copy_or_move(temp_file_1, "/dev/bovem", :copy, true, false, false)).to be_false
+
+      shell.console.should_receive(:error).with("Cannot move file {mark=bright}#{temp_file_1}{/mark} to non writable directory {mark=bright}/dev{/mark}.")
+      expect(shell.copy_or_move(temp_file_1, "/dev/bovem", :move, true, false, false)).to be_false
+    end
+
+    it "should complain about other exceptions" do
+      FileUtils.stub(:cp_r).and_raise(ArgumentError.new("ERROR"))
+      FileUtils.stub(:move).and_raise(ArgumentError.new("ERROR"))
+      File.open(temp_file_1, "w") {|f| f.write("OK") }
+
+      shell.console.should_receive(:error).with("Cannot copy file {mark=bright}#{temp_file_1}{/mark} to directory {mark=bright}#{File.dirname(temp_file_2)}{/mark} due to this error: [ArgumentError] ERROR.", "\n", 5)
+      expect(shell.copy_or_move(temp_file_1, temp_file_2, :copy, true, false, false)).to be_false
+
+      shell.console.should_receive(:error).with("Cannot move file {mark=bright}#{temp_file_1}{/mark} to directory {mark=bright}#{File.dirname(temp_file_2)}{/mark} due to this error: [ArgumentError] ERROR.", "\n", 5)
+      expect(shell.copy_or_move(temp_file_1, temp_file_2, :move, true, false, false)).to be_false
+    end
+
+    describe "should exit when requested to" do
+      it "by calling :fatal" do
+        FileUtils.stub(:cp_r).and_raise(ArgumentError.new("ERROR"))
+        FileUtils.stub(:move).and_raise(ArgumentError.new("ERROR"))
+
+        File.open(temp_file_1, "w") {|f| f.write("OK") }
+        File.open(temp_file_2, "w") {|f| f.write("OK") }
+
+        shell.console.should_receive(:fatal).with("Cannot copy file {mark=bright}#{temp_file_1}{/mark} to directory {mark=bright}/dev{/mark} due to this error: [ArgumentError] ERROR.", "\n", 5)
+        expect(shell.copy_or_move(temp_file_1, "/dev/bovem", :copy, true, false, true)).to be_false
+
+        shell.console.should_receive(:fatal).with("Cannot move file {mark=bright}#{temp_file_1}{/mark} to directory {mark=bright}/dev{/mark} due to this error: [ArgumentError] ERROR.", "\n", 5)
+        expect(shell.copy_or_move(temp_file_1, "/dev/bovem", :move, true, false, true)).to be_false
+
+        Kernel.stub(:exit).and_return(true)
+        shell.console.should_receive(:error).with("Cannot copy following entries to {mark=bright}/dev{/mark}:")
+        expect(shell.copy_or_move([temp_file_1, temp_file_2], "/dev", :copy, true, false, true)).to be_false
+
+        shell.console.should_receive(:error).with("Cannot move following entries to {mark=bright}/dev{/mark}:")
+        expect(shell.copy_or_move([temp_file_1, temp_file_2], "/dev", :move, true, false, true)).to be_false
+      end
+
+      it "by calling Kernel#exit" do
+        File.open(temp_file_1, "w") {|f| f.write("OK") }
+        File.open(temp_file_2, "w") {|f| f.write("OK") }
+
+        Kernel.should_receive(:exit).with(-1).exactly(4).and_return(true)
+        expect(shell.copy_or_move(temp_file_1, "/dev/bovem", :copy, true, false, true)).to be_false
+        expect(shell.copy_or_move([temp_file_1, temp_file_2], "/dev", :copy, true, false, true)).to be_false
+        expect(shell.copy_or_move(temp_file_1, "/dev/bovem", :move, true, false, true)).to be_false
+        expect(shell.copy_or_move([temp_file_1, temp_file_2], "/dev", :move, true, false, true)).to be_false
+      end
+    end
+  end
+
+  describe "#copy" do
+    it "should forward everything to #copy_or_move" do
+      shell.should_receive(:copy_or_move).with("A", "B", :copy, "C", "D", "E")
+      shell.copy("A", "B", "C", "D", "E")
+    end
+  end
+
+  describe "#move" do
+    it "should forward everything to #copy_or_move" do
+      shell.should_receive(:copy_or_move).with("A", "B", :move, "C", "D", "E")
+      shell.move("A", "B", "C", "D", "E")
+    end
+  end
+
+  describe "#within_directory" do
+    let(:target){ File.expand_path("~") }
+
+    it "should execute block in other directory and return true" do
+      owd = Dir.pwd
+      dir = ""
+
+      shell.within_directory(target) do
+        expect(Dir.pwd).to eq(target)
+        dir = "OK"
+      end
+
+      expect(shell.within_directory(target) { dir = "OK" }).to be_true
+    end
+
+    it "should change and restore directory" do
+      owd = Dir.pwd
+
+      shell.within_directory(target) do
+        expect(Dir.pwd).to eq(target)
+      end
+
+      expect(Dir.pwd).to eq(owd)
+    end
+
+    it "should change but not restore directory" do
+      owd = Dir.pwd
+
+      shell.within_directory(target) do
+        expect(Dir.pwd).to eq(target)
+      end
+
+      expect(Dir.pwd).not_to eq(target)
+    end
+
+    it "should show messages" do
+      shell.console.should_receive(:info).with(/Moving into directory \{mark=bright\}(.+)\{\/mark\}/)
+      shell.within_directory(target, true, true) { "OK" }
+    end
+
+    it "should return false and not execute code in case of invalid directory" do
+      dir = ""
+
+      expect(shell.within_directory("/invalid") { dir = "OK" }).to be_false
+      expect(dir).to eq("")
+
+      Dir.stub(:chdir).and_raise(ArgumentError)
+      expect(shell.within_directory("/") { dir = "OK" }).to be_false
+
+      Dir.unstub(:chdir)
+      Dir.stub(:pwd).and_return("/invalid")
+      expect(shell.within_directory("/") { dir = "OK" }).to be_false
+    end
+  end
+
+  describe "#create_directories" do
+    before(:each) do
+      FileUtils.rm_r(temp_file_1) if File.exists?(temp_file_1)
+      FileUtils.rm_r(temp_file_2) if File.exists?(temp_file_2)
+      FileUtils.rm_r(temp_file_3) if File.exists?(temp_file_3)
+      FileUtils.rm_r(temp_dir_1) if File.exists?(temp_dir_1)
+      FileUtils.rm_r(temp_dir_2) if File.exists?(temp_dir_2)
+    end
+
+    after(:each) do
+      FileUtils.rm_r(temp_file_1) if File.exists?(temp_file_1)
+      FileUtils.rm_r(temp_file_2) if File.exists?(temp_file_2)
+      FileUtils.rm_r(temp_file_3) if File.exists?(temp_file_3)
+      FileUtils.rm_r(temp_dir_1) if File.exists?(temp_dir_1)
+      FileUtils.rm_r(temp_dir_2) if File.exists?(temp_dir_2)
+    end
+
+    it "should create directory" do
+      expect(shell.create_directories([temp_dir_1, temp_dir_2])).to be_true
+      expect(shell.check(temp_dir_1, :directory)).to be_true
+      expect(shell.check(temp_dir_2, :directory)).to be_true
+    end
+
+    it "should only print the list of files" do
+      shell.console.should_receive(:warn).with("Will create directories:")
+      FileUtils.should_not_receive(:mkdir_p)
+      expect(shell.create_directories(temp_file_1, 0755, false)).to be_true
+    end
+
+    it "should complain about directory already existing" do
+      shell.create_directories(temp_dir_1, 0755, true, false, false)
+      shell.console.should_receive(:error).with("The directory {mark=bright}#{temp_dir_1}{/mark} already exists.")
+      expect(shell.create_directories(temp_dir_1, 0755, true, false, false)).to be_false
+    end
+
+    it "should complain about paths already existing as a file." do
+      File.open(temp_file_1, "w") {|f| f.write("OK") }
+
+      shell.console.should_receive(:error).with("Path {mark=bright}#{temp_file_1}{/mark} is currently a file.")
+      expect(shell.create_directories(temp_file_1, 0755, true, false, false)).to be_false
+    end
+
+    it "should complain about non writable parents" do
+      shell.console.should_receive(:error).with("Cannot create following directory due to permission denied: {mark=bright}/dev/bovem{/mark}.")
+      expect(shell.create_directories("/dev/bovem", 0755, true, false, false)).to be_false
+    end
+
+    it "should complain about other exceptions" do
+      FileUtils.stub(:mkdir_p).and_raise(ArgumentError.new("ERROR"))
+      shell.console.should_receive(:error).with("Cannot create following directories:")
+      shell.console.should_receive(:write).at_least(2)
+      expect(shell.create_directories(temp_dir_1, 0755, true, true, false)).to be_false
+    end
+
+    describe "should exit when requested to" do
+      it "by calling :fatal" do
+        shell.console.should_receive(:fatal).with("Path {mark=bright}/dev/null{/mark} is currently a file.")
+        expect(shell.create_directories("/dev/null")).to be_false
+      end
+
+      it "by calling Kernel#exit" do
+        FileUtils.stub(:mkdir_p).and_raise(ArgumentError.new("ERROR"))
+        Kernel.should_receive(:exit).with(-1)
+        expect(shell.create_directories(temp_dir_1, 0755, true, true)).to be_false
+      end
+    end
+  end
+
+  describe "#find" do
+    let(:root) {File.expand_path(File.dirname(__FILE__) + "/../../") }
+
+    it "it should return [] for invalid or empty directories" do
+      expect(shell.find("/invalid", /rb/)).to eq([])
+    end
+
+    it "it should return every file for empty patterns" do
+      files = []
+
+      Find.find(root) do |file|
+        files << file
+      end
+
+      expect(shell.find(root, nil)).to eq(files)
+    end
+
+    it "should find files basing on pattern" do
+      files = []
+
+      Find.find(root + "/lib/bovem/") do |file|
+        files << file if !File.directory?(file)
+      end
+
+      expect(shell.find(root, /lib\/bovem\/.+rb/)).to eq(files)
+      expect(shell.find(root, /lib\/BOVEM\/.+rb/)).to eq(files)
+      expect(shell.find(root, "lib\/bovem/")).to eq(files)
+      expect(shell.find(root, /lib\/BOVEM\/.+rb/, false, true)).to eq([])
+    end
+
+    it "should find files basing on extension" do
+      files = []
+
+      Find.find(root + "/lib/bovem/") do |file|
+        files << file if !File.directory?(file)
+      end
+
+      expect(shell.find(root + "/lib/bovem", /rb/, true)).to eq(files)
+      expect(shell.find(root + "/lib/bovem", /bovem/, true)).to eq([])
+      expect(shell.find(root + "/lib/bovem", "RB", true, true)).to eq([])
+    end
+  end
+end