bee 0.4.0 → 0.5.0

data/test/tc_bee_build.rb

@@ -1,216 +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_listener'
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'bee'
-
-# Test case for console formatter.
-class TestBeeBuild < TmpTestCase
-
-  def test_load
-    # try loading a build file that doesn't exist
-    begin
-      Bee::Build::load('foo')
-      flunk "Build file should not have been found!"
-    rescue Bee::Util::BuildError
-      expected = "Build file 'foo' not found"
-      actual = $!.message
-      assert_equal(expected, actual)
-    end
-    # try loading a build file that is a directory
-    begin
-      Bee::Build::load('.')
-      flunk "Build file may not be a directory!"
-    rescue Bee::Util::BuildError
-      expected = "Build file '.' is not a file"
-      actual = $!.message
-      assert_equal(expected, actual)
-    end
-    # try running a build that should never fail
-    build_file = File.join(@tmp_dir, 'build.yml')
-    begin
-      source = '- target: test
-  script:
-    - print: "Hello World!"'
-      File.open(build_file, 'w') {|file| file.write(source)}
-      listener = TestBuildListener.new
-      build = Bee::Build::load(build_file)
-      build.run('', listener)
-    ensure
-      File.delete(build_file)
-    end
-    # try loading a build file with YAML syntax error
-    begin
-      source = 
-'- target: test
-   script: \"test\"'
-      File.open(build_file, 'w') {|file| file.write(source)}
-      build = Bee::Build::load(build_file)
-      flunk "Should fail to parse YAML file!"
-    rescue Bee::Util::BuildError
-      expected = "YAML syntax error in build file: syntax error on line 1, " +
-        "col 10: `   script: \\\"test\\\"'"
-      actual = $!.message
-      assert_equal(expected, actual)
-    ensure
-      File.delete(build_file)
-    end
-    # try loading a build file that is a YAML string
-    begin
-      source = 'foo'
-      File.open(build_file, 'w') {|file| file.write(source)}
-      build = Bee::Build::load(build_file)
-      flunk "Build object must be a list!"
-    rescue Bee::Util::BuildError
-      expected = "Build must be a list"
-      actual = $!.message
-      assert_equal(expected, actual)
-    ensure
-      File.delete(build_file)
-    end
-  end
-  
-  def test_initialize
-    # try loading a build object (resulting from loading YAML file) that is not
-    # a list
-    begin
-      Bee::Build.new(Object.new, nil)
-      flunk "Build object must be a list!"
-    rescue Bee::Util::BuildError
-      expected = "Build must be a list"
-      actual = $!.message
-      assert_equal(expected, actual)
-    end
-    # try loading a build object with two build info entries
-    object = [{'build' => 'test'}, {'build' => 'test'}]
-    begin
-      Bee::Build.new(object, nil)
-      flunk "Build can't have duplicate info entries!"
-    rescue Bee::Util::BuildError
-      expected = "Duplicate build info"
-      actual = $!.message
-      assert_equal(expected, actual)
-    end
-    # try loading a build object defining a context
-    context_file = 'context.rb'
-    context_path = File.join(@tmp_dir, context_file)
-    context_source = 'def test
-set_property(:tested, true)
-end'
-    File.open(context_path, 'w') {|file| file.write(context_source)}
-    object = [{'build' => 'test', 'context' => context_file},
-      {'target' => 'test', 'script' => [{'rb' => 'test'}]}]
-    listener = TestBuildListener.new
-    build = Bee::Build.new(object, File.join(@tmp_dir, 'build.yml'))
-    build.run('', listener)
-    assert(build.context.get_property(:tested))
-    assert(listener.started)
-    assert(listener.finished)
-    assert(!listener.errors)
-    # try loading a buggy context
-    context_file = 'context.rb'
-    context_path = File.join(@tmp_dir, context_file)
-    context_source = 'def test end'
-    File.open(context_path, 'w') {|file| file.write(context_source)}
-    object = [{'build' => 'test', 'context' => context_file},
-      {'target' => 'test', 'script' => [{'rb' => 'test'}]}]
-    listener = TestBuildListener.new
-    begin
-      build = Bee::Build.new(object, File.join(@tmp_dir, 'build.yml'))
-      flunk "Should have raised a BuildError"
-    rescue Bee::Util::BuildError
-      assert_match(/Error loading context 'context.rb': compile error/,
-        $!.message)
-    end
-    # load a build defining properties
-    object = [{'properties' => [{'foo' => 'bar'}]}]
-    build = Bee::Build.new(object, File.join(@tmp_dir, 'build.yml'))
-    assert_equal(build.context.get_property(:foo), 'bar')
-    # load a build defining duplicate properties
-    object = [{'properties' => [{'foo' => 'bar'}, {'foo' => 'bar'}]}]
-    begin
-      build = Bee::Build.new(object, File.join(@tmp_dir, 'build.yml'))
-    rescue Bee::Util::BuildError
-      assert_equal("Property 'foo' was already defined", $!.message)
-    end
-    # load a build with unknown entry
-    object = [{'foo' => 'bar'}]
-    begin
-      build = Bee::Build.new(object, File.join(@tmp_dir, 'build.yml'))
-    rescue Bee::Util::BuildError
-      assert_match("Unknown entry:", $!.message)
-    end
-    # try running a buggy build with a listener
-    object = [{'target' => 'test', 'script' => [{'foo' => 'bar'}]}]
-    listener = TestBuildListener.new
-    build = Bee::Build.new(object, File.join(@tmp_dir, 'build.yml'))
-    build.run('', listener)
-    assert(listener.started)
-    assert(!listener.finished)
-    assert(listener.errors)
-    # try running a buggy build without a listener
-    object = [{'target' => 'test', 'script' => [{'foo' => 'bar'}]}]
-    build = Bee::Build.new(object, File.join(@tmp_dir, 'build.yml'))
-    begin
-      build.run('', nil)
-    rescue Bee::Util::BuildError
-      assert_equal("Task 'foo' not found in package 'default'", $!.message)
-    end
-    # try running a build with dependencies
-    target1 = {'target' => 'test1', 
-      'script' => [{'rb' => 'set_property(:foo, "bar")'}]}
-    target2 = {'target' => 'test2', 'depends' => 'test1'}
-    object = [target2, target1]
-    listener = TestBuildListener.new
-    build = Bee::Build.new(object, File.join(@tmp_dir, 'build.yml'))
-    build.run('', listener)
-    assert(listener.started)
-    assert(listener.finished)
-    assert(!listener.errors)
-    assert_equal(['test1', 'test2'], 
-                 listener.targets.collect {|target| target.name})
-    # run a task with two keys
-    object = [{'target' => 'test', 
-                'script' => [{'foo' => 'bar', 'spam' => 'eggs'}]}]
-    build = Bee::Build.new(object, File.join(@tmp_dir, 'build.yml'))
-    begin
-      build.run('', nil)
-    rescue Bee::Util::BuildError
-      assert_equal("A task entry must be a Hash with a single key", $!.message)
-    end
-    # run a buggy Ruby script
-    object = [{'target' => 'test', 'script' => [{'rb' => 'bar'}]}]
-    build = Bee::Build.new(object, File.join(@tmp_dir, 'build.yml'))
-    begin
-      build.run('', nil)
-    rescue Bee::Util::BuildError
-      assert_match(/Error running Ruby script/, $!.message)
-    end
-    # run a buggy Ruby script (with bad property reference)
-    object = [{'target' => 'test', 'script' => [{'print' => :bar}]}]
-    build = Bee::Build.new(object, File.join(@tmp_dir, 'build.yml'))
-    begin
-      build.run('', nil)
-    rescue Bee::Util::BuildError
-      assert_match(/Property 'bar' was not set/,
-        $!.message)
-    end
-  end
-
-end

data/test/tc_bee_console.rb

@@ -1,106 +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.
-
-require 'test/unit'
-require 'stringio'
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'bee_console'
-$:.unshift(File.dirname(__FILE__))
-require 'tmp_test_case'
-
-# Test context.
-class TestBeeConsole < TmpTestCase
-  
-  def test_parse_command_line
-    ARGV.replace(['-h', '-b', '-k', 'foo', '-t', '-v', '-s', 'bar', '-f', 'spam', 'eggs'])
-    actual = Bee::Console.parse_command_line
-    expected = [true, true, true, 'foo', true, true, 'bar', 'spam', false, ['eggs']]
-    assert_equal(expected, actual)
-  end
-  
-  def test_start_command_line
-    stdout = $stdout
-    stderr = $stderr
-    output = StringIO.new
-    $stdout = $stderr = output
-    begin
-      # nominal case starting a build from command line
-      build_file = 'test.yml'
-      build_path = File.join(@tmp_dir, build_file)
-      source = '- target: test
-  script: "cd ."'
-      File.open(build_path, 'w') {|file| file.write(source)}
-      ARGV.replace(['-f', build_path])
-      Bee::Console.start_command_line
-      # error parsing command line arguments
-      ARGV.replace(['-z'])
-      begin
-        Bee::Console.start_command_line
-        flunk "Command line parsing should have failed"
-      rescue SystemExit => e
-        assert_equal(Bee::Console::EXIT_PARSING_CMDLINE, e.status)
-      end
-      # help command
-      ARGV.replace(['-h'])
-      Bee::Console.start_command_line
-      # build help
-      build_file = 'test.yml'
-      build_path = File.join(@tmp_dir, build_file)
-      source = '- target: test
-  script: "cd ."'
-      File.open(build_path, 'w') {|file| file.write(source)}
-      ARGV.replace(['-f', build_path, '-b'])
-      Bee::Console.start_command_line
-      # task help
-      ARGV.replace(['-k', 'print'])
-      Bee::Console.start_command_line
-      # task help
-      ARGV.replace(['-k', '?'])
-      Bee::Console.start_command_line
-      # error task help
-      ARGV.replace(['-k', 'foo'])
-      begin
-        Bee::Console.start_command_line
-        flunk "Should have failed"
-      rescue Exception
-      end
-      # template generation
-      build_file = 'test.yml'
-      build_path = File.join(@tmp_dir, build_file)
-      File.delete(build_path)
-      build_path = File.join(build_path)
-      ARGV.replace(['-f', build_path, '-t'])
-      Bee::Console.start_command_line
-      # template generation with a build file that already exists
-      begin
-        build_file = 'test.yml'
-        build_path = File.join(@tmp_dir, build_file)
-        build_path = File.join(build_path)
-        ARGV.replace(['-f', build_path, '-t'])
-        Bee::Console.start_command_line
-        flunk "Template generation should have failed"
-      rescue SystemExit => e
-        assert_equal(Bee::Console::EXIT_BUILD_ERROR, e.status)
-      end
-      # test unknown internal error
-      # TODO
-    ensure
-      $stdout = stdout
-      $stderr = stderr
-    end
-  end
-  
-end

data/test/tc_bee_console_formatter.rb

@@ -1,81 +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.
-
-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('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 = {
-      :line_character => '#',
-      :line_length => 72,
-      :target_style => :bright,
-      :target_foreground => :red,
-      :target_background => :green
-    }
-    formatter = Bee::Console::Formatter.new(style)
-    target = Bee::Target.new({ 'target' => 'TEST' }, nil)
-    actual = formatter.format_target(target)
-    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

@@ -1,84 +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.
-
-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