boxen 3.0.0.beta1 → 3.1.0

data/script/bootstrap

@@ -4,4 +4,4 @@
 cd "$(dirname $0)"/..
 
 rm -f .bundle/config
-bundle install --binstubs .bundle/bin --path .bundle --quiet
+bundle install --binstubs bin --path .bundle --quiet

data/script/tests

@@ -6,6 +6,5 @@ cd "$(dirname $0)"/..
 script/bootstrap &&
   ruby -rubygems -Ilib:test \
     -e 'require "bundler/setup"' \
-    -e 'require "minitest/autorun"' \
     -e 'tests = ARGV.empty? ? Dir["test/**/*_test.rb"] : ARGV' \
     -e 'tests.each { |f| load f }' "$@"

data/test/boxen/test.rb

@@ -2,6 +2,6 @@ require "minitest/autorun"
 require "mocha/setup"
 
 module Boxen
-  class Test < MiniTest::Test
+  class Test < MiniTest::Unit::TestCase
   end
 end

data/test/boxen_check_test.rb

@@ -0,0 +1,55 @@
+require "boxen/test"
+require "boxen/check"
+
+class BoxenCheckTest < Boxen::Test
+  def test_initialize
+    check = Boxen::Check.new :config
+    assert_equal :config, check.config
+  end
+
+  def test_ok?
+    ex = assert_raises RuntimeError do
+      Boxen::Check.new(:config).ok?
+    end
+
+    assert_match "must implement", ex.message
+  end
+
+  def test_run
+    ex = assert_raises RuntimeError do
+      Boxen::Check.new(:config).run
+    end
+
+    assert_match "must implement", ex.message
+  end
+
+  def test_self_checks
+    subclass = Class.new Boxen::Check
+    Boxen::Check.const_set :TestCheck, subclass
+
+    assert Boxen::Check.checks(:config).any? { |c| subclass === c },
+      "an instance of TestCheck exists in checks"
+  end
+
+  def test_self_checks_subclasses
+    klass = Struct.new :config
+    Boxen::Check.const_set :TestBadCheck, klass
+
+    refute Boxen::Check.checks(:config).any? { |c| klass === c },
+      "checks are subclasses of Boxen::Check"
+  end
+
+  def test_self_run
+    willrun = mock do
+      expects(:ok?).returns false
+      expects(:run)
+    end
+
+    wontrun = mock do
+      expects(:ok?).returns true
+    end
+
+    Boxen::Check.expects(:checks).with(:config).returns [willrun, wontrun]
+    Boxen::Check.run :config
+  end
+end

data/test/boxen_cli_test.rb

@@ -1,16 +1,39 @@
+require "boxen/test"
 require "boxen/cli"
 
-require "boxen/command_status"
+class BoxenCLITest < Boxen::Test
+  def setup
+    @config = Boxen::Config.new
+    @flags  = Boxen::Flags.new
+    @cli    = Boxen::CLI.new(@config, @flags)
+  end
+
+  def test_initialize
+    config = Boxen::Config.new
+    flags  = Boxen::Flags.new
+
+    cli = Boxen::CLI.new config, flags
 
-describe Boxen::CLI do
+    assert_equal config, cli.config
+    assert_equal flags,  cli.flags
 
-  it "is a fancy way of reinvoking commands at this time" do
-    config = mock("config")
-    Boxen::Config.expects(:load).returns(config)
-    Boxen::Command.expects(:invoke).with("foo", config).
-      returns(Boxen::CommandStatus.new(0))
+    assert_equal config, cli.runner.config
+    assert_equal flags,  cli.runner.flags
+  end
 
-    Boxen::CLI.run("foo")
+  def test_run
+    @cli.runner.expects(:run)
+    @cli.run
   end
 
+  def test_help
+    $stdout.stubs(:write)
+
+    flags = Boxen::Flags.new('--help')
+    cli   = Boxen::CLI.new(@config, flags)
+    cli.runner.expects(:run).never
+    assert_raises SystemExit do
+      cli.run
+    end
+  end
 end

data/test/boxen_config_test.rb

@@ -7,6 +7,13 @@ class BoxenConfigTest < Boxen::Test
     @config.repodir = "test/fixtures/repo"
   end
 
+  def test_debug?
+    refute @config.debug?
+
+    @config.debug = true
+    assert @config.debug?
+  end
+
   def test_email
     assert_nil @config.email
 
@@ -89,6 +96,27 @@ class BoxenConfigTest < Boxen::Test
     assert_equal "foo", @config.name
   end
 
+  def test_pretend?
+    refute @config.pretend?
+
+    @config.pretend = true
+    assert @config.pretend?
+  end
+
+  def test_profile?
+    refute @config.profile?
+
+    @config.profile = true
+    assert @config.profile?
+  end
+
+  def test_future_parser?
+    refute @config.future_parser?
+
+    @config.future_parser = true
+    assert @config.future_parser?
+  end
+
   def test_projects
     files = Dir["#{@config.repodir}/modules/projects/manifests/*.pp"]
     assert_equal files.size, @config.projects.size
@@ -296,6 +324,8 @@ class BoxenConfigTest < Boxen::Test
   end
 
   def test_token
+    assert_nil @config.token
+
     @config.token = "foo"
     assert_equal "foo", @config.token
   end
@@ -352,7 +382,7 @@ class BoxenConfigTest < Boxen::Test
     ENV["BOXEN_S3_BUCKET"] = val
   end
 
-  def test_s3bucket_env_var
+  def test_s3host_env_var
     val = ENV["BOXEN_S3_BUCKET"]
 
     ENV["BOXEN_S3_BUCKET"] = "my-bucket"

data/test/boxen_directories_test.rb

@@ -12,25 +12,25 @@ class BoxenPreflightDirectoriesTest < Boxen::Test
   end
 
   def test_not_okay_if_homedir_group_wrong
-    directories = Boxen::Preflight::Directories.new(@config, :command)
+    directories = Boxen::Preflight::Directories.new(@config)
     directories.stubs(:homedir_group).returns(false)
     refute directories.ok?
   end
 
   def test_not_okay_if_homedir_owner_wrong
-    directories = Boxen::Preflight::Directories.new(@config, :command)
+    directories = Boxen::Preflight::Directories.new(@config)
     directories.stubs(:homedir_owner).returns(false)
     refute directories.ok?
   end
 
   def test_not_okay_unless_homedir_exists
-    directories = Boxen::Preflight::Directories.new(@config, :command)
+    directories = Boxen::Preflight::Directories.new(@config)
     directories.stubs(:homedir_directory_exists?).returns(false)
     refute directories.ok?
   end
 
   def test_okay_if_allchecks_fine
-    directories = Boxen::Preflight::Directories.new(@config, :command)
+    directories = Boxen::Preflight::Directories.new(@config)
     directories.stubs(:homedir_directory_exists?).returns(true)
     directories.stubs(:homedir_owner).returns("foobar")
     directories.stubs(:homedir_group).returns("staff")

data/test/boxen_flags_test.rb

@@ -0,0 +1,217 @@
+require "boxen/test"
+require "boxen/flags"
+
+class BoxenFlagsTest < Boxen::Test
+  def test_apply
+    config = mock do
+      expects(:debug=).with true
+
+      stubs(:fde?).returns true
+      expects(:fde=).with false
+
+      expects(:homedir=).with "homedir"
+      expects(:logfile=).with "logfile"
+      expects(:login=).with "login"
+      expects(:token=).with "token"
+      expects(:pretend=).with true
+      expects(:profile=).with true
+      expects(:future_parser=).with true
+      expects(:report=).with true
+      expects(:graph=).with true
+      expects(:srcdir=).with "srcdir"
+      expects(:stealth=).with true
+      expects(:user=).with "user"
+      expects(:color=).with true
+    end
+
+    # Do our best to frob every switch.
+
+    flags = Boxen::Flags.new "--debug", "--help", "--login", "login",
+      "--no-fde", "--no-pull", "--no-issue", "--noop",
+      "--pretend", "--profile", "--future-parser", "--report", "--graph", "--projects",
+      "--user", "user", "--homedir", "homedir", "--srcdir", "srcdir",
+      "--logfile", "logfile", "--token", "token"
+
+    assert_same config, flags.apply(config)
+  end
+
+  def test_args
+    config = flags "--debug", "foo"
+    assert_equal %w(foo), config.args
+  end
+
+  def test_debug
+    refute flags.debug?
+    assert flags("--debug").debug?
+  end
+
+  def test_env?
+    refute flags.env?
+    assert flags("--env").env?
+  end
+
+  def test_help
+    refute flags.help?
+
+    %w(--help -h -?).each do |flag|
+      assert flags(flag).help?
+    end
+  end
+
+  def test_disable_services?
+    refute flags.disable_services?
+    assert flags("--disable-services").disable_services?
+  end
+
+  def test_enable_services?
+    refute flags.enable_services?
+    assert flags("--enable-services").enable_services?
+  end
+
+  def test_list_services?
+    refute flags.list_services?
+    assert flags("--list-services").list_services?
+  end
+
+  def test_homedir
+    assert_nil flags.homedir
+    assert_equal "foo", flags("--homedir", "foo").homedir
+  end
+
+  def test_initialize_bad_option
+    ex = assert_raises Boxen::Error do
+      flags "--bad-option"
+    end
+
+    assert_match "invalid option", ex.message
+    assert_match "--bad-option", ex.message
+  end
+
+  def test_initialize_dups
+    args  = %w(foo)
+    config = flags args
+
+    assert_equal args, config.args
+    refute_same args, config.args
+  end
+
+  def test_initialize_empty
+    config = flags
+    assert_equal [], config.args
+  end
+
+  def test_initialize_flattens
+    config = flags "foo", ["bar"]
+    assert_equal %w(foo bar), config.args
+  end
+
+  def test_initialize_nils
+    config = flags "foo", nil, "bar"
+    assert_equal %w(foo bar), config.args
+  end
+
+  def test_initialize_strings
+    config = flags :foo, [:bar]
+    assert_equal %w(foo bar), config.args
+  end
+
+  def test_logfile
+    assert_nil flags.logfile
+    assert_equal "foo", flags("--logfile", "foo").logfile
+  end
+
+  def test_login
+    assert_nil flags.login
+    assert_equal "jbarnette", flags("--login", "jbarnette").login
+  end
+
+  def test_no_fde
+    assert flags.fde?
+    refute flags("--no-fde").fde?
+  end
+
+  def test_no_pull_is_a_noop
+    flags "--no-pull"
+  end
+
+  def test_parse
+    config = flags
+    config.parse "--debug", "foo"
+
+    assert config.debug?
+    assert_equal %w(foo), config.args
+  end
+
+  def test_token
+    assert_nil flags.token
+    assert_equal "foo", flags("--token", "foo").token
+  end
+
+  def test_token_missing_value
+    ex = assert_raises Boxen::Error do
+      flags "--token"
+    end
+
+    assert_match "missing argument", ex.message
+  end
+
+  def test_pretend
+    refute flags.pretend?
+    assert flags("--noop").pretend?
+    assert flags("--pretend").pretend?
+  end
+
+  def test_profile
+    refute flags.profile?
+    assert flags("--profile").profile?
+  end
+
+  def test_future_parser
+    refute flags.future_parser?
+    assert flags("--future-parser").future_parser?
+  end
+
+  def test_report
+    refute flags.report?
+    assert flags("--report").report?
+  end
+
+  def test_graph
+    refute flags.graph?
+    assert flags("--graph").graph?
+  end
+
+  def test_projects
+    refute flags.projects?
+    assert flags("--projects").projects?
+  end
+
+  def test_srcdir
+    assert_nil flags.srcdir
+    assert_equal "foo", flags("--srcdir", "foo").srcdir
+  end
+
+  def test_stealth
+    refute flags.stealth?
+    assert flags("--no-issue").stealth?
+    assert flags("--stealth").stealth?
+  end
+
+  def test_user
+    assert_equal "jbarnette", flags("--user", "jbarnette").user
+  end
+
+  def test_user_missing_value
+    ex = assert_raises Boxen::Error do
+      flags "--user"
+    end
+
+    assert_match "missing argument", ex.message
+  end
+
+  # Create an instance of Boxen::Flags with optional `args`.
+
+  def flags(*args)
+    Boxen::Flags.new *args
+  end
+end

data/test/{postflight/boxen_postflight_github_issue_test.rb → boxen_hook_github_issue_test.rb}

@@ -1,54 +1,57 @@
-require 'boxen/test'
-require 'boxen/postflight'
-require 'boxen/postflight/github_issue'
+require "boxen/test"
+require "boxen/hook/github_issue"
 
 class Boxen::Config
   attr_writer :api
 end
 
-class Boxen::Postflight::GithubIssue < Boxen::Postflight
-  attr_writer :checkout
-end
-
-class BoxenPostflightGithubIssueTest < Boxen::Test
+class BoxenHookGitHubIssueTest < Boxen::Test
   def setup
     @config   = Boxen::Config.new
     @checkout = Boxen::Checkout.new(@config)
-    @command  = stub 'command', :success? => true
-    @check    = Boxen::Postflight::GithubIssue.new @config, @command
-    @check.checkout = @checkout
+    @puppet   = mock 'puppeteer'
+    @result   = stub 'result', :success? => true
+    @hook = Boxen::Hook::GitHubIssue.new @config, @checkout, @puppet, @result
   end
 
   def test_enabled
     original = ENV['BOXEN_ISSUES_ENABLED']
 
     ENV['BOXEN_ISSUES_ENABLED'] = nil
-    refute @check.enabled?
+    refute @hook.enabled?
 
     ENV['BOXEN_ISSUES_ENABLED'] = 'duh'
-    assert @check.enabled?
+    assert @hook.enabled?
 
     ENV['BOXEN_ISSUES_ENABLED'] = original
   end
 
-  def test_ok
-    @check.stubs(:enabled?).returns(false)
+  def test_perform
+    @hook.stubs(:enabled?).returns(false)
+    @config.stubs(:stealth?).returns(true)
+    @config.stubs(:pretend?).returns(true)
     @checkout.stubs(:master?).returns(false)
     @config.stubs(:login).returns(nil)
 
-    assert @check.ok?
+    refute @hook.perform?
+
+    @hook.stubs(:enabled?).returns(true)
+    refute @hook.perform?
 
-    @check.stubs(:enabled?).returns(true)
-    assert @check.ok?
+    @config.stubs(:stealth?).returns(false)
+    refute @hook.perform?
+
+    @config.stubs(:pretend?).returns(false)
+    refute @hook.perform?
 
     @checkout.stubs(:master?).returns(true)
-    assert @check.ok?
+    refute @hook.perform?
 
     @config.stubs(:login).returns('')
-    assert @check.ok?
+    refute @hook.perform?
 
     @config.stubs(:login).returns('somelogin')
-    refute @check.ok?
+    assert @hook.perform?
   end
 
   def test_compare_url
@@ -57,7 +60,7 @@ class BoxenPostflightGithubIssueTest < Boxen::Test
     @checkout.expects(:sha).returns(sha)
 
     expected = "https://github.com/#{repo}/compare/#{sha}...master"
-    assert_equal expected, @check.compare_url
+    assert_equal expected, @hook.compare_url
   end
 
   def test_compare_url_ghurl
@@ -67,102 +70,108 @@ class BoxenPostflightGithubIssueTest < Boxen::Test
     @checkout.expects(:sha).returns(sha)
 
     expected = "https://git.foo.com/#{repo}/compare/#{sha}...master"
-    assert_equal expected, @check.compare_url
+    assert_equal expected, @hook.compare_url
   end
 
   def test_hostname
-    Socket.expects(:gethostname).returns("whatevs.local")
-    assert_equal "whatevs.local", @check.hostname
+    @hook.expects(:"`").with("hostname").returns "whatevs.local\n"
+    assert_equal "whatevs.local", @hook.hostname
   end
 
   def test_initialize
-    check = Boxen::Postflight::GithubIssue.new :config, :command
-    assert_equal :config,   check.config
-    assert_equal :command,  check.command
+    hook = Boxen::Hook::GitHubIssue.new :config, :checkout, :puppet, :result
+    assert_equal :config,   hook.config
+    assert_equal :checkout, hook.checkout
+    assert_equal :puppet,   hook.puppet
+    assert_equal :result,   hook.result
   end
 
   def test_os
-    @check.expects(:"`").with("sw_vers -productVersion").returns "11.1.1\n"
-    assert_equal "11.1.1", @check.os
+    @hook.expects(:"`").with("sw_vers -productVersion").returns "11.1.1\n"
+    assert_equal "11.1.1", @hook.os
   end
 
   def test_shell
     val = ENV['SHELL']
 
     ENV['SHELL'] = '/bin/crush'
-    assert_equal "/bin/crush", @check.shell
+    assert_equal "/bin/crush", @hook.shell
 
     ENV['SHELL'] = val
   end
 
   def test_record_failure
-    @check.stubs(:issues?).returns(true)
+    @hook.stubs(:issues?).returns(true)
 
     details = 'Everything went wrong.'
-    @check.stubs(:failure_details).returns(details)
+    @hook.stubs(:failure_details).returns(details)
 
     @config.reponame = repo = 'some/repo'
     @config.user     = user = 'hapless'
 
-    @check.failure_label = label = 'boom'
+    @hook.failure_label = label = 'boom'
 
     @config.api = api = mock('api')
     api.expects(:create_issue).with(repo, "Failed for #{user}", details, :labels => [label])
 
-    @check.record_failure
+    @hook.record_failure
   end
 
   def test_record_failure_no_issues
-    @check.stubs(:issues?).returns(false)
+    @hook.stubs(:issues?).returns(false)
 
     @config.api = api = mock('api')
     api.expects(:create_issue).never
 
-    @check.record_failure
+    @hook.record_failure
   end
 
   def test_failure_label
     default = 'failure'
-    assert_equal default, @check.failure_label
+    assert_equal default, @hook.failure_label
 
-    @check.failure_label = label = 'oops'
-    assert_equal label, @check.failure_label
+    @hook.failure_label = label = 'oops'
+    assert_equal label, @hook.failure_label
 
-    @check.failure_label = nil
-    assert_equal default, @check.failure_label
+    @hook.failure_label = nil
+    assert_equal default, @hook.failure_label
   end
 
   def test_ongoing_label
     default = 'ongoing'
-    assert_equal default, @check.ongoing_label
+    assert_equal default, @hook.ongoing_label
 
-    @check.ongoing_label = label = 'checkit'
-    assert_equal label, @check.ongoing_label
+    @hook.ongoing_label = label = 'checkit'
+    assert_equal label, @hook.ongoing_label
 
-    @check.ongoing_label = nil
-    assert_equal default, @check.ongoing_label
+    @hook.ongoing_label = nil
+    assert_equal default, @hook.ongoing_label
   end
 
   def test_failure_details
     sha = 'decafbad'
     @checkout.stubs(:sha).returns(sha)
     hostname = 'cools.local'
-    @check.stubs(:hostname).returns(hostname)
+    @hook.stubs(:hostname).returns(hostname)
     shell = '/bin/ksh'
-    @check.stubs(:shell).returns(shell)
+    @hook.stubs(:shell).returns(shell)
     os = '11.1.1'
-    @check.stubs(:os).returns(os)
+    @hook.stubs(:os).returns(os)
     log = "so\nmany\nthings\nto\nreport"
-    @check.stubs(:logfile).returns(log)
+    @hook.stubs(:log).returns(log)
 
-    @config.reponame = 'some/repo'
-    compare = @check.compare_url
+    @config.reponame = repo = 'some/repo'
+    compare = @hook.compare_url
     changes = 'so many changes'
     @checkout.stubs(:changes).returns(changes)
 
+    commands = %w[/path/to/puppet apply stuff_and_things]
+    @puppet.stubs(:command).returns(commands)
+    command = commands.join(' ')
+
     @config.logfile = logfile = '/path/to/logfile.txt'
 
-    details = @check.failure_details
+    details = @hook.failure_details
 
     assert_match sha,      details
     assert_match hostname, details
@@ -170,17 +179,18 @@ class BoxenPostflightGithubIssueTest < Boxen::Test
     assert_match os,       details
     assert_match compare,  details
     assert_match changes,  details
+    assert_match command,  details
     assert_match logfile,  details
     assert_match log,      details
   end
 
-  def test_logfile
+  def test_log
     @config.logfile = logfile = '/path/to/logfile.txt'
 
     log = 'a bunch of log data'
     File.expects(:read).with(logfile).returns(log)
 
-    assert_equal log, @check.logfile
+    assert_equal log, @hook.log
   end
 
 
@@ -192,12 +202,12 @@ class BoxenPostflightGithubIssueTest < Boxen::Test
   Label = Struct.new(:name)
 
   def test_close_failures
-    @check.stubs(:issues?).returns(true)
+    @hook.stubs(:issues?).returns(true)
 
     @config.reponame = repo = 'some/repo'
 
     issues = Array.new(3) { |i|  Issue.new(i*2 + 2) }
-    @check.stubs(:failures).returns(issues)
+    @hook.stubs(:failures).returns(issues)
 
     sha = 'decafbad'
     @checkout.stubs(:sha).returns(sha)
@@ -208,29 +218,29 @@ class BoxenPostflightGithubIssueTest < Boxen::Test
       api.expects(:close_issue).with(repo, issue.number)
     end
 
-    @check.close_failures
+    @hook.close_failures
   end
 
   def test_close_failures_no_issues
-    @check.stubs(:issues?).returns(false)
+    @hook.stubs(:issues?).returns(false)
 
-    @check.expects(:failures).never
+    @hook.expects(:failures).never
 
     @config.api = api = mock('api')
     api.expects(:add_comment).never
     api.expects(:close_issue).never
 
-    @check.close_failures
+    @hook.close_failures
   end
 
   def test_failures
-    @check.stubs(:issues?).returns(true)
+    @hook.stubs(:issues?).returns(true)
 
     @config.reponame = repo = 'some/repo'
     @config.login    = user = 'hapless'
 
-    @check.failure_label = fail_label = 'ouch'
-    @check.ongoing_label = goon_label = 'goon'
+    @hook.failure_label = fail_label = 'ouch'
+    @hook.ongoing_label = goon_label = 'goon'
 
     fail_l = Label.new(fail_label)
     goon_l = Label.new(goon_label)
@@ -247,16 +257,16 @@ class BoxenPostflightGithubIssueTest < Boxen::Test
     @config.api = api = mock('api')
     api.expects(:list_issues).with(repo, :state => 'open', :labels => fail_label, :creator => user).returns(issues)
 
-    assert_equal issues.values_at(0,1,3), @check.failures
+    assert_equal issues.values_at(0,1,3), @hook.failures
   end
 
   def test_failures_no_issues
-    @check.stubs(:issues?).returns(false)
+    @hook.stubs(:issues?).returns(false)
 
     @config.api = api = mock('api')
     api.expects(:list_issues).never
 
-    assert_equal [], @check.failures
+    assert_equal [], @hook.failures
   end
 
   RepoInfo = Struct.new(:has_issues)
@@ -267,18 +277,18 @@ class BoxenPostflightGithubIssueTest < Boxen::Test
 
     @config.api = api = mock('api')
     api.stubs(:repository).with(repo).returns(repo_info)
-    assert @check.issues?
+    assert @hook.issues?
 
     repo_info = RepoInfo.new(false)
     api.stubs(:repository).with(repo).returns(repo_info)
-    refute @check.issues?
+    refute @hook.issues?
 
     @config.stubs(:reponame)  # to ensure the returned value is nil
     api.stubs(:repository).returns(RepoInfo.new(true))
-    refute @check.issues?
+    refute @hook.issues?
 
     @config.stubs(:reponame).returns('boxen/our-boxen') # our main public repo
     api.stubs(:repository).returns(RepoInfo.new(true))
-    refute @check.issues?
+    refute @hook.issues?
   end
 end