From 59a0c1e1b5604ab198e9694df030cd855b5ccbd6 Mon Sep 17 00:00:00 2001 From: Samuel John Date: Thu, 13 Jun 2013 15:52:23 +0200 Subject: [PATCH] Improve python tests for brew bots Allow `build.with?` and similar methods to be used during the test phase. The BuildOptions (`build`) are initialized with the `Tab.used_options` unless explicitly overwritten on the command line. So basically `build.with?` works in `def install` and in `test do` as one would naively expect. (For the test, gramatically it should be `built.with?` but who cares) If a formula was installed `--with-python`, now the tests are also run `--with-python`. This enables us to use the `python do ... end` in a meaningful manner. Using `python do ... end` blocks for the tests, because the bot.brew.sh has system python per default and we need to set the PYTHONPATH for the test. Potentially to different values for Python 2.x and 3.x. --- Library/Homebrew/build_options.rb | 25 ++++++++++++++++----- Library/Homebrew/formula.rb | 3 +++ Library/Homebrew/python_helper.rb | 6 ++--- Library/Homebrew/test/test_build_options.rb | 20 ++++++++++++++--- 4 files changed, 42 insertions(+), 12 deletions(-) diff --git a/Library/Homebrew/build_options.rb b/Library/Homebrew/build_options.rb index 0cd3a5a467..441a81bc29 100644 --- a/Library/Homebrew/build_options.rb +++ b/Library/Homebrew/build_options.rb @@ -100,13 +100,26 @@ class BuildOptions # implicit_options are needed because `depends_on 'spam' => 'with-stuff'` # complains if 'spam' has stuff as default and only defines `--without-stuff`. def implicit_options - implicit = unused_options.map do |o| - if o.name =~ /^with-(.+)$/ && without?($1) - Option.new("without-#{$1}") # we lose the description, but that's ok - elsif o.name =~ /^without-(.+)$/ && with?($1) - Option.new("with-#{$1}") - end + implicit = unused_options.map do |option| + opposite_of option unless has_opposite_of? option end.compact Options.new(implicit) end + + def has_opposite_of? option + true if args.include? opposite_of option + end + + def opposite_of option + option = Option.new option + if option.name =~ /^with-(.+)$/ + Option.new("without-#{$1}") + elsif option.name =~ /^without-(.+)$/ + Option.new("with-#{$1}") + elsif option.name =~ /^enable-(.+)$/ + Option.new("disable-#{$1}") + elsif option.name =~ /^disable-(.+)$/ + Option.new("enable-#{$1}") + end + end end diff --git a/Library/Homebrew/formula.rb b/Library/Homebrew/formula.rb index 39bea8ee68..e5b071c0f3 100644 --- a/Library/Homebrew/formula.rb +++ b/Library/Homebrew/formula.rb @@ -515,6 +515,9 @@ class Formula def test require 'test/unit/assertions' extend(Test::Unit::Assertions) + # Adding the used options allows us to use `build.with?` inside of tests + tab = Tab.for_name(name) + tab.used_options.each { |opt| build.args << opt unless build.has_opposite_of? opt } ret = nil mktemp do @testpath = Pathname.pwd diff --git a/Library/Homebrew/python_helper.rb b/Library/Homebrew/python_helper.rb index 8ebf0b7943..bace441fc0 100644 --- a/Library/Homebrew/python_helper.rb +++ b/Library/Homebrew/python_helper.rb @@ -16,11 +16,11 @@ def python_helper(options={:allowed_major_versions => [2, 3]}, &block) if !block_given? and !@current_python.nil? # We are already inside of a `python do ... end` block, so just return - # the current_python or false if the version.major is not allowed. + # the current_python or nil if the version.major is not allowed. if options[:allowed_major_versions].include?(@current_python.version.major) return @current_python else - return false + return nil end end @@ -42,7 +42,7 @@ def python_helper(options={:allowed_major_versions => [2, 3]}, &block) end # Allow to use an else-branch like so: `if python do ... end; else ... end`. - return false if filtered_python_reqs.empty? + return nil if filtered_python_reqs.empty? # Sort by version, so the older 2.x will be used first and if no # block_given? then 2.x is preferred because it is returned. diff --git a/Library/Homebrew/test/test_build_options.rb b/Library/Homebrew/test/test_build_options.rb index cc5fd01d7b..9e2a9e06f0 100644 --- a/Library/Homebrew/test/test_build_options.rb +++ b/Library/Homebrew/test/test_build_options.rb @@ -1,9 +1,9 @@ -require 'testing_env' + require 'testing_env' require 'build_options' class BuildOptionsTests < Test::Unit::TestCase def setup - args = %w{--with-foo --with-bar --without-qux} + args = %w{--with-foo --with-bar --without-qux} # args fake the command line @build = BuildOptions.new(args) @build.add("with-foo") @build.add("with-bar") @@ -44,7 +44,7 @@ class BuildOptionsTests < Test::Unit::TestCase end def test_implicit_options - # --without-baz is not explicitly specified on the command line + # --without-baz is not explicitly specified on the command line (i.e. args) # therefore --with-baz should be implicitly assumed: assert @build.implicit_options.include?("--with-baz") # But all these should not be in the implict_options: @@ -53,4 +53,18 @@ class BuildOptionsTests < Test::Unit::TestCase assert !@build.implicit_options.include?("--without-bar") assert !@build.implicit_options.include?("--with-qux") end + + def test_opposite_of + assert @build.opposite_of(Option.new("with-foo")) == Option.new("without-foo") + assert @build.opposite_of("without-foo") == Option.new("with-foo") + assert @build.opposite_of(Option.new("enable-spam")) == Option.new("disable-spam") + assert @build.opposite_of("disable-beer") == Option.new("enable-beer") + end + + def test_has_opposite_of? + assert @build.has_opposite_of?("--without-foo") + assert @build.has_opposite_of?(Option.new("--with-qux")) + assert !@build.has_opposite_of?("--without-qux") + assert !@build.has_opposite_of?("--without-nonexisting") + end end