boxen-linux 2.7.1

data/test/boxen_directories_test.rb

@@ -0,0 +1,40 @@
+require 'boxen/test'
+require 'boxen/preflight/directories'
+
+class BoxenPreflightDirectoriesTest < Boxen::Test
+  class TestConfig
+    def user;    "foobar"; end
+    def homedir; "foobar"; end
+  end
+
+  def setup
+    @config = TestConfig.new
+  end
+
+  def test_not_okay_if_homedir_group_wrong
+    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)
+    directories.stubs(:homedir_owner).returns(false)
+    refute directories.ok?
+  end
+
+  def test_not_okay_unless_homedir_exists
+    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)
+    directories.stubs(:homedir_directory_exists?).returns(true)
+    directories.stubs(:homedir_owner).returns("foobar")
+    directories.stubs(:homedir_group).returns("staff")
+
+    assert directories.ok?
+  end
+end

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/boxen_hook_github_issue_test.rb

@@ -0,0 +1,294 @@
+require "boxen/test"
+require "boxen/hook/github_issue"
+
+class Boxen::Config
+  attr_writer :api
+end
+
+class BoxenHookGitHubIssueTest < Boxen::Test
+  def setup
+    @config   = Boxen::Config.new
+    @checkout = Boxen::Checkout.new(@config)
+    @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 @hook.enabled?
+
+    ENV['BOXEN_ISSUES_ENABLED'] = 'duh'
+    assert @hook.enabled?
+
+    ENV['BOXEN_ISSUES_ENABLED'] = original
+  end
+
+  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)
+
+    refute @hook.perform?
+
+    @hook.stubs(:enabled?).returns(true)
+    refute @hook.perform?
+
+    @config.stubs(:stealth?).returns(false)
+    refute @hook.perform?
+
+    @config.stubs(:pretend?).returns(false)
+    refute @hook.perform?
+
+    @checkout.stubs(:master?).returns(true)
+    refute @hook.perform?
+
+    @config.stubs(:login).returns('')
+    refute @hook.perform?
+
+    @config.stubs(:login).returns('somelogin')
+    assert @hook.perform?
+  end
+
+  def test_compare_url
+    @config.reponame = repo = 'org/repo'
+    sha = 'deadbeef'
+    @checkout.expects(:sha).returns(sha)
+
+    expected = "https://github.com/#{repo}/compare/#{sha}...master"
+    assert_equal expected, @hook.compare_url
+  end
+
+  def test_compare_url_ghurl
+    @config.reponame = repo = 'org/repo'
+    @config.ghurl = 'https://git.foo.com'
+    sha = 'deadbeef'
+    @checkout.expects(:sha).returns(sha)
+
+    expected = "https://git.foo.com/#{repo}/compare/#{sha}...master"
+    assert_equal expected, @hook.compare_url
+  end
+
+  def test_hostname
+    @hook.expects(:"`").with("hostname").returns "whatevs.local\n"
+    assert_equal "whatevs.local", @hook.hostname
+  end
+
+  def test_initialize
+    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
+    @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", @hook.shell
+
+    ENV['SHELL'] = val
+  end
+
+  def test_record_failure
+    @hook.stubs(:issues?).returns(true)
+
+    details = 'Everything went wrong.'
+    @hook.stubs(:failure_details).returns(details)
+
+    @config.reponame = repo = 'some/repo'
+    @config.user     = user = 'hapless'
+
+    @hook.failure_label = label = 'boom'
+
+    @config.api = api = mock('api')
+    api.expects(:create_issue).with(repo, "Failed for #{user}", details, :labels => [label])
+
+    @hook.record_failure
+  end
+
+  def test_record_failure_no_issues
+    @hook.stubs(:issues?).returns(false)
+
+    @config.api = api = mock('api')
+    api.expects(:create_issue).never
+
+    @hook.record_failure
+  end
+
+  def test_failure_label
+    default = 'failure'
+    assert_equal default, @hook.failure_label
+
+    @hook.failure_label = label = 'oops'
+    assert_equal label, @hook.failure_label
+
+    @hook.failure_label = nil
+    assert_equal default, @hook.failure_label
+  end
+
+  def test_ongoing_label
+    default = 'ongoing'
+    assert_equal default, @hook.ongoing_label
+
+    @hook.ongoing_label = label = 'checkit'
+    assert_equal label, @hook.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'
+    @hook.stubs(:hostname).returns(hostname)
+    shell = '/bin/ksh'
+    @hook.stubs(:shell).returns(shell)
+    os = '11.1.1'
+    @hook.stubs(:os).returns(os)
+    log = "so\nmany\nthings\nto\nreport"
+    @hook.stubs(:log).returns(log)
+
+    @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 = @hook.failure_details
+
+    assert_match sha,      details
+    assert_match hostname, details
+    assert_match shell,    details
+    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_log
+    @config.logfile = logfile = '/path/to/logfile.txt'
+
+    log = 'a bunch of log data'
+    File.expects(:read).with(logfile).returns(log)
+
+    assert_equal log, @hook.log
+  end
+
+
+  Issue = Struct.new(:number, :labels) do
+    def labels
+      self[:labels] || []
+    end
+  end
+  Label = Struct.new(:name)
+
+  def test_close_failures
+    @hook.stubs(:issues?).returns(true)
+
+    @config.reponame = repo = 'some/repo'
+
+    issues = Array.new(3) { |i|  Issue.new(i*2 + 2) }
+    @hook.stubs(:failures).returns(issues)
+
+    sha = 'decafbad'
+    @checkout.stubs(:sha).returns(sha)
+
+    @config.api = api = mock('api')
+    issues.each do |issue|
+      api.expects(:add_comment).with(repo, issue.number, "Succeeded at version #{sha}.")
+      api.expects(:close_issue).with(repo, issue.number)
+    end
+
+    @hook.close_failures
+  end
+
+  def test_close_failures_no_issues
+    @hook.stubs(:issues?).returns(false)
+
+    @hook.expects(:failures).never
+
+    @config.api = api = mock('api')
+    api.expects(:add_comment).never
+    api.expects(:close_issue).never
+
+    @hook.close_failures
+  end
+
+  def test_failures
+    @hook.stubs(:issues?).returns(true)
+
+    @config.reponame = repo = 'some/repo'
+    @config.login    = user = 'hapless'
+
+    @hook.failure_label = fail_label = 'ouch'
+    @hook.ongoing_label = goon_label = 'goon'
+
+    fail_l = Label.new(fail_label)
+    goon_l = Label.new(goon_label)
+    pop_l  = Label.new('popcorn')
+
+    issues = [
+      Issue.new(0, [fail_l]),
+      Issue.new(1, [fail_l, pop_l]),
+      Issue.new(2, [fail_l, goon_l]),
+      Issue.new(3, [fail_l, Label.new('bang')]),
+      Issue.new(4, [fail_l, goon_l, pop_l]),
+    ]
+
+    @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), @hook.failures
+  end
+
+  def test_failures_no_issues
+    @hook.stubs(:issues?).returns(false)
+
+    @config.api = api = mock('api')
+    api.expects(:list_issues).never
+
+    assert_equal [], @hook.failures
+  end
+
+  RepoInfo = Struct.new(:has_issues)
+  def test_issues?
+    @config.reponame = repo = 'some/repo'
+
+    repo_info = RepoInfo.new(true)
+
+    @config.api = api = mock('api')
+    api.stubs(:repository).with(repo).returns(repo_info)
+    assert @hook.issues?
+
+    repo_info = RepoInfo.new(false)
+    api.stubs(:repository).with(repo).returns(repo_info)
+    refute @hook.issues?
+
+    @config.stubs(:reponame)  # to ensure the returned value is nil
+    api.stubs(:repository).returns(RepoInfo.new(true))
+    refute @hook.issues?
+
+    @config.stubs(:reponame).returns('boxen/our-boxen') # our main public repo
+    api.stubs(:repository).returns(RepoInfo.new(true))
+    refute @hook.issues?
+  end
+end