bee 0.3.1 → 0.4.0

data/test/tc_bee_default_tasks.rb

@@ -1,298 +0,0 @@
-#!/usr/bin/env ruby
-
-# Copyright 2006 Michel Casabianca <casa@sweetohm.net>
-#
-# 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.rb'
-require 'fileutils'
-
-class TestBeeDefaultTasks < Test::Unit::TestCase
-
-  # Temporary directory.
-  TEMP_DIR = 'tmp'
-
-  # Constructor.
-  def initialize(*args)
-    super(*args)
-    @home = File.expand_path(File.dirname(__FILE__))
-    @working_dir = Dir.getwd
-    @tmp_dir = File.join(@home, TEMP_DIR)
-    # try to create temporary directory and disable tests if we can't
-    begin
-      FileUtils.makedirs(@tmp_dir)
-      @run_tests = true
-    rescue
-      @run_tests = false
-    end
-  end
-
-  # Run before any test:
-  # - Create temporary directory.
-  # - Create a context object and load tasks in it.
-  def setup
-    FileUtils.makedirs(@tmp_dir)
-    @context = Bee::Context.new
-    script = File.read(File.join(@home, '..', 'lib', 'bee_default_context.rb'))
-    @context.evaluate_script(script)
-  end
-
-  # Run after any test: delete temporary directory.
-  def teardown
-    FileUtils.rm_rf(@tmp_dir)
-    Dir.chdir(@working_dir)
-  end
-
-  ############################ UTILITY FUNCTIONS ##########################
-
-  # 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
-
-  ############################ TEST FUNCTIONS #############################
-
-  # Test task print.
-  # TODO: implement.
-  def test_task_print
-    return unless @run_tests
-  end
-
-  # Test task cat.
-  # TODO: implement.
-  def test_task_cat
-    return unless @run_tests
-  end
-
-  # Test task cd.
-  def test_task_cd
-    return unless @run_tests
-    working_dir = File.expand_path(File.dirname(__FILE__))
-    # test nominal case
-    @context.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')
-      @context.cd(dir)
-      flunk "Should have raised an Errno::ENOENT"
-    rescue Errno::ENOENT
-    end
-    # test bad arguments
-    begin
-      @context.cd(Object.new)
-      flunk "Should have raised a BuildError"
-    rescue Bee::BuildError
-      expected = 'cd parameter is a String'
-      actual = $!.message
-      assert_equal(expected, actual)
-    end
-  end
-
-  # Test task mkdir.
-  def test_task_mkdir
-    return unless @run_tests
-    # nominal case with a single recursive dir
-    dir = File.join(@tmp_dir, 'foo', 'bar')
-    @context.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')]
-    @context.mkdir(dirs)
-    found = Dir.entries(@tmp_dir)
-    assert(found.member?('toto'))
-    assert(found.member?('titi'))
-    # error case
-    dir = Object.new
-    begin
-      @context.mkdir(dir)
-      flunk "Should have raised a BuildError"
-    rescue Bee::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
-      @context.mkdir(dirs)
-      flunk "Should have raised a BuildError"
-    rescue Bee::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
-    return unless @run_tests
-    # nominal case for a src and dest file
-    src = File.join(@tmp_dir, 'src.txt')
-    create_file(src)
-    dest = File.join(@tmp_dir, 'dest.txt')
-    @context.cp({ 'src' => src, 'dest' => dest })
-    assert_file(dest, src)
-    # nominal case for src files and destination directory
-    clean_tmp
-    src2 = File.join(@tmp_dir, 'src2.txt')
-    dest = File.join(@tmp_dir, 'dir')
-    create_file(src)
-    create_file(src2)
-    FileUtils.makedirs(dest)
-    @context.cp({ 'src' => [src, src2], 'dest' => dest })
-    assert_file(File.join(dest, 'src.txt'), src)
-    assert_file(File.join(dest, 'src2.txt'), src2)
-    # nominal case for src and dest directory
-    clean_tmp
-    src = File.join(@tmp_dir, 'dir')
-    dest = File.join(@tmp_dir, 'todir')
-    FileUtils.makedirs(src)
-    FileUtils.makedirs(dest)
-    file1 = File.join(src, 'file1.txt')
-    file2 = File.join(src, 'file2.txt')
-    create_file(file1)
-    create_file(file2)
-    @context.cp({ 'src' => src, 'dest' => dest })
-    assert_file(File.join(dest, 'dir', 'file1.txt'), file1)
-    assert_file(File.join(dest, 'dir', 'file2.txt'), file2)
-  end
-
-  # Test task mv.
-  def test_task_mv
-    return unless @run_tests
-    # nominal case for a src and dest file
-    src = File.join(@tmp_dir, 'src.txt')
-    create_file(src)
-    dest = File.join(@tmp_dir, 'dest.txt')
-    @context.mv({ 'src' => src, 'dest' => dest })
-    assert_file(dest, src)
-    assert(!File.exists?(File.join(@tmp_dir, src)))
-    # nominal case with two source files
-    clean_tmp
-    src = File.join(@tmp_dir, 'src.txt')
-    src2 = File.join(@tmp_dir, 'src2.txt')
-    dest = File.join(@tmp_dir, 'dir')
-    create_file(src)
-    create_file(src2)
-    FileUtils.makedirs(dest)
-    @context.mv({ 'src' => File.join(@tmp_dir, '*.txt'), 'dest' => dest })
-    assert_file(File.join(dest, 'src.txt'), src)
-    assert_file(File.join(dest, 'src2.txt'), src2)
-    assert(!File.exists?(src))
-    assert(!File.exists?(src2))
-    # nominal case with directory for src and dest
-    clean_tmp
-    src = File.join(@tmp_dir, 'dir1')
-    dest = File.join(@tmp_dir, 'dir2')
-    FileUtils.makedirs(src)
-    create_file(File.join(src, 'test.txt'))
-    @context.mv({ 'src' => src, 'dest' => dest })
-    assert(File.exists?(dest))
-    assert(File.directory?(dest))
-    assert_file(File.join(dest, 'test.txt'), File.join(src, 'test.txt'))
-    assert(!File.exists?(src))
-  end
-
-  # Test task rm.
-  def test_task_rm
-    return unless @run_tests
-    # nominal case with a glob
-    file = File.join(@tmp_dir, 'test.txt')
-    create_file(file)
-    @context.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)
-    @context.rm([File.join(@tmp_dir, '**/*.txt'), 
-                 File.join(@tmp_dir, '**/*.log')])
-    assert(!File.exists?(file1))
-    assert(!File.exists?(file2))
-    assert(!File.exists?(file3))
-  end
-
-  # Test task rmdir.
-  def test_task_rmdir
-    return unless @run_tests
-    # nominal case with one dir
-    dir = File.join(@tmp_dir, 'dir')
-    FileUtils.makedirs(dir)
-    @context.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)
-    @context.rmdir([dir1, dir2])
-    assert(!File.exists?(dir1))
-    assert(!File.exists?(dir2))
-  end
-
-  # Test task find.
-  def test_task_find
-    return unless @run_tests
-    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)
-    @context.find({ 'files' => "#{File.join(@tmp_dir, '**/*.txt')}",
-                    'toprop' => 'list'})
-    list = @context.get('list').sort
-    expected = [file1, file2, file3].sort
-    assert_equal(expected, list)
-  end
-
-  # Test task erb.
-  def test_task_erb
-    return unless @run_tests
-    @context.set('test', 'TEST')
-    source = 'This is a <%= test %>'
-    @context.erb({ 'source' => source, 'toprop' => 'result' })
-    actual = @context.get('result')
-    expected = 'This is a TEST'
-    assert_equal(expected, actual)
-  end
-
-end