autobuild 1.8.3 → 1.9.0.b1

data/lib/autobuild/test.rb

@@ -0,0 +1,104 @@
+# simplecov must be loaded FIRST. Only the files required after it gets loaded
+# will be profiled !!!
+if ENV['TEST_ENABLE_COVERAGE'] == '1'
+    begin
+        require 'simplecov'
+        SimpleCov.start
+    rescue LoadError
+        require 'autobuild'
+        Autobuild.warn "coverage is disabled because the 'simplecov' gem cannot be loaded"
+    rescue Exception => e
+        require 'autobuild'
+        Autobuild.warn "coverage is disabled: #{e.message}"
+    end
+end
+
+require 'minitest/autorun'
+require 'autobuild'
+require 'tmpdir'
+require 'erb'
+require 'fileutils'
+## Uncomment this to enable flexmock
+require 'flexmock/test_unit'
+require 'minitest/spec'
+
+if ENV['TEST_ENABLE_PRY'] != '0'
+    begin
+        require 'pry'
+    rescue Exception
+        Autobuild.warn "debugging is disabled because the 'pry' gem cannot be loaded"
+    end
+end
+
+module Autobuild
+    # This module is the common setup for all tests
+    #
+    # It should be included in the toplevel describe blocks
+    #
+    # @example
+    #   require 'autobuild/test'
+    #   describe Autobuild do
+    #   end
+    #
+    module SelfTest
+        if defined? FlexMock
+            include FlexMock::ArgumentTypes
+            include FlexMock::MockContainer
+        end
+
+        def setup
+            @tempdir = File.join(Dir.tmpdir, "/autobuild-test-#{Process.uid}")
+            FileUtils.mkdir_p(@tempdir, :mode => 0700)
+            Autobuild.logdir = "#{tempdir}/log"
+            FileUtils.mkdir_p Autobuild.logdir
+            Autobuild.silent = true
+            # Setup code for all the tests
+        end
+
+        def teardown
+            Autobuild.silent = false
+            if defined? FlexMock
+                flexmock_teardown
+            end
+            super
+
+            Autobuild::Package.clear
+
+            if @tempdir
+                FileUtils.rm_rf @tempdir
+            end
+        end
+
+        def data_dir
+            File.join(File.dirname(__FILE__), '..', '..', 'test', 'data')
+        end
+
+        attr_reader :tempdir
+
+        def build_config(bind, template)
+            eval "basedir = '#{self.tempdir}'", bind
+            ryml = File.open(File.join(data_dir, "#{template}.ryml")) { |f| f.readlines }.join('')
+            result = ERB.new(ryml).result(bind)
+
+            yml = File.join(tempdir, "#{template}.yml")
+            File.open(yml, 'w+') { |f| f.write(result) }
+            
+            return yml
+        end
+
+        def untar(file)
+            file = File.expand_path(file, data_dir)
+            dir = self.tempdir
+            Dir.chdir(dir) do 
+                system("tar xf #{file}")
+            end
+
+            dir
+        end
+    end
+end
+
+class Minitest::Test
+    include Autobuild::SelfTest
+end
+

data/lib/autobuild/timestamps.rb

@@ -81,7 +81,7 @@ module Autobuild
     end
             
     def self.get_stamp(stampfile)
-        return Time.at(0) if !File.exists?(stampfile)
+        return Time.at(0) if !File.exist?(stampfile)
         return File.mtime(stampfile)
     end
 
@@ -99,9 +99,9 @@ module Autobuild
     def self.touch_stamp(stampfile)
         Autobuild.message "Touching #{stampfile}" if Autobuild.debug
         dir = File.dirname(stampfile)
-        if File.exists?(dir) && !File.directory?(dir)
+        if File.exist?(dir) && !File.directory?(dir)
             raise "#{dir} exists and is not a directory"
-        elsif !File.exists?(dir)
+        elsif !File.exist?(dir)
             FileUtils.mkdir_p dir
         end
         FileUtils.touch(stampfile)

data/lib/autobuild/tools.rb

@@ -23,7 +23,7 @@ module Autobuild
 
         def find_in_path(file)
             path = ENV['PATH'].split(File::PATH_SEPARATOR).
-                find { |dir| File.exists?(File.join(dir, file)) }
+                find { |dir| File.exist?(File.join(dir, file)) }
             if path
                 return File.join(path, file)
             end

data/lib/autobuild/utility.rb

@@ -14,8 +14,11 @@ module Autobuild
         def initialize(name, package)
             @name = name
             @package = package
-            @enabled = true
+            @available = true
+            @enabled   = true
             @source_ref_dir = nil
+            @source_dir = nil
+            @target_dir = nil
         end
 
         # Directory in which the utility will generate some files The
@@ -108,19 +111,28 @@ module Autobuild
         # This will return true only if a task has been by calling {task} _and_
         # the utility has not been explicitly disabled by setting the {enabled}
         # attribute to false
+        #
+        # @return [Boolean]
+        def available?
+            @available && (source_dir && @task)
+        end
+
+        # True if this utility should be executed
+        #
+        # @return [Boolean]
         def enabled?
-            if !@enabled
-                return false
-            else
-                return source_dir && @task
-            end
+            @enabled && available?
         end
 
-        # Allows to force {enabled?} to return false, regardless of whether
-        # {task} has been called or not
+        # Allows to override the utility's availability (i.e. whether this
+        # utility is available on the underlying package) regardless of whether
+        # {task} got called or not
         #
-        # This is mainly used for package types that have an e.g. documentation
-        # task by default, so that some packages can disable it.
+        # This is mainly used to fine-tune packages whose base type enables the
+        # utility (e.g. testing) but the actual package does not have it
+        attr_writer :available
+
+        # Allows to disable the utility regardless of the value of {available?}
         attr_writer :enabled
 
         def install

data/lib/autobuild/version.rb

@@ -1,5 +1,5 @@
 module Autobuild
-    VERSION = "1.8.3" unless defined? Autobuild::VERSION
+    VERSION = "1.9.0.b1" unless defined? Autobuild::VERSION
 end
 
 

data/test/import/test_cvs.rb

@@ -0,0 +1,51 @@
+require 'autobuild/test'
+
+class TC_CVSImport < Minitest::Test
+    include Autobuild
+
+    def setup
+        super
+        Autobuild.logdir = "#{tempdir}/log"
+        FileUtils.mkdir_p(Autobuild.logdir)
+    end
+    
+    def test_cvs
+        Autobuild.verbose = true
+        untar('cvsroot.tar')
+        cvsroot = File.join(tempdir, 'cvsroot')
+        pkg_cvs = Package.new 'cvs'
+        pkg_cvs.srcdir = File.join(tempdir, 'cvs')
+
+        # Make a checkout
+        importer = Autobuild.cvs(cvsroot, module: 'cvs')
+        importer.import(pkg_cvs)
+        assert( File.exists?(File.join(pkg_cvs.srcdir, 'test')) )
+
+        # Make an update
+        importer.import(pkg_cvs)
+
+        # Make an update fail because the repository does not exist anymore
+        FileUtils.rm_rf cvsroot
+        assert_raises(Autobuild::SubcommandFailed) { importer.import pkg_cvs }
+
+        # Make a checkout fail because the repository does not exist anymore
+        FileUtils.rm_rf pkg_cvs.srcdir
+        assert_raises(Autobuild::SubcommandFailed) { importer.import pkg_cvs }
+
+	# Recreate the repository, and make a checkout fail because the 
+	# WC is not a CVS WC
+        untar('cvsroot.tar')
+        FileUtils.mkdir pkg_cvs.srcdir
+        assert_raises(Autobuild::ConfigException) { importer.import pkg_cvs }
+
+	# Create two repositories, and make the update fail because the
+	# WC is of the wrong source
+	FileUtils.rm_rf pkg_cvs.srcdir
+        importer.import(pkg_cvs)
+	FileUtils.mv cvsroot, "#{cvsroot}.2"
+        importer = Autobuild.cvs("#{cvsroot}.2", module: 'cvs')
+        assert_raises(Autobuild::ConfigException) { importer.import pkg_cvs }
+    end
+end
+
+

data/test/import/test_git.rb

@@ -0,0 +1,364 @@
+require 'autobuild/test'
+
+describe Autobuild::Git do
+    attr_reader :pkg, :importer, :gitrepo
+    before do
+        untar('gitrepo.tar')
+        @gitrepo = File.join(tempdir, 'gitrepo.git')
+        @pkg = Autobuild::Package.new 'test'
+        pkg.srcdir = File.join(tempdir, 'git')
+        @importer = Autobuild.git(gitrepo)
+        pkg.importer = importer
+    end
+    
+    describe "#initialize" do
+        it "allows passing the branch as second argument for backward-compatibility way" do
+            Autobuild.silent = true
+            importer = Autobuild::Git.new('repo', 'branch', tag: 'test')
+            assert_equal 'branch', importer.branch
+        end
+        it "raises ConfigException if the branch parameter and the branch options are both given" do
+            Autobuild.silent = true
+            assert_raises(Autobuild::ConfigException) do
+                Autobuild::Git.new('repo', 'branch', branch: 'another')
+            end
+        end
+    end
+
+    describe "version_compare" do
+        it "should return -1 if the actual version is greater" do
+            assert_equal(-1, Autobuild::Git.compare_versions([2, 1, 0], [2, 0, 1]))
+        end
+        it "should return 0 if the versions are equal" do
+            assert_equal(0, Autobuild::Git.compare_versions([2, 1, 0], [2, 1, 0]))
+        end
+        it "should return 1 if the required version is greater" do
+            assert_equal(1, Autobuild::Git.compare_versions([2, 0, 1], [2, 1, 0]))
+            assert_equal(1, Autobuild::Git.compare_versions([1, 9, 1], [2, 1, 0]))
+        end
+        it "should fill missing version parts with zeros" do
+            assert_equal(-1, Autobuild::Git.compare_versions([2, 1], [2, 0, 1]))
+            assert_equal(-1, Autobuild::Git.compare_versions([2, 1, 0], [2, 0]))
+            assert_equal(0, Autobuild::Git.compare_versions([2, 1], [2, 1, 0]))
+            assert_equal(0, Autobuild::Git.compare_versions([2, 1, 0], [2, 1]))
+            assert_equal(1, Autobuild::Git.compare_versions([2, 1], [2, 1, 1]))
+            assert_equal(1, Autobuild::Git.compare_versions([2, 1, 1], [2, 2]))
+        end
+    end
+
+    describe "at_least_version" do
+        Autobuild::Git.stub :version, [1,9,1] do
+            it "should be true if required version is smaller" do
+                assert_equal( true, Autobuild::Git.at_least_version( 1,8,1 ) ) 
+            end
+            it "should be false if required version is greater" do
+                assert_equal( false, Autobuild::Git.at_least_version( 50,0,1 ) )
+            end
+        end
+    end
+
+    describe "#has_commit?" do
+        before do
+            importer.import(pkg)
+        end
+
+        it "returns true if the specified name resolves to a commit" do
+            assert importer.has_commit?(pkg, importer.rev_parse(pkg, 'HEAD'))
+        end
+        it "returns true if the specified commit is present locally" do
+            assert importer.has_commit?(pkg, importer.rev_parse(pkg, '8b09cb0febae222b31e2ee55f839c1e00dc7edc4'))
+        end
+        it "returns false if the specified name does not resolve to an object" do
+            assert !importer.has_commit?(pkg, 'blabla')
+        end
+        it "returns false if the specified commit is not present locally" do
+            assert !importer.has_commit?(pkg, '1ddb20665622279700770be09f9a291b37c9b631')
+        end
+        it "raises for any other error" do
+            flexmock(Autobuild::Subprocess).should_receive(:run).
+                and_raise(Autobuild::SubcommandFailed.new('test', 'test', 'bla', 200))
+            assert_raises(Autobuild::SubcommandFailed) do
+                importer.has_commit?(pkg, 'master')
+            end
+        end
+    end
+
+    describe "#has_branch?" do
+        before do
+            importer.import(pkg)
+        end
+
+        it "returns true if the branch exists" do
+            assert importer.has_branch?(pkg, 'master')
+        end
+
+        it "returns false if the branch does not exist" do
+            assert !importer.has_branch?(pkg, 'does_not_exist')
+        end
+
+        it "raises for any other error" do
+            flexmock(Autobuild::Subprocess).should_receive(:run).
+                and_raise(Autobuild::SubcommandFailed.new('test', 'test', 'bla', 200))
+            assert_raises(Autobuild::SubcommandFailed) do
+                importer.has_branch?(pkg, 'master')
+            end
+        end
+    end
+
+    describe "#detached_head?" do
+        before do
+            importer.import(pkg)
+        end
+
+        it "returns true if HEAD is detached" do
+            importer.run_git(pkg, 'checkout', 'master~1')
+            assert importer.detached_head?(pkg)
+        end
+        it "returns false if HEAD is pointing to a branch" do
+            assert !importer.detached_head?(pkg)
+        end
+        it "raises for any other error" do
+            flexmock(Autobuild::Subprocess).should_receive(:run).
+                and_raise(Autobuild::SubcommandFailed.new('test', 'test', 'bla', 200))
+            assert_raises(Autobuild::SubcommandFailed) do
+                importer.detached_head?(pkg)
+            end
+        end
+    end
+
+    describe "#current_branch" do
+        before do
+            importer.import(pkg)
+        end
+
+        it "returns the current branch name" do
+            importer.run_git(pkg, 'checkout', '-b', 'test')
+            assert_equal 'refs/heads/test', importer.current_branch(pkg)
+        end
+        it "returns nil if the head is detached" do
+            importer.run_git(pkg, 'checkout', 'master~1')
+            assert importer.current_branch(pkg).nil?
+        end
+        it "raises for any other error" do
+            flexmock(Autobuild::Subprocess).should_receive(:run).
+                and_raise(Autobuild::SubcommandFailed.new('test', 'test', 'bla', 200))
+            assert_raises(Autobuild::SubcommandFailed) do
+                importer.current_branch(pkg)
+            end
+        end
+    end
+
+    describe "#rev_parse" do
+        it "raises PackageException if the name does not exist" do
+            importer.import(pkg)
+            assert_raises(Autobuild::PackageException) do
+                importer.rev_parse(pkg, 'does_not_exist')
+            end
+        end
+    end
+
+    describe "#show" do
+        it "returns the content of a path at a commit" do
+            importer.import(pkg)
+            File.open(File.join(tempdir, 'git', 'test'), 'a') do |io|
+                io.puts "newline"
+            end
+            head = importer.rev_parse(pkg, 'HEAD')
+            importer.run_git(pkg, 'commit', '-a', '-m', 'test commit')
+            assert_equal '', importer.show(pkg, head, 'test')
+            assert_equal 'newline', importer.show(pkg, 'HEAD', 'test')
+        end
+    end
+
+    describe ".has_uncommitted_changes?" do
+        before do
+            importer.import(pkg)
+        end
+
+        it "returns true if some files is modified" do
+            File.open(File.join(tempdir, 'git', 'test'), 'a') do |io|
+                io.puts "newline"
+            end
+            assert Autobuild::Git.has_uncommitted_changes?(pkg)
+        end
+        it "returns true if some files is modified and staged" do
+            file = File.join(tempdir, 'git', 'test')
+            File.open(file, 'a') { |io| io.puts "newline" }
+            importer.run_git(pkg, 'add', file) 
+            assert Autobuild::Git.has_uncommitted_changes?(pkg)
+        end
+        it "returns true if a new file is added" do
+            newfile = File.join(tempdir, 'git', 'blabla')
+            FileUtils.touch newfile
+            importer.run_git(pkg, 'add', newfile) 
+            assert Autobuild::Git.has_uncommitted_changes?(pkg)
+        end
+        it "returns true if a file has been removed" do
+            FileUtils.rm_f File.join(tempdir, 'git', 'test')
+            assert Autobuild::Git.has_uncommitted_changes?(pkg)
+        end
+        it "returns true if a file has been removed and staged" do
+            delfile = File.join(tempdir, 'git', 'test')
+            FileUtils.rm_f delfile
+            importer.run_git(pkg, 'rm', delfile) 
+            assert Autobuild::Git.has_uncommitted_changes?(pkg)
+        end
+    end
+
+    describe "update" do
+        def self.common_commit_and_tag_behaviour
+
+            it "does not access the repository if the target is already merged and reset is false" do
+                importer.import(pkg)
+
+                # We relocate to a non-existing repository to ensure that it
+                # does not try to access it
+                importer.relocate('/does/not/exist')
+                pin_importer(1)
+                importer.import(pkg, reset: false)
+                assert_on_commit 0
+            end
+            it "does not access the repository if the target is already HEAD and reset is true" do
+                importer.import(pkg)
+                pin_importer(0)
+                importer.relocate('/does/not/exist')
+                importer.import(pkg, reset: true)
+                assert_on_commit 0
+            end
+            it "does not access the remote repository if the commit is present locally" do
+                pin_importer(1)
+                importer.import(pkg)
+                pin_importer(0)
+                importer.relocate('/does/not/exist')
+                importer.import(pkg, reset: false)
+                assert_on_commit 0
+            end
+            it "attempts to merge the target commit if it is not present in HEAD" do
+                pin_importer(1)
+                importer.import(pkg)
+                pin_importer(0)
+                importer.import(pkg, reset: false)
+                assert_on_commit 0
+            end
+            it "resets if reset is true" do
+                importer.import(pkg)
+                pin_importer(1)
+                importer.import(pkg, reset: true)
+                assert_on_commit 1
+            end
+            it "refuses to reset if some commits are present locally but not in the remote branch" do
+                importer.import(pkg)
+                File.open(File.join(tempdir, 'git', 'test3'), 'w') do |io|
+                    io.puts "test"
+                end
+                importer.run_git(pkg, 'add', 'test3')
+                importer.run_git(pkg, 'commit', '-a', '-m', 'third commit')
+                current_head = importer.rev_parse(pkg, 'HEAD')
+                pin_importer(1)
+                assert_raises(Autobuild::ImporterCannotReset) do
+                    importer.import(pkg, reset: true)
+                end
+                assert_equal current_head, importer.rev_parse(pkg, 'HEAD')
+            end
+            it "creates the local branch at the specified commit if the branch does not exist" do
+                importer.import(pkg)
+                head = importer.rev_parse(pkg, 'HEAD')
+                importer.local_branch = 'local'
+                importer.import(pkg)
+                assert_equal 'refs/heads/local', importer.current_branch(pkg)
+                assert_equal head, importer.rev_parse(pkg, 'HEAD')
+            end
+
+            it "acts on local_branch" do
+                importer.import(pkg)
+                head = importer.rev_parse(pkg, 'HEAD')
+                importer.run_git(pkg, 'reset', '--hard', 'master~1')
+                importer.run_git(pkg, 'branch', 'local')
+                importer.local_branch = 'local'
+                importer.import(pkg)
+                assert_equal 'refs/heads/local', importer.current_branch(pkg)
+                assert_equal head, importer.rev_parse(pkg, 'refs/remotes/autobuild/master')
+            end
+
+            it "refuses to update if the local and remote branches have diverged" do
+                importer.import(pkg)
+                importer.run_git(pkg, 'reset', '--hard', 'master~1')
+                File.open(File.join(tempdir, 'git', 'test'), 'a') do |io|
+                    io.puts "test"
+                end
+                importer.run_git(pkg, 'commit', '-a', '-m', 'a fork commit')
+                assert_raises(Autobuild::PackageException) do
+                    importer.import(pkg)
+                end
+            end
+        end
+        describe "with a specific commit given" do
+            def assert_on_commit(id)
+                assert_equal commits[id], importer.rev_parse(pkg, 'HEAD')
+            end
+            def commits
+                if !@commits
+                    importer = Autobuild.git(gitrepo)
+                    pkg = Autobuild::Package.new 'commits'
+                    pkg.srcdir = gitrepo
+                    pkg.importer = importer
+                    @commits = [
+                        importer.rev_parse(pkg, 'HEAD'),
+                        importer.rev_parse(pkg, 'HEAD~1')]
+                end
+                @commits
+            end
+
+            def pin_importer(id, options = Hash.new)
+                importer.relocate(importer.repository, options.merge(commit: commits[id]))
+            end
+
+            it "fetches from the remote repository if the commit is not present locally" do
+                untar('gitrepo-with-extra-commit-and-tag.tar')
+                importer.import(pkg)
+                extra_repo = File.join(tempdir, 'gitrepo-with-extra-commit-and-tag.git')
+                importer.relocate(extra_repo, commit: '1ddb20665622279700770be09f9a291b37c9b631')
+                importer.import(pkg, reset: false)
+                assert_equal  '1ddb20665622279700770be09f9a291b37c9b631', importer.rev_parse(pkg, 'HEAD')
+            end
+
+            common_commit_and_tag_behaviour
+        end
+        describe "with a specific tag given" do
+            attr_reader :commits
+
+            before do
+                importer = Autobuild.git(gitrepo)
+                pkg = Autobuild::Package.new 'commits'
+                pkg.srcdir = gitrepo
+                pkg.importer = importer
+                importer.run_git_bare(pkg, 'tag', "tag0", "HEAD")
+                importer.run_git_bare(pkg, 'tag', "tag1", "HEAD~1")
+                @commits = [
+                    importer.rev_parse(pkg, 'HEAD'),
+                    importer.rev_parse(pkg, 'HEAD~1')]
+            end
+
+            def assert_on_commit(id)
+                assert_equal commits[id], importer.rev_parse(pkg, 'HEAD')
+            end
+
+            def pin_importer(id, options = Hash.new)
+                importer.relocate(importer.repository, options.merge(tag: "tag#{id}"))
+            end
+
+            it "fetches from the remote repository if the commit is not present locally" do
+                untar('gitrepo-with-extra-commit-and-tag.tar')
+                importer.import(pkg)
+                extra_repo = File.join(tempdir, 'gitrepo-with-extra-commit-and-tag.git')
+                importer.relocate(extra_repo, tag: 'third_commit')
+                importer.import(pkg, reset: false)
+                tag_id = importer.rev_parse(pkg, 'third_commit')
+                assert_equal tag_id, importer.rev_parse(pkg, 'HEAD')
+            end
+
+            common_commit_and_tag_behaviour
+        end
+    end
+end
+