bee 0.4.0 → 0.5.0

data/test/tc_bee_task_default.rb

@@ -1,467 +0,0 @@
-#!/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