csd 0.1.8 → 0.1.9

data/lib/csd/user_interface/silent.rb

@@ -0,0 +1,28 @@
+# -*- encoding: UTF-8 -*-
+require 'csd/user_interface/base'
+
+module CSD
+  module UserInterface
+    class Silent < Base
+      
+      def separator
+      end
+      
+      def indicate_activity
+      end
+    
+      def debug(message)
+      end
+    
+      def info(message)
+      end
+    
+      def warn(message)
+      end
+
+      def error(message)
+      end
+      
+    end
+  end
+end

data/lib/csd/vendor/active_support/object_extensions.rb

@@ -0,0 +1,37 @@
+# -*- encoding: UTF-8 -*-
+
+module CSD
+  module Vendor
+    # Author
+    # 
+    # Copyright (c) 2005-2010 David Heinemeier Hansson
+    # This module is taken from Ruby on Rails' ActiveSupport
+    # Link: http://github.com/rails/rails/tree/master/activesupport
+    #
+    # License
+    # 
+    # Active Support is released under the MIT license.
+    #
+    module ActiveSupport
+      # This module comprises extensions to Object (the parent of all classes).
+      #
+      module ObjectExtensions
+        
+        # Makes backticks behave (somewhat more) similarly on all platforms.
+        # On win32 `nonexistent_command` raises Errno::ENOENT; on Unix, the
+        # spawned shell prints a message to stderr and sets $?.  We emulate
+        # Unix on the former but not the latter.
+        def `(command) #:nodoc:
+          super
+        rescue Errno::ENOENT => e
+          STDERR.puts "#$0: #{e}"
+        end
+        
+      end
+    end
+  end
+end
+
+class Object #:nodoc:
+  include CSD::Vendor::ActiveSupport::ObjectExtensions
+end

data/test/application/test_minisip.rb

@@ -5,21 +5,21 @@ class TestDir < Test::Unit::TestCase
   
   include CSD
   
-  context "The Minisip application" do
+  context "The Minisip Base application" do
   
     setup do
+      ARGV.clear
       Options.clear
+      ARGV.push(@name)
+      Applications.current!
       @app = Application::Minisip::Base.new
     end
-
-    teardown do
-    end
     
-    should "respond to valid actions" do
+    should "respond to a valid action" do
       assert @app.respond_to?(:compile)
     end
     
-    should "know how to identify a subset of libraries with --only" do
+    should "know how to identify and sort a subset of internal MiniSIP libraries with --only" do
       Options.only = nil
       assert_equal Application::Minisip::Base::LIBRARIES, @app.libraries
       Options.only = %w{ libmcrypto }
@@ -32,8 +32,13 @@ class TestDir < Test::Unit::TestCase
       assert_equal %w{ libmutil minisip }, @app.libraries
     end
     
+
+
+
+
+    
     context "when downloading source code" do
-  
+    
       should "dummy" do
         assert true
       end

data/test/functional/test_application_base.rb

@@ -0,0 +1,56 @@
+require 'helper'
+require 'ostruct'
+require 'tmpdir'
+
+class TestApplicationBase < Test::Unit::TestCase
+  
+  include CSD
+  
+  context "An application instance" do
+  
+    setup do
+      ARGV.clear
+      Options.clear
+      @name = 'minisip'
+      ARGV.push(@name)
+      assert @app = Applications.find(@name).instance
+    end
+    
+    should "use a temporary directory as working directory when the --temp options is given" do
+      Options.temp = true
+      @app.define_working_directory
+      assert_kind_of Pathname, Path.work
+      # We verify whether this is a tempory directory by comparing the first six characters
+      # of the working directory path with the path of a freshly created tmp-directory.
+      # TODO: Find a better way to test the creation of temporary directories
+      tmp_dir = Pathname.new Dir.mktmpdir
+      assert_equal tmp_dir.to_s[0..5], Path.work.to_s[0..5]
+      # Cleanup
+      assert Path.work.rmdir
+      assert tmp_dir.rmdir
+    end
+    
+    should "accept a manual working directory parameter" do
+      Options.work_dir = '/my/cool/working/dir'
+      @app.define_working_directory
+      assert_kind_of Pathname, Path.work
+      assert_equal '/my/cool/working/dir', Path.work.to_s
+    end
+    
+    should "overwrite the --temp option when the --work-dir option is given" do
+      Options.temp = true
+      Options.work_dir = '/'
+      @app.define_working_directory
+      assert_kind_of Pathname, Path.work
+      assert_equal '/', Path.work.to_s
+    end
+    
+    should "take the current pwd with a subdirectory in the name of the application as working directory by default" do
+      @app.define_working_directory
+      assert_kind_of Pathname, Path.work
+      assert_equal File.join(Dir.pwd, "#{@name}.ai"), Path.work.to_s
+    end
+    
+  end # context "An application instance"
+
+end

data/test/functional/test_application_default.rb

@@ -0,0 +1,33 @@
+require 'helper'
+require 'ostruct'
+require 'tmpdir'
+
+module CSD
+  module Application
+    # This is our dummy application for testing
+    #
+    module Chess
+      class << self
+        include CSD::Application::Default
+      end
+    end
+  end
+end
+
+class TestApplicationDefault < Test::Unit::TestCase
+  
+  include CSD
+  
+  context "the empty, default application module" do
+    
+    setup do
+      @mod = Application::Chess
+    end
+
+    should "raise an error if the instance method was called" do
+      assert_raise(Error::Application::NoInstanceMethod) { @mod.instance }
+    end
+    
+  end
+  
+end

data/test/functional/test_applications.rb

@@ -1,5 +1,6 @@
 require 'helper'
 require 'ostruct'
+require 'tmpdir'
 
 class TestApplications < Test::Unit::TestCase
   
@@ -13,31 +14,31 @@ class TestApplications < Test::Unit::TestCase
       Options.clear
     end
     
-    context "and considering a valid application" do
+    context "and considering an application module which can be loaded" do
 
       setup do
-        @app = 'minisip'
-        assert Applications.find(@app)
+        @name = 'minisip'
+        assert Applications.find(@name)
       end
       
       context "the find function" do
     
         should "find an application in the first argument" do
-          ARGV.push(@app)
-          assert_equal @app, Applications.current!.name
+          ARGV.push(@name)
+          assert_equal @name, Applications.current!.name
         end
       
         should "find an application in the second argument" do
           ARGV.push('dummy')
-          ARGV.push(@app)
-          assert_equal @app, Applications.current!.name
+          ARGV.push(@name)
+          assert_equal @name, Applications.current!.name
         end
       
         should "find an application in the third argument" do
           ARGV.push('foo')
           ARGV.push('bar')
-          ARGV.push(@app)
-          assert_equal @app, Applications.current!.name
+          ARGV.push(@name)
+          assert_equal @name, Applications.current!.name
         end
       
         should "set nothing, if there is no valid app" do
@@ -50,17 +51,21 @@ class TestApplications < Test::Unit::TestCase
       end # context "the find function"
       
       context "the application module" do
+        
+        should "implement an instance method" do
+          assert Applications.find(@name).respond_to?(:instance)
+        end
       
         should "know its name" do
-          assert_equal @app, Applications.find(@app).name
+          assert_equal @name, Applications.find(@name).name
         end
         
         should "respond to options with a string" do
-          assert_kind_of(String, Applications.find(@app).options)
-          assert_kind_of(String, Applications.find(@app).options('install'))
-          assert_kind_of(String, Applications.find(@app).options('not_a_valid_action'))
+          assert_kind_of(String, Applications.find(@name).options)
+          assert_kind_of(String, Applications.find(@name).options('install'))
+          assert_kind_of(String, Applications.find(@name).options('not_a_valid_action'))
         end
-      
+        
       end # context "the application module"
       
     end # context "and considering a valid application, find"

data/test/functional/test_cli.rb

@@ -0,0 +1,80 @@
+require 'helper'
+
+class TestApplications < Test::Unit::TestCase
+  
+  include CSD
+  
+  context "The CLI instance" do
+  
+    setup do
+      Options.clear
+      Options.testmode = true
+      Options.silent = false
+      assert_instance_of UserInterface::CLI, CSD.ui
+    end
+    
+    should "be able to indicate activity by printing periods" do
+      out, err = capture do
+        UI.indicate_activity
+        UI.indicate_activity
+        UI.indicate_activity
+      end
+      assert_equal '...', out
+      assert_equal '', err
+    end
+  
+    should "represent a separator by a new line" do
+      out, err = capture do
+        UI.separator
+        UI.separator
+        UI.separator
+      end
+      assert_equal "\n\n\n", out
+      assert_equal '', err
+    end
+
+    should "log debugging messages in debug mode" do
+      Options.debug = true
+      out, err = capture do
+        UI.debug "debugging"
+      end
+      assert_match /debugging/, out
+      assert_equal '', err
+    end
+    
+    should "NOT log debugging messages UNLESS debug mode" do
+      Options.debug = false
+      out, err = capture do
+        UI.debug "debugging"
+      end
+      assert_equal '', out
+      assert_equal '', err
+    end
+    
+    should "log info messages" do
+      out, err = capture do
+        UI.info "informing"
+      end
+      assert_match /informing/, out
+      assert_equal '', err
+    end
+    
+    should "log warning messages" do
+      out, err = capture do
+        UI.warn "waaarning"
+      end
+      assert_match /waaarning/, out
+      assert_equal '', err
+    end
+    
+    should "log error messages to STDOUT" do
+      out, err = capture do
+        UI.error "erroring"
+      end
+      assert_equal '', out
+      assert_match /erroring/, err
+    end
+   
+  end # context "An CLI instance"
+
+end

data/test/functional/test_commands.rb

@@ -72,18 +72,23 @@ That we in truth can nothing know!}
         ensure_mkdir(@dir)
         @dir.chmod(0000)
         assert_kind_of(CommandResult, result = Cmd.mkdir(File.join(@dir, 'subdir_in_readonly_dir'), :die_on_failure => false))
-        assert !result.success?
+        if superuser?
+          assert result.success?
+          assert result.writable?
+        else
+          assert !result.success?
+          assert !result.writable?
+        end
         assert !result.already_existed?
-        assert !result.writable?
         @dir.chmod(0777) # Cleanup
       end
       
       should "notify if there is no permission to create a new directory with die_on_failure" do
         ensure_mkdir(@dir)
         @dir.chmod(0000)
-        assert_raise(Error::UI::Die) {
+        assert_raise(Error::Command::MkdirFailed) {
           Cmd.mkdir(File.join(@dir, 'subdir_in_readonly_dir'), :die_on_failure => true)
-        }
+        } unless superuser?
         @dir.chmod(0777) # Cleanup
       end
       
@@ -93,7 +98,7 @@ That we in truth can nothing know!}
         assert_kind_of(CommandResult, result = Cmd.mkdir(@dir))
         assert result.success?
         assert result.already_existed?
-        assert !result.writable?
+        superuser? ? assert(result.writable?) : assert(!result.writable?)
         @dir.chmod(0777) # Cleanup
       end
       
@@ -117,7 +122,7 @@ That we in truth can nothing know!}
       
       should "realize when the target is not a directory, but a file or something with die_on_failure" do
         testfile_path = File.join(@tmp, 'testfile')
-        assert_raise(Error::UI::Die) {
+        assert_raise(Error::Command::CdFailed) {
           Cmd.cd(testfile_path, :die_on_failure => true)
         }
       end
@@ -128,7 +133,7 @@ That we in truth can nothing know!}
       end
 
       should "realize when the target doesn't exist with die_on_failure" do
-        assert_raise(Error::UI::Die) {
+        assert_raise(Error::Command::CdFailed) {
           Cmd.cd('/i/for/sure/dont/exist', :die_on_failure => true)
         }
       end
@@ -189,7 +194,7 @@ That we in truth can nothing know!}
         end
         
         should "know when a source file doesn't exist with die_on_failure" do
-          assert_raise(Error::UI::Die) {
+          assert_raise(Error::Command::CopyFailed) {
             Cmd.copy('/no/source', @subdir, :die_on_failure => true)
           }
         end
@@ -200,7 +205,7 @@ That we in truth can nothing know!}
         end
         
         should "know when a destination directory doesn't exist with die_on_failure" do
-          assert_raise(Error::UI::Die) {
+          assert_raise(Error::Command::CopyFailed) {
             Cmd.copy(@file1, '/no/destination', :die_on_failure => true)
           }
         end
@@ -231,7 +236,7 @@ That we in truth can nothing know!}
         end
 
         should "know when a source file doesn't exist with die_on_failure" do
-          assert_raise(Error::UI::Die) {
+          assert_raise(Error::Command::MoveFailed) {
             Cmd.move('/no/source', @subdir, :die_on_failure => true)
           }
         end
@@ -257,7 +262,7 @@ That we in truth can nothing know!}
         end
         
         should "be unsuccessful if the file doesn't exist with die_on_failure" do
-          assert_raise(Error::UI::Die) {
+          assert_raise(Error::Command::ReplaceFailed) {
             Cmd.replace('/i/am/not/there', 'FAUST', 'GOETHE')
           }
         end
@@ -290,39 +295,78 @@ That we in truth can nothing know!}
   end # context "As a directory function"
   
   context "run" do
-
-    setup do
-      Options.silent = true
-      Options.reveal = false
-      Options.online = true # Some tests need an uplink to the Internet. For now, we will hardcode here so that they should be executed.
-      Options.testmode = true # This puts us in test-mode, basically to prevent STDOUT and STDERR to show unnecessary output.
-    end
     
-    should "return a successfull CommandResult if the command was OK" do
-      assert_kind_of(CommandResult, result = Cmd.run('cd'))
-      assert_kind_of(Process::Status, result.status)
-      assert result.success?
-    end
-    
-    should "not produce any output in :internal mode and in non-verbose mode" do
-      Options.testmode = false
-      out, err = capture do
-        assert_kind_of(CommandResult, result = Cmd.run('ls', :internal => true))
+    context "in normal mode" do
+
+      setup do
+        Options.clear
+        Options.testmode = true
+        Options.silent = false
       end
-      assert_equal '', out
-    end
     
-    should "should produce output in NON-:internal mode and in non-verbose mode" do
-      out, err = capture do
-        assert_kind_of(CommandResult, result = Cmd.run('which ls', :internal => false))
+      should "not produce any output in :internal mode" do
+        out, err = capture do
+          assert_kind_of(CommandResult, result = Cmd.run('ls', :internal => true))
+        end
+        assert_equal '', out
+        assert_equal '', err
       end
-      assert_equal('.', out)
-    end
+      
+      should "produce output in :internal mode" do
+        out, err = capture do
+          assert_kind_of(CommandResult, result = Cmd.run('ls', :internal => false))
+        end
+        assert_match /\.+/, out # Make sure it contains only periods
+        assert_equal '', err
+      end
+      
+      context "in verbose mode" do
+        
+        setup do
+          Options.verbose = true
+        end
+        
+        should "produce verbose output" do
+          out, err = capture do
+            assert_kind_of(CommandResult, result = Cmd.run('ls', :internal => false))
+          end
+          assert out.size > 0
+          assert_match /[^\.]/, out # Match anything that is not a period
+          assert_equal '', err
+        end
 
-    should "return a non-successfull CommandResult if the command was bad without die_on_failure" do
-      assert_kind_of(CommandResult, result = Cmd.run('this-command-does-not-exist', :die_on_failure => false))
-      assert !result.success?
-    end
+      end # context "in verbose mode"
+    
+    end # context "in normal mode"
+    
+    context "in silent mode" do
+      
+      setup do
+        Options.clear
+        Options.testmode = true
+        Options.silent = true
+      end
+      
+      should "return a successfull CommandResult if the command was OK" do
+        assert_kind_of(CommandResult, result = Cmd.run('cd'))
+        assert_kind_of(Process::Status, result.status)
+        assert result.success?
+      end
+      
+      should "not produce any output" do
+        out, err = capture do
+          assert_kind_of(CommandResult, result = Cmd.run('ls', :internal => false))
+        end
+        assert_equal '', out
+      end
+      
+      should "return a non-successfull CommandResult if the command was bad without die_on_failure" do
+        assert_kind_of(CommandResult, result = Cmd.run('this-command-does-not-exist', :die_on_failure => false))
+        assert !result.success?
+      end
+      
+      
+    end # context "in silent mode"
     
   end
   
@@ -348,7 +392,7 @@ That we in truth can nothing know!}
       assert result.success?
       assert @dir.directory?
       assert File.exist?(File.join(@dir, 'dummy.txt'))
-    end if Options.online
+    end if ONLINE
     
     should "do nothing at the destination in reveal mode" do
       Options.reveal = true