bee 0.3.1 → 0.4.0

data/test/tc_bee_console_formatter.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-# Copyright 2006 Michel Casabianca <casa@sweetohm.net>
+# Copyright 2006-2007 Michel Casabianca <michel.casabianca@gmail.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,18 +16,22 @@
 
 require 'test/unit'
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'bee'
 require 'bee_console'
 
+# Test case for console formatter.
 class TestBeeConsoleFormatter < Test::Unit::TestCase
 
+  # Test default target title formatting.
   def test_format_target_default
     expected = "#{'-'*72} TEST --"
-    formatter = Bee::Console::Formatter.new(nil)
+    formatter = Bee::Console::Formatter.new('ll:80')
     target = Bee::Target.new({ 'target' => 'TEST' }, nil)
     actual = formatter.format_target(target)
     assert_equal(expected, actual)
   end
-
+  
+  # Test target title formatting with colorization.
   def test_format_target
     expected = "\e[1;31;42m#{'#'*64} TEST ##\e[0m"
     style = {
@@ -43,4 +47,35 @@ class TestBeeConsoleFormatter < Test::Unit::TestCase
     assert_equal(expected, actual)
   end
 
+  def test_format_task
+    expected = '- foo: bar'
+    task = {'foo' => 'bar'}
+    formatter = Bee::Console::Formatter.new('')
+    actual = formatter.format_task(task)
+    assert_equal(expected, actual)
+    expected = '- rb: bar'
+    task = {'rb' => 'bar'}
+    actual = formatter.format_task(task)
+    assert_equal(expected, actual)
+  end
+  
+  def test_help_build
+    expected = "- Build: \"test\"
+  Description: Test description
+- Properties:
+  - base: \"#{Dir.pwd}\"
+  - foo: \"bar\"
+  - test: \"test\"
+- Targets:
+  - test: Test description
+- Default: test"
+    object = [{'build' => 'test', 'description' => 'Test description'},
+      {'properties' => [{'test' => 'test'}, {'foo' => 'bar'}]},
+      {'target' => 'test', 'description' => 'Test description'}]
+    build = Bee::Build.new(object, nil)
+    formatter = Bee::Console::Formatter.new(nil)
+    actual = formatter.help_build(build)
+    assert_equal(expected, actual)
+  end
+
 end

data/test/tc_bee_context.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+
+# Copyright 2006-2007 Michel Casabianca <michel.casabianca@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test/unit'
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'bee'
+
+# Test context.
+class TestBeeContext < Test::Unit::TestCase
+
+  # Initialize a context.
+  def setup
+    @context = Bee::Context.new
+  end
+
+  # Test object evaluation.
+  def test_evaluate_object
+    # nil: must evaluate to nil
+    expected = nil
+    actual = @context.evaluate_object(expected)
+    assert_equal(expected, actual)
+    # string: return value with property references replaced
+    expected = "This is a test!"
+    actual = @context.evaluate_object(expected)
+    assert_equal(expected, actual)
+    @context.set_property(:foo, 'bar')
+    expected = 'This is bar!'
+    actual = @context.evaluate_object('This is #{foo}!')
+    assert_equal(expected, actual)
+    # symbol: replace with property value
+    expected = 'bar'
+    actual = @context.evaluate_object(:foo)
+    assert_equal(expected, actual)
+    # array: return array with elements evaluated
+    expected = [1, 2, 3]
+    actual = @context.evaluate_object([1, 2, 3])
+    assert_equal(expected, actual)
+    expected = ['a', 'b', 'bar']
+    actual = @context.evaluate_object(['a', 'b', :foo])
+    assert_equal(expected, actual)
+    # hash: return hash with keys and values evaluated
+    expected = { 1 => 'bar', 'bar' => 2 }
+    actual = @context.evaluate_object({ 1 => :foo, '#{foo}' => 2 })
+    assert_equal(expected, actual)
+    # complex: symbol referencing an array
+    expected = [1, 2, 3]
+    @context.set_property('int', 3)
+    @context.set_property('array', [1, 2, :int])
+    actual = @context.evaluate_object(:array)
+    assert_equal(expected, actual)
+  end
+  
+  # Test property access
+  def test_set
+    # nominal case
+    @context.set_property(:foo, 'bar')
+    assert_equal(@context.get_property(:foo), 'bar')
+    # error case
+    begin
+      @context.set_property('123', 'foo')
+      flunk "Property setting should have failed"
+    rescue
+    end
+    begin
+      @context.get_property('^^^^^123')
+      flunk "Property getting should have failed"
+    rescue
+    end    
+  end
+
+end

data/test/tc_bee_task_default.rb

@@ -0,0 +1,467 @@
+#!/usr/bin/env ruby
+
+# Copyright 2006-2007 Michel Casabianca <michel.casabianca@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+$:.unshift(File.join(File.dirname(__FILE__)))
+require 'tmp_test_case'
+require 'test_build'
+require 'test_build_listener'
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'bee'
+require 'bee_task_default'
+require 'fileutils'
+
+# Test default bee tasks.
+class TestBeeDefaultTasks < TmpTestCase
+  
+  # Run before any test: create a context object and load tasks in it.
+  def setup
+    super
+    @context = Bee::Context.new
+    @listener = TestBuildListener.new
+    @build = TestBuild.new(@context, @listener)
+    @package = Bee::Task::Default.new(@build)
+  end
+  
+  # Test task print.
+  def test_task_print
+    @package.print('TEST')
+    assert_equal("TEST\n", @listener.output)
+    @listener.output = ''
+    @package.print(['foo', 'bar'])
+    assert_equal("[\"foo\", \"bar\"]\n", @listener.output)
+  end
+  
+  # Test task cat.
+  def test_task_cat
+    path = File.join(@tmp_dir, 'test.txt')
+    File.open(path, 'w') {|file| file.write('TEST')}
+    @package.cat(path)
+    assert_equal("TEST\n", @listener.output)
+    @listener.output = ''
+    begin
+      @package.cat('foo')
+      flunk "Cat should have failed"
+    rescue
+      assert_equal("File 'foo' not found", $!.message)
+    end
+  end
+  
+  # Test task cd.
+  def test_task_cd
+    working_dir = File.expand_path(File.dirname(__FILE__))
+    # test nominal case
+    @package.cd(@tmp_dir)
+    expected = @tmp_dir
+    actual = Dir.getwd
+    assert_equal(expected, actual)
+    # test changing to a directory that doesn't exists
+    begin
+      dir = File.join(@tmp_dir, 'lkjqzcjv')
+      @package.cd(dir)
+      flunk "Should have raised an Errno::ENOENT"
+    rescue Errno::ENOENT
+    end
+    # test bad arguments
+    begin
+      @package.cd(Object.new)
+      flunk "Should have raised a BuildError"
+    rescue Bee::Util::BuildError
+      expected = 'cd parameter is a String'
+      actual = $!.message
+      assert_equal(expected, actual)
+    end
+  end
+  
+  # Test task mkdir.
+  def test_task_mkdir
+    # nominal case with a single recursive dir
+    dir = File.join(@tmp_dir, 'foo', 'bar')
+    @package.mkdir(dir)
+    expected = true
+    actual = File.exists?(dir) and File.directory?(dir)
+    assert_equal(expected, actual)
+    # nominal case with a list of directories
+    dirs = [File.join(@tmp_dir, 'toto'), File.join(@tmp_dir, 'titi')]
+    @package.mkdir(dirs)
+    found = Dir.entries(@tmp_dir)
+    assert(found.member?('toto'))
+    assert(found.member?('titi'))
+    # error case
+    dir = Object.new
+    begin
+      @package.mkdir(dir)
+      flunk "Should have raised a BuildError"
+    rescue Bee::Util::BuildError => e
+      expected = 'mkdir parameter must a String or an array of Strings'
+      actual = $!.message
+      assert_equal(expected, actual)
+    end
+    # another error case
+    dirs = [File.join(@tmp_dir, 'foo'), Object.new]
+    begin
+      @package.mkdir(dirs)
+      flunk "Should have raised a BuildError"
+    rescue Bee::Util::BuildError => e
+      expected = 'mkdir parameter must a String or an array of Strings'
+      actual = $!.message
+      assert_equal(expected, actual)
+    end
+  end
+  
+  # Test task cp.
+  def test_task_cp
+    # nominal case for a src and dest file
+    includes = File.join(@tmp_dir, 'file.txt')
+    create_file(includes)
+    dest = File.join(@tmp_dir, 'dest.txt')
+    @package.cp({ 'includes' => includes, 'dest' => dest })
+    assert_file(dest, includes)
+    # nominal case for src files and destination directory
+    clean_tmp
+    includes2 = File.join(@tmp_dir, 'file2.txt')
+    dest = File.join(@tmp_dir, 'dir')
+    create_file(includes)
+    create_file(includes2)
+    FileUtils.makedirs(dest)
+    @package.cp({ 'includes' => [includes, includes2], 'dest' => dest })
+    assert_file(File.join(dest, 'file.txt'), includes)
+    assert_file(File.join(dest, 'file2.txt'), includes2)
+    # nominal case for src and dest directory
+    clean_tmp
+    includes = File.join(@tmp_dir, 'dir')
+    dest = File.join(@tmp_dir, 'todir')
+    FileUtils.makedirs(includes)
+    FileUtils.makedirs(dest)
+    file1 = File.join(includes, 'file1.txt')
+    file2 = File.join(includes, 'file2.txt')
+    create_file(file1)
+    create_file(file2)
+    @package.cp({ 'includes' => includes, 'dest' => dest })
+    assert_file(File.join(dest, 'dir', 'file1.txt'), file1)
+    assert_file(File.join(dest, 'dir', 'file2.txt'), file2)
+    # error case: dest must be a string
+    clean_tmp
+    includes = File.join(@tmp_dir, 'dir')
+    dest = ['foo', 'bar']
+    begin
+      @package.cp({ 'includes' => includes, 'dest' => dest })
+      flunk "Should have failed because dest must be a string"
+    rescue
+    end
+  end
+  
+  # Test task mv.
+  def test_task_mv
+    # nominal case for a src and dest file
+    includes = File.join(@tmp_dir, 'src.txt')
+    create_file(includes)
+    dest = File.join(@tmp_dir, 'dest.txt')
+    @package.mv({ 'includes' => includes, 'dest' => dest })
+    assert_file(dest, includes)
+    assert(!File.exists?(File.join(@tmp_dir, includes)))
+    # nominal case with two source files
+    clean_tmp
+    includes = File.join(@tmp_dir, 'src.txt')
+    includes2 = File.join(@tmp_dir, 'src2.txt')
+    dest = File.join(@tmp_dir, 'dir')
+    create_file(includes)
+    create_file(includes2)
+    FileUtils.makedirs(dest)
+    @package.mv({ 'includes' => File.join(@tmp_dir, '*.txt'), 'dest' => dest })
+    assert_file(File.join(dest, 'src.txt'), includes)
+    assert_file(File.join(dest, 'src2.txt'), includes2)
+    assert(!File.exists?(includes))
+    assert(!File.exists?(includes2))
+    # nominal case with directory for src and dest
+    clean_tmp
+    includes = File.join(@tmp_dir, 'dir1')
+    dest = File.join(@tmp_dir, 'dir2')
+    FileUtils.makedirs(includes)
+    create_file(File.join(includes, 'test.txt'))
+    @package.mv({ 'includes' => includes, 'dest' => dest })
+    assert(File.exists?(dest))
+    assert(File.directory?(dest))
+    assert_file(File.join(dest, 'test.txt'), File.join(includes, 'test.txt'))
+    assert(!File.exists?(includes))
+    # error case: dest must be a string
+    clean_tmp
+    includes = File.join(@tmp_dir, 'src.txt')
+    dest = ['foo', 'bar']
+    begin
+      @package.mv({ 'includes' => includes, 'dest' => dest })
+      flunk "Should have failed because dest must be a string"
+    rescue
+    end
+  end
+  
+  # Test task rm.
+  def test_task_rm
+    # nominal case with a glob
+    file = File.join(@tmp_dir, 'test.txt')
+    create_file(file)
+    @package.rm(File.join(@tmp_dir, file))
+    assert(!File.exists?(File.join(@tmp_dir, file)))
+    # nominal case with two globs and three files
+    clean_tmp
+    file1 = File.join(@tmp_dir, 'test1.txt')
+    file2 = File.join(@tmp_dir, 'test2.txt')
+    file3 = File.join(@tmp_dir, 'test3.log')
+    create_file(file1)
+    create_file(file2)
+    create_file(file3)
+    @package.rm([File.join(@tmp_dir, '**/*.txt'), 
+    File.join(@tmp_dir, '**/*.log')])
+    assert(!File.exists?(file1))
+    assert(!File.exists?(file2))
+    assert(!File.exists?(file3))
+    # error case: parameter must be a string or array of strings
+    clean_tmp
+    begin
+      @package.rm({ 'foo' => 'bar' })
+      flunk "Shound have failed because parameter must be a string or array"
+    rescue
+    end
+    begin
+      @package.rm(['foo', { 'foo' => 'bar' }])
+      flunk "Shound have failed because parameter must be a string or array"
+    rescue
+    end
+  end
+  
+  # Test task rmdir.
+  def test_task_rmdir
+    # nominal case with one dir
+    dir = File.join(@tmp_dir, 'dir')
+    FileUtils.makedirs(dir)
+    @package.rmdir(dir)
+    assert(!File.exists?(dir))
+    # nominal case with two dirs
+    clean_tmp
+    dir1 = File.join(@tmp_dir, 'dir1')
+    dir2 = File.join(@tmp_dir, 'dir2')
+    FileUtils.makedirs(dir1)
+    FileUtils.makedirs(dir2)
+    @package.rmdir([dir1, dir2])
+    assert(!File.exists?(dir1))
+    assert(!File.exists?(dir2))
+    # error case: parameter must be a string or array of strings
+    clean_tmp
+    begin
+      @package.rmdir({ 'foo' => 'bar' })
+      flunk "Shound have failed because parameter must be a string or array"
+    rescue
+    end
+    begin
+      @package.rmdir(['foo', { 'foo' => 'bar' }])
+      flunk "Shound have failed because parameter must be a string or array"
+    rescue
+    end
+  end
+  
+  # Test task find.
+  def test_task_find
+    file1 = File.join(@tmp_dir, 'file1.txt')
+    file2 = File.join(@tmp_dir, 'file2.txt')
+    dir = File.join(@tmp_dir, 'dir')
+    file3 = File.join(dir, 'file3.txt')
+    create_file(file1)
+    create_file(file2)
+    FileUtils.makedirs(dir)
+    create_file(file3)
+    @package.find({ 'includes' => "#{File.join(@tmp_dir, '**/*.txt')}",
+                    'property' => 'list'})
+    list = @context.get_property('list').sort
+    expected = [file1, file2, file3].sort
+    assert_equal(expected, list)
+  end
+
+  # Test task test.
+  def test_task_test
+    # TODO: write a test when test task fixed.
+  end
+  
+  # Test task erb.
+  def test_task_erb
+    # nominal case in property
+    @context.set_property('test', 'TEST')
+    source = 'This is a <%= test %>'
+    @package.erb({ 'source' => source, 'property' => 'result' })
+    actual = @context.get_property(:result)
+    expected = 'This is a TEST'
+    assert_equal(expected, actual)
+    # nominal case in property
+    file = File.join(@tmp_dir, 'file.txt')
+    @package.erb({ 'source' => source, 'dest' => file })
+    actual = File.read(file)
+    expected = 'This is a TEST'
+    assert_equal(expected, actual)
+    # error case: source parameter must be a string
+    begin
+      @package.erb({ 'source' => [source], 'property' => 'result' })
+      flunk "should have failed because source parameter must be a string"
+    rescue
+    end
+    # error case: src parameter must be a string
+    begin
+      @package.erb({ 'src' => [source], 'property' => 'result' })
+      flunk "should have failed because src parameter must be a string"
+    rescue
+    end
+    # error case: dest parameter must be a string
+    begin
+      @package.erb({ 'src' => 'src', 'dest' => ['dest'] })
+      flunk "should have failed"
+    rescue
+    end
+    # error case: property parameter must be a string
+    begin
+      @package.erb({ 'src' => 'src', 'property' => ['result'] })
+      flunk "should have failed"
+    rescue
+    end
+    # error case: at least src or source parameter
+    begin
+      @package.erb({ 'dest' => 'dest' })
+      flunk "should have failed"
+    rescue
+    end
+    # error case: at least dest or property parameter
+    begin
+      @package.erb({ 'src' => 'src' })
+      flunk "should have failed"
+    rescue
+    end
+    # error case: error in erb source
+    source = 'This is a test <%= foo %>'
+    begin
+      @package.erb({ 'source' => source, 'property' => 'result' })
+      flunk "should have failed"
+    rescue
+    end
+  end
+
+  # Test task erb.
+  def test_task_rdoc
+    includes = __FILE__
+    dest = File.join(@tmp_dir, 'rdoc')
+    options = '-q'
+    @package.rdoc({'includes' => includes, 
+                    'dest' => dest, 
+                    'options' => options})
+    assert(File.exists?(File.join(dest, 'index.html')))
+    # error case: dest must be a string
+    begin
+      @package.rdoc({'includes' => includes, 'dest' => [dest]})
+      flunk "Should have failed"
+    rescue
+    end
+  end
+  
+  # Test task zip.
+  def test_task_zip
+    file1 = File.join(@tmp_dir, 'file1.txt')
+    file2 = File.join(@tmp_dir, 'file2.txt')
+    File.open(file1, 'w') {|file| file.write('File 1')}
+    File.open(file2, 'w') {|file| file.write('File 2')}
+    includes = "#{@tmp_dir}/*.txt"
+    dest = File.join(@tmp_dir, 'test.zip')
+    @package.zip({'includes' => includes, 'dest' => dest, 'prefix' => 'test'})
+    # error case: dest must be a string
+    begin
+      @package.zip({'includes' => includes, 'dest' => [dest]})
+      flunk "Shoud have failed"
+    rescue
+    end
+    # error case: prefix must be a string
+    begin
+      @package.zip({'includes' => includes, 
+                     'dest' => dest, 
+                     'prefix' => ['test']})
+      flunk "Shoud have failed"
+    rescue
+    end
+  end
+  
+  # Test task tar.
+  def test_task_tar
+    file1 = File.join(@tmp_dir, 'file1.txt')
+    file2 = File.join(@tmp_dir, 'file2.txt')
+    File.open(file1, 'w') {|file| file.write('File 1')}
+    File.open(file2, 'w') {|file| file.write('File 2')}
+    includes = "#{@tmp_dir}/*.txt"
+    dest = File.join(@tmp_dir, 'test.zip')
+    @package.tar({'includes' => includes, 'dest' => dest})
+    # error case: dest must be a string
+    begin
+      @package.tar({'includes' => includes, 'dest' => [dest]})
+      flunk "Shoud have failed"
+    rescue
+    end
+  end
+
+  # Test task gzip.
+  def test_task_gzip
+    src = File.join(@tmp_dir, 'file.txt')
+    File.open(src, 'w') {|file| file.write('File')}
+    dest = File.join(@tmp_dir, 'file.gzip')
+    @package.gzip({'src' => src, 'dest' => dest})
+    # error case: dest must be a string
+    begin
+      @package.gzip({'src' => file, 'dest' => [dest]})
+      flunk "Shoud have failed"
+    rescue
+    end
+  end
+
+  # Test task targz.
+  def test_task_targz
+    file1 = File.join(@tmp_dir, 'file1.txt')
+    file2 = File.join(@tmp_dir, 'file2.txt')
+    File.open(file1, 'w') {|file| file.write('File 1')}
+    File.open(file2, 'w') {|file| file.write('File 2')}
+    includes = "#{@tmp_dir}/*.txt"
+    dest = File.join(@tmp_dir, 'test.zip')
+    @package.targz({'includes' => includes, 'dest' => dest})
+    # error case: dest must be a string
+    begin
+      @package.targz({'includes' => includes, 'dest' => [dest]})
+      flunk "Shoud have failed"
+    rescue
+    end
+  end
+
+  private
+  
+  # Clean temporary directory.
+  def clean_tmp
+    FileUtils.rm_rf(@tmp_dir)
+    FileUtils.makedirs(@tmp_dir)    
+  end
+  
+  # Create a given file in tmp directory with its name as contents.
+  # - name: file name, relative to temporary directory.
+  def create_file(name)
+    File.open(name, 'w') { |file| file.write(name) }    
+  end
+  
+  # Assert file exists and test its contents.
+  def assert_file(file, contents)
+    assert(File.exists?(file))
+    text = File.read(file)
+    assert_equal(contents, text)
+  end
+  
+end