build-tool 0.5.7 → 0.6.0.rc1

data/test/unit/git_svn_configuration_test.rb

@@ -0,0 +1,240 @@
+require 'test_helper'
+
+require 'build-tool/vcs/git-svn'
+
+
+
+class GitSvnConfigurationTest < ActiveSupport::TestCase
+
+    #######################
+    # THE GIT FUNCTIONALITY
+    #
+    test 'Constructor.' do
+        cfg = BuildTool::VCS::GitSvnConfiguration.new()
+        cfg.vcs( ModuleMock.new( 'test' ) )
+        assert_equal( 'git-svn', cfg.name )
+        assert_equal( {}, cfg.remote )
+        assert_equal( {}, cfg.global_options )
+        assert_equal( {}, cfg.options )
+        assert_equal( 'remotes/git-svn', cfg.track )
+        assert_raise( BuildTool::ConfigurationError ) { cfg.repository  }
+    end
+
+    test 'Track is correctly split.' do
+        cfg = BuildTool::VCS::GitSvnConfiguration.new
+        assert_equal( 'remotes', cfg.track_remote )
+        assert_equal( 'git-svn', cfg.track_branch )
+        cfg.track = 'myremote/mybranch'
+        assert_equal( 'myremote', cfg.track_remote )
+        assert_equal( 'mybranch', cfg.track_branch )
+    end
+
+    test 'Vcs() returns a git-svn instance.' do
+        cfg = BuildTool::VCS::GitSvnConfiguration.new
+        # :TODO:
+        # assert( cfg.vcs.is_a?( BuildTool::VCS::Git ), "vcs() returns a instance of Git." )
+    end
+
+    test 'track() accessor works.' do
+        cfg = create_configuration
+        assert_equal( 'myremote/mybranch', cfg.track )
+    end
+
+    test 'track() accessor works with inheritance.' do
+        parent = create_configuration
+        # Create a empty object with a parent
+        cfg = BuildTool::VCS::GitSvnConfiguration.new
+        cfg.parent = parent
+        # Value is taken from parent
+        assert_equal( 'myremote/mybranch', cfg.track )
+        # Unless we set it locally
+        cfg.track = 'repo1/test'
+        assert_equal( 'repo1/test', cfg.track )
+        # After a reset
+        cfg.track = nil
+        assert_equal( 'myremote/mybranch', cfg.track )
+    end
+
+    test 'options() accessor works.' do
+        cfg = create_configuration
+        assert_equal( 'option 1', cfg.options[:option1] )
+        assert_equal( 'option 2', cfg.options[:option2] )
+        assert_nil( cfg.options[:option3] )
+    end
+
+    test 'options() accessor works with inheritance.' do
+        parent = create_configuration
+        # Create a empty object with a parent
+        cfg = BuildTool::VCS::GitSvnConfiguration.new
+        cfg.parent = parent
+        # Options are not merged.
+        assert_nil( cfg.options[:option1] )
+        assert_nil( cfg.options[:option2] )
+        assert_nil( cfg.options[:option3] )
+        # Merged_options is merged with the parent.
+        assert_equal( 'option 1', cfg.merged_options[:option1] )
+        assert_equal( 'option 2', cfg.merged_options[:option2] )
+        assert_nil( cfg.merged_options[:option3] )
+        # But ours have priority
+        cfg.options[:option1] = 'overwritten'
+        assert_equal( 'overwritten', cfg.merged_options[:option1] )
+    end
+
+    test 'options() accessor works with global configuration.' do
+        cfg = create_configuration
+        create_global_configuration
+        assert_equal( 'option 1', cfg.merged_options[:option1] )
+        assert_equal( 'option 2', cfg.merged_options[:option2] )
+        assert_equal( 'option 3(set globally)', cfg.merged_options[:option3] )
+    end
+
+    test 'options() accessor works with global configuration and inheritance.' do
+        parent = create_configuration
+        # Create a empty object with a parent
+        cfg = BuildTool::VCS::GitSvnConfiguration.new
+        cfg.parent = parent
+        cfg.options[:option1] = 'overwritten'
+        # Merged_options is merged with the parent and global
+        create_global_configuration
+        assert_equal( 'overwritten', cfg.merged_options[:option1] )
+        assert_equal( 'option 2', cfg.merged_options[:option2] )
+        assert_equal( 'option 3(set globally)', cfg.merged_options[:option3] )
+        # And we can reset them
+        cfg.options.delete(:option1)
+        assert_equal( 'option 1', cfg.merged_options[:option1] )
+    end
+
+    test 'global_options() works.' do
+        cfg = create_configuration
+        assert_equal( {}, cfg.global_options )
+    end
+
+    test 'global_options() works with global configuration.' do
+        cfg = create_configuration
+        create_global_configuration
+        assert_equal( 'global option 1', cfg.merged_global_options[:globaloption1] )
+        assert_equal( 'global option 2', cfg.merged_global_options[:globaloption2] )
+    end
+
+    test 'remote() accessor works.' do
+        cfg = create_configuration
+        assert_equal( 'GitRemoteObject 1', cfg.remote['origin'] )
+        assert_equal( 'GitRemoteObject 1', cfg.merged_remote['origin'] )
+    end
+
+    test 'remote() accessor works with inheritance.' do
+        parent = create_configuration
+        cfg = BuildTool::VCS::GitSvnConfiguration.new
+        cfg.parent = parent
+        cfg.remote['other'] = 'other'
+        assert_nil( cfg.remote['origin'] )
+        assert_equal( 'GitRemoteObject 1', cfg.merged_remote['origin'] )
+        assert_equal( 'other', cfg.merged_remote['other'] )
+        cfg.remote['origin'] = 'test'
+        assert_equal( 'test', cfg.merged_remote['origin'] )
+        assert_equal( 'other', cfg.merged_remote['other'] )
+    end
+
+    #######################
+    # THE GIT-SVN FUNCTIONALITY
+    #
+    test 'Constructor Git-SVN.' do
+        cfg = BuildTool::VCS::GitSvnConfiguration.new
+        assert_equal( {}, cfg.externals )
+        assert_equal( {}, cfg.merged_externals )
+    end
+
+    test 'external() accessor works.' do
+        cfg = create_configuration
+        assert_equal( 'svn+ssh@user@example.com/remote/path', cfg.externals[ 'local/path' ] )
+    end
+
+    test 'external() accessor works with inheritance.' do
+        parent = create_configuration
+        # Create a empty object with a parent
+        cfg = BuildTool::VCS::GitSvnConfiguration.new
+        cfg.parent = parent
+        # Value is taken from parent
+        assert_equal( 'svn+ssh@user@example.com/remote/path', cfg.merged_externals[ 'local/path' ] )
+        # Unless we set it locally
+        cfg.externals['local/path'] ='svn+ssh@user@example.com/remote/other/path'
+        assert_equal( 'svn+ssh@user@example.com/remote/other/path', cfg.merged_externals[ 'local/path' ] )
+        # After a reset
+        cfg.externals.delete( 'local/path' )
+        assert_equal( 'svn+ssh@user@example.com/remote/path', cfg.merged_externals[ 'local/path' ] )
+    end
+
+    test 'repository() accessor works.' do
+        cfg = create_configuration
+        assert_equal( 'repo', cfg.repository.name )
+    end
+
+    test 'repository() accessor works with inheritance.' do
+        parent = create_configuration
+        # Create a empty object with a parent
+        cfg = BuildTool::VCS::GitSvnConfiguration.new
+        cfg.parent = parent
+        # Value is taken from parent
+        assert_equal( 'repo', cfg.repository.name )
+        # Unless we set it locally
+        cfg.repository = RepositoryMock.new( 'repo2' )
+        assert_equal( 'repo2', cfg.repository.name )
+        # After a reset
+        cfg.repository = nil
+        assert_equal( 'repo', cfg.repository.name )
+    end
+
+    test 'accessor remote_path() works.' do
+        cfg = create_configuration
+        assert_equal( 'remote/path', cfg.remote_path )
+    end
+
+    test 'accessor remote_path() works with inheritance.' do
+        parent = create_configuration
+        cfg = BuildTool::VCS::GitSvnConfiguration.new
+        cfg.vcs( ModuleMock.new( 'test' ) )
+        cfg.parent = parent
+        # We get the value from the parent
+        assert_equal( 'remote/path', cfg.remote_path )
+        # Unless we override it
+        cfg.remote_path = 'remote/other_path'
+        assert_equal( 'remote/other_path', cfg.remote_path )
+        # And we can reset it
+        cfg.remote_path = nil
+        assert_equal( 'remote/path', cfg.remote_path )
+    end
+
+
+    private
+
+    def create_configuration
+        # Reset global configuration
+        BuildTool::VCS::GitConfiguration.global_config = nil
+        # Create a configuration object
+        cfg = BuildTool::VCS::GitSvnConfiguration.new
+        cfg.track = 'myremote/mybranch'
+        cfg.options = {
+            :option1 => "option 1",
+            :option2 => "option 2" }
+        cfg.remote['origin'] = 'GitRemoteObject 1'
+        cfg.remote['private'] = 'GitRemoteObject 2'
+        cfg.externals['local/path'] ='svn+ssh@user@example.com/remote/path'
+        cfg.repository = RepositoryMock.new( 'repo' )
+        cfg.remote_path = 'remote/path'
+        cfg
+    end
+
+    def create_global_configuration
+        # Add a global configuration object
+        global = BuildTool::VCS::GitConfiguration.new
+        BuildTool::VCS::GitConfiguration.global_config = global
+        global.options = {
+            :option1 => "option 1(set globally)",
+            :option3 => "option 3(set globally)" }
+        global.global_options = {
+            :globaloption1 => "global option 1",
+            :globaloption2 => "global option 2" }
+        global
+    end
+
+end # class GitSvnConfigurationTest

data/test/unit/mercurial_configuration_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+require 'build-tool/vcs/mercurial'
+
+class MercurialConfigurationTest < ActiveSupport::TestCase
+
+    test 'Constructor' do
+        cfg = BuildTool::VCS::MercurialConfiguration.new
+        cfg.vcs( ModuleMock.new( 'mercurial/test' ) )
+        assert_equal( cfg.name, 'mercurial' )
+        assert_nil( cfg.url )
+        assert_equal( 'default', cfg.track )
+    end
+
+    test 'accessor url() works.' do
+        cfg = create_configuration
+        assert_equal( 'some_branch', cfg.track )
+    end
+
+    test 'accessor url() works with inheritance.' do
+        parent = create_configuration
+        cfg = BuildTool::VCS::MercurialConfiguration.new
+        cfg.parent = parent
+        # We get the value from the parent
+        assert_equal( 'some_url', cfg.url )
+        # Unless we have it overriden
+        cfg.url = 'different_url'
+        assert_equal( 'different_url', cfg.url )
+        # But we can reset it
+        cfg.url = nil
+        assert_equal( 'some_url', cfg.url )
+    end
+
+    test 'accessor branch() works.' do
+        cfg = create_configuration
+        assert_equal( 'some_branch', cfg.track )
+    end
+
+    test 'accessor branch() works with inheritance.' do
+        parent = create_configuration
+        cfg = BuildTool::VCS::MercurialConfiguration.new
+        cfg.parent = parent
+        # We get the value from the parent
+        assert_equal( 'some_branch', cfg.track )
+        # Unless we have it overriden
+        cfg.track = 'different_branch'
+        assert_equal( 'different_branch', cfg.track )
+        # But we can reset it
+        cfg.track = nil
+        assert_equal( 'some_branch', cfg.track )
+    end
+
+    #######
+    private
+    #######
+
+    def create_configuration
+        cfg = BuildTool::VCS::MercurialConfiguration.new
+        cfg.url = 'some_url'
+        cfg.track = 'some_branch'
+        cfg
+    end
+
+end

data/test/unit/model/command_log_test.rb

@@ -0,0 +1,103 @@
+require 'test_helper'
+
+setup_database()
+
+require 'build-tool/history'
+
+class TestCommandLog < ActiveSupport::TestCase
+
+    test 'Constructor works' do
+        cmd = nil
+
+        # The constructor does not save
+        assert_no_difference( 'BuildTool::History::CommandLog.count', 'new() does not save the object' ) do
+
+            cmd = BuildTool::History::CommandLog.new(
+                :command => 'my_special_command',
+                :logdir  => '/home/build-tool/log')
+
+            # Check the initial values
+            assert_nil( cmd.started_at, 'started_at is initialized with nil.' )
+            assert_nil( cmd.finished_at, 'finished_at is initialized with nil.' )
+            assert_equal( BuildTool::History::CommandLog::STARTED, cmd.state, 'STARTED is the initial state.' )
+            assert_equal( '-----', cmd.duration, '"-----" is not yet feasible.'  )
+
+        end
+
+        # Now save it
+        cmd.save
+
+        # And check we can load it back from the db
+        id = cmd.id
+        cmd = nil
+        cmd = BuildTool::History::CommandLog.find( id )
+
+        # Same values as before
+        assert_nil( cmd.started_at, 'started_at is initialized with nil.' )
+        assert_nil( cmd.finished_at, 'finished_at is initialized with nil.' )
+        assert_equal( BuildTool::History::CommandLog::STARTED, cmd.state, 'STARTED is the initial state.' )
+        assert_equal( '-----', cmd.duration, '"-----" is not yet feasible.'  )
+    end
+
+
+
+    test 'Workflow works' do
+
+        cmd = BuildTool::History::CommandLog.new(
+            :command => 'my_other_command',
+            :logdir  => '/home/build-tool/log')
+
+        assert_difference( 'BuildTool::History::CommandLog.count', 1, 'started() saves the object' ) do
+            cmd.started()
+        end
+
+        # Started sets started_at and state, duration is not yet calculable
+        assert_equal( BuildTool::History::CommandLog::STARTED, cmd.state )
+        assert_not_nil( cmd.started_at, 'CommandLog.started_at is set.' )
+        assert_equal( '-----', cmd.duration )
+
+        # Started sets started_at and state, duration is calculable
+        cmd.finished( BuildTool::History::CommandLog::FINISHED_WITH_ERRORS )
+        assert_equal( BuildTool::History::CommandLog::FINISHED_WITH_ERRORS, cmd.state )
+        assert_not_nil( cmd.finished_at , 'CommandLog.finished_at is set.' )
+        assert_match( /[0-9][0-9]:[0-9][0-9]/, cmd.duration )
+
+    end
+
+
+
+    test 'last() returns the last n entries.' do
+
+        cmds = BuildTool::History::CommandLog.last( 1 )
+        assert_equal( 1, cmds.count, 'one element is returned' )
+        assert_equal( 'my_other_command', cmds[0].command )
+
+        cmds = BuildTool::History::CommandLog.last( 2 )
+        assert_equal( 2, cmds.count, 'two element are returned' )
+        assert_equal( 'my_special_command', cmds[1].command )
+        assert_equal( 'my_other_command', cmds[0].command )
+
+    end
+
+
+
+    test 'older_than() returns all modules older that 10 days.' do
+
+        # :TODO: Create a real test
+        cmds = BuildTool::History::CommandLog.older_than()
+        assert_equal( 0, cmds.count, 'no element is returned' )
+
+    end
+
+
+
+    test 'last_by_module() returns the last n entries per module.' do
+
+        # :TODO: Create a real test
+        cmds = BuildTool::History::CommandLog.last_by_module( 'kdelibs' )
+        assert_equal( 0, cmds.count, 'no element is returned' )
+
+    end
+end
+
+

data/test/unit/model/feature_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+setup_database()
+
+require 'build-tool/model/feature'
+
+class FeatureTest < ActiveSupport::TestCase
+
+    test 'Constructor' do
+        feat = BuildTool::Feature.new
+    end
+
+    test 'Active logic' do
+        feat = BuildTool::Feature.new
+        assert( feat.default_active?, 'By default all features are active' )
+        assert( feat.active?, 'By default all features are active' )
+        feat.default_active = false
+        assert( !feat.default_active? )
+        assert( !feat.active?, 'By default active? uses default_active?' )
+        feat.active = true
+        assert( !feat.default_active? )
+        assert( feat.active? )
+        feat.active = nil
+        assert( !feat.default_active? )
+        assert( !feat.active? )
+    end
+
+end # class FeatureTest
+

data/test/unit/model/module_log_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+setup_database()
+
+require 'build-tool/history'
+
+class TestModuleLog < ActiveSupport::TestCase
+
+    def setup
+        @cmd = BuildTool::History::CommandLog.new(
+            :command => 'my_special_command',
+            :logdir  => '/home/build-tool/log')
+        @modA = BuildTool::Module.new( :name => 'modA' )
+        @modB = BuildTool::Module.new( :name => 'modB' )
+        @cmd.started
+        @cmd.finished( BuildTool::History::ModuleLog::FINISHED_SUCCESSFUL )
+    end
+
+
+
+    test 'Constructor works' do
+
+        mod = nil
+
+        # The constructor does not save
+        assert_no_difference( 'BuildTool::History::ModuleLog.count', 'new() does not save the object' ) do
+
+            mod = @cmd.module_logs.build(
+                :module => @modA,
+                :event   => 'compile',
+                :logfile => '10_kdelibs_compile.log' )
+
+        end
+
+        assert_nil( mod.started_at, 'started_at is initialized with nil.' )
+        assert_nil( mod.finished_at, 'finished_at is initialized with nil.' )
+        assert_equal( BuildTool::History::ModuleLog::STARTED, mod.state )
+        assert_equal( '-----', mod.duration )
+        assert_equal( 'modA', mod.module.name )
+        assert_equal( 'compile', mod.event )
+        assert_equal( '10_kdelibs_compile.log', mod.logfile )
+    end
+
+
+
+    test 'Workflow works' do
+
+        mod = @cmd.module_logs.build(
+            :module => @modB,
+            :event   => 'install',
+            :logfile => '50_kdebase-runtime_install.log' )
+
+        # Started sets started_at and state, duration is not yet calculable
+        assert_difference( 'BuildTool::History::ModuleLog.count', 1, 'started() saves the object' ) do
+            mod.started()
+        end
+        assert_equal( BuildTool::History::ModuleLog::STARTED, mod.state )
+        assert_not_nil( mod.started_at, 'ModuleLog.started_at is set.' )
+        assert_equal( '-----', mod.duration )
+
+        # Started sets started_at and state, duration is calculable
+        mod.finished( BuildTool::History::ModuleLog::FINISHED_WITH_ERRORS )
+        assert_equal( BuildTool::History::ModuleLog::FINISHED_WITH_ERRORS, mod.state )
+        assert_not_nil( mod.finished_at , 'ModuleLog.finished_at is set.' )
+        assert_match( /[0-9][0-9]:[0-9][0-9]/, mod.duration )
+
+    end
+
+end
+