boxen23 3.1.3a

data/test/boxen_hook_web_test.rb

@@ -0,0 +1,58 @@
+require "boxen/test"
+require "boxen/hook/web"
+
+class Boxen::Config
+  attr_writer :api
+end
+
+class BoxenHookWebTest < Boxen::Test
+  def setup
+    @config   = Boxen::Config.new
+    @checkout = Boxen::Checkout.new(@config)
+    @puppet   = mock 'puppeteer'
+    @result   = stub 'result', :success? => true
+    @hook = Boxen::Hook::Web.new @config, @checkout, @puppet, @result
+  end
+
+  def test_enabled
+    original = ENV['BOXEN_WEB_HOOK_URL']
+
+    ENV['BOXEN_WEB_HOOK_URL'] = nil
+    refute @hook.enabled?
+
+    ENV['BOXEN_WEB_HOOK_URL'] = ''
+    refute @hook.enabled?
+
+    ENV['BOXEN_WEB_HOOK_URL'] = '1'
+    assert @hook.enabled?
+
+    ENV['BOXEN_WEB_HOOK_URL'] = original
+  end
+
+  def test_perform
+    @hook.stubs(:enabled?).returns(false)
+    refute @hook.perform?
+
+    @hook.stubs(:enabled?).returns(true)
+    assert @hook.perform?
+  end
+
+  def test_run
+    @config.stubs(:user).returns('fred')
+    @checkout.stubs(:sha).returns('87dbag3')
+    @result.stubs(:success?).returns(false)
+    now = Time.now
+    Time.stubs(:now).returns(now)
+
+    @hook.stubs(:enabled?).returns(true)
+
+    @hook.expects(:post_web_hook).with({
+      :login  => 'fred',
+      :sha    => '87dbag3',
+      :status => 'failure',
+      :time   => "#{now.utc.to_i}"
+    })
+
+    @hook.run
+  end
+end

data/test/boxen_keychain_test.rb

@@ -0,0 +1,21 @@
+require 'boxen/test'
+require "boxen/util"
+require 'boxen/keychain'
+
+class BoxenKeychainTest < Boxen::Test
+  def setup
+    @keychain = Boxen::Keychain.new('test') if Boxen::Util.osx?
+  end
+
+  def test_get_token
+    return skip('Keychain helper is OSX only') unless Boxen::Util.osx?
+    @keychain.expects(:get).with('GitHub API Token').returns('foobar')
+    assert_equal 'foobar', @keychain.token
+  end
+
+  def test_set_token
+    return skip('Keychain helper is OSX only') unless Boxen::Util.osx?
+    @keychain.expects(:set).with('GitHub API Token', 'foobar').returns('foobar')
+    assert_equal 'foobar', @keychain.token=('foobar')
+  end
+end

data/test/boxen_postflight_active_test.rb

@@ -0,0 +1,29 @@
+require "boxen/test"
+require "boxen/postflight"
+
+class BoxenPostflightActiveTest < Boxen::Test
+  def setup
+    @check = Boxen::Postflight::Active.new :config
+  end
+
+  def test_ok?
+    Boxen::Util.expects(:active?).returns true
+    assert @check.ok?
+  end
+
+  def test_ok_bad
+    Boxen::Util.expects(:active?).returns false
+    refute @check.ok?
+  end
+
+  def test_run
+    config = stub :envfile => "foo"
+    @check = Boxen::Postflight::Active.new config
+
+    stdout, stderr = capture_io do
+      @check.run
+    end
+
+    assert_match "loaded", stderr
+  end
+end

data/test/boxen_postflight_env_test.rb

@@ -0,0 +1,6 @@
+require "boxen/test"
+require "boxen/postflight"
+
+class BoxenPostflightEnvTest < Boxen::Test
+
+end

data/test/boxen_preflight_creds_test.rb

@@ -0,0 +1,177 @@
+require 'boxen/test'
+require 'boxen/config'
+require 'boxen/preflight/creds'
+
+class BoxenPreflightCredsTest < Boxen::Test
+  # Make a struct to use for stubbing out authorization objects.
+  Struct.new("Authorization", :id, :note, :fingerprint, :token)
+
+  def setup
+    @config   = Boxen::Config.new do |c|
+      c.user  = 'mojombo'
+      c.token = 'sekr3t!'
+    end
+    ENV.delete("BOXEN_GITHUB_LOGIN")
+    ENV.delete("BOXEN_GITHUB_PASSWORD")
+  end
+
+  def test_basic
+    preflight = Boxen::Preflight::Creds.new @config
+
+    error = Octokit::Unauthorized.new
+    @config.api.stubs(:user).raises(error)
+
+    refute preflight.ok?
+  end
+
+  def test_basic_with_otp_challenge
+    preflight = Boxen::Preflight::Creds.new @config
+
+    blank_opt = {:headers => {}}
+    good_otp  = {:headers => {"X-GitHub-OTP" => "123456"}}
+
+    error = Octokit::OneTimePasswordRequired.new
+    error.stubs(:message).returns("OTP")
+
+    preflight.tmp_api.expects(:authorizations).with(blank_opt).raises(error)
+    preflight.tmp_api.expects(:authorizations).with(good_otp).returns([])
+    preflight.tmp_api.expects(:create_authorization).raises(error)
+
+    preflight.expects(:warn)
+    HighLine.any_instance.expects(:ask).returns("123456")
+
+    preflight.get_tokens
+    assert_equal "123456", preflight.otp
+  end
+
+  def test_fetch_login_and_password_when_nothing_is_given_in_env
+    # fetches login and password by asking
+    preflight = Boxen::Preflight::Creds.new @config
+    HighLine.any_instance.expects(:ask).with("GitHub login: ").returns "l"
+    HighLine.any_instance.expects(:ask).with("GitHub password: ").returns "p"
+    preflight.send(:fetch_login_and_password)
+
+    assert_equal "l", @config.login
+    assert_equal "p", preflight.instance_variable_get(:@password)
+  end
+
+  def test_fetch_password_when_login_is_given_in_env
+    # fetches only password by asking
+    ENV["BOXEN_GITHUB_LOGIN"] = "l"
+    preflight = Boxen::Preflight::Creds.new @config
+    preflight.expects(:warn)
+    HighLine.any_instance.expects(:ask).with("GitHub login: ").never
+    HighLine.any_instance.expects(:ask).with("GitHub password: ").returns "p"
+    preflight.send(:fetch_login_and_password)
+
+    assert_equal "l", @config.login
+    assert_equal "p", preflight.instance_variable_get(:@password)
+  end
+
+  def test_fetch_login_when_password_is_given_in_env
+    # fetches only login by asking
+    ENV["BOXEN_GITHUB_PASSWORD"] = "p"
+    preflight = Boxen::Preflight::Creds.new @config
+    preflight.expects(:warn)
+    HighLine.any_instance.expects(:ask).with("GitHub login: ").returns "l"
+    HighLine.any_instance.expects(:ask).with("GitHub password: ").never
+    preflight.send(:fetch_login_and_password)
+
+    assert_equal "l", @config.login
+    assert_equal "p", preflight.instance_variable_get(:@password)
+  end
+
+  def test_run_with_existing_token
+    preflight = Boxen::Preflight::Creds.new @config
+    note = "App1"
+    fingerprint = "Fingerprint1"
+    existing_token = Struct::Authorization.new(1, note, fingerprint, "Token1")
+
+    preflight.stubs(:fetch_login_and_password).returns("")
+    preflight.stubs(:get_tokens).returns([existing_token])
+    preflight.stubs(:note).returns(note)
+    preflight.stubs(:fingerprint).returns(fingerprint)
+    preflight.stubs(:ok?).returns(true)
+    preflight.tmp_api.expects(:delete_authorization).with(existing_token.id, :headers => {})
+    preflight.tmp_api.expects(:create_authorization).with(
+      :note => note,
+      :fingerprint => fingerprint,
+      :scopes => %w(repo user),
+      :headers => {}
+    ).returns(existing_token)
+
+    preflight.run
+  end
+
+  def test_run_with_no_existing_token
+    preflight = Boxen::Preflight::Creds.new @config
+    note = "App1"
+    fingerprint = "Fingerprint1"
+    new_token = Struct::Authorization.new(1, note, fingerprint, "Token1")
+
+    preflight.stubs(:fetch_login_and_password).returns("")
+    preflight.stubs(:get_tokens).returns([])
+    preflight.stubs(:note).returns(note)
+    preflight.stubs(:fingerprint).returns(fingerprint)
+    preflight.stubs(:ok?).returns(true)
+    preflight.tmp_api.expects(:delete_authorization).never
+    preflight.tmp_api.expects(:create_authorization).with(
+      :note => note,
+      :fingerprint => fingerprint,
+      :scopes => %w(repo user),
+      :headers => {}
+    ).returns(new_token)
+
+    preflight.run
+  end
+
+  def test_run_does_not_delete_unrelated_tokens
+    preflight = Boxen::Preflight::Creds.new @config
+    note = "App1"
+    fingerprint = "Fingerprint1"
+    new_token = Struct::Authorization.new(1, note, fingerprint, "Token1")
+    unrelated_token = Struct::Authorization.new(2, "App2", fingerprint, "Token2")
+    unrelated_token_with_fingerprint = Struct::Authorization.new(3, "App3", "Fingerprint3", "Token3")
+
+    preflight.stubs(:fetch_login_and_password).returns("")
+    preflight.stubs(:get_tokens).returns(
+      [unrelated_token, unrelated_token_with_fingerprint]
+    )
+    preflight.stubs(:note).returns(note)
+    preflight.stubs(:fingerprint).returns(fingerprint)
+    preflight.stubs(:ok?).returns(true)
+    preflight.tmp_api.expects(:delete_authorization).never
+    preflight.tmp_api.expects(:create_authorization).with(
+      :note => note,
+      :fingerprint => fingerprint,
+      :scopes => %w(repo user),
+      :headers => {}
+    ).returns(new_token)
+
+    preflight.run
+  end
+
+  def test_run_does_delete_legacy_token
+    preflight = Boxen::Preflight::Creds.new @config
+    note = "App1"
+    fingerprint = "Fingerprint1"
+    existing_token = Struct::Authorization.new(1, note, fingerprint, "Token1")
+    legacy_token = Struct::Authorization.new(2, "Boxen", nil, "Token2")
+
+    preflight.stubs(:fetch_login_and_password).returns("")
+    preflight.stubs(:get_tokens).returns([existing_token, legacy_token])
+    preflight.stubs(:note).returns(note)
+    preflight.stubs(:fingerprint).returns(fingerprint)
+    preflight.stubs(:ok?).returns(true)
+    preflight.tmp_api.expects(:delete_authorization).with(2, :headers => {})
+    preflight.tmp_api.expects(:delete_authorization).with(1, :headers => {})
+    preflight.tmp_api.expects(:create_authorization).with(
+      :note => note,
+      :fingerprint => fingerprint,
+      :scopes => %w(repo user),
+      :headers => {}
+    ).returns(existing_token)
+
+    preflight.run
+  end
+end

data/test/boxen_preflight_etc_my_cnf_test.rb

@@ -0,0 +1,10 @@
+require 'boxen/test'
+require 'boxen/preflight/etc_my_cnf'
+
+class BoxenPreflightEtcMyCnfTest < Boxen::Test
+  def test_file_check
+    preflight = Boxen::Preflight::EtcMyCnf.new(mock('config'))
+    File.expects(:file?).with("/etc/my.cnf").returns(false)
+    assert preflight.ok?
+  end
+end

data/test/boxen_preflight_rvm_test.rb

@@ -0,0 +1,10 @@
+require 'boxen/test'
+require 'boxen/preflight/rvm'
+
+class BoxenPreflightRVMTest < Boxen::Test
+  def test_directory_check
+    preflight = Boxen::Preflight::RVM.new(mock('config'))
+    File.expects(:exist?).with("#{ENV['HOME']}/.rvm").returns(false)
+    assert preflight.ok?
+  end
+end

data/test/boxen_project_test.rb

@@ -0,0 +1,14 @@
+require "boxen/test"
+require "boxen/project"
+
+class BoxenProjectTest < Boxen::Test
+  def test_initialize
+    project = Boxen::Project.new "foo"
+    assert_equal "foo", project.dir
+  end
+
+  def test_name
+    project = Boxen::Project.new "foo/bar/baz"
+    assert_equal "baz", project.name
+  end
+end

data/test/boxen_puppeteer_test.rb

@@ -0,0 +1,101 @@
+require "boxen/test"
+require "boxen/puppeteer"
+
+class BoxenPuppeteerTest < Boxen::Test
+  def test_initialize
+    puppet = Boxen::Puppeteer.new :config
+    assert_equal :config, puppet.config
+  end
+
+  def test_flags
+    config = stub do
+      stubs(:homedir).returns "homedir"
+      stubs(:logfile).returns "logfile"
+      stubs(:profile?).returns true
+      stubs(:future_parser?).returns true
+      stubs(:puppetdir).returns "puppetdir"
+      stubs(:repodir).returns "repodir"
+      stubs(:debug?).returns true
+      stubs(:pretend?).returns true
+      stubs(:report?).returns false
+      stubs(:graph?).returns false
+      stubs(:color?).returns false
+    end
+
+    puppet = Boxen::Puppeteer.new config
+    flags  = puppet.flags
+
+    assert_flag "--debug", flags
+    assert_flag "--detailed-exitcodes", flags
+    assert_flag "--evaltrace", flags
+    assert_flag "--no-report", flags
+    assert_flag "--noop", flags
+    assert_flag "--summarize", flags
+    assert_flag "--color=false", flags
+    assert_flag "--parser=future", flags
+
+    assert_flag_value "--confdir", :anything, flags
+    assert_flag_value "--group", "admin", flags
+    assert_flag_value "--vardir", :anything, flags
+    assert_flag_value "--libdir", :anything, flags
+    assert_flag_value "--manifestdir", :anything, flags
+    assert_flag_value "--modulepath", :anything, flags
+
+    assert_flag_value "--hiera_config", "/dev/null", flags
+
+    assert_flag_value "--logdest", "logfile", flags
+    assert_flag_value "--logdest", "console", flags
+  end
+
+  def test_run
+    config = stub do
+      stubs(:debug?).returns false
+      stubs(:homedir).returns "homedir"
+      stubs(:logfile).returns "logfile"
+      stubs(:pretend?).returns false
+      stubs(:profile?).returns false
+      stubs(:future_parser?).returns false
+      stubs(:report?).returns false
+      stubs(:graph?).returns false
+      stubs(:puppetdir).returns "puppetdir"
+      stubs(:repodir).returns "test/fixtures/repo"
+      stubs(:color?).returns true
+    end
+
+    puppet = Boxen::Puppeteer.new config
+
+    FileUtils.expects(:rm_f).with config.logfile
+    FileUtils.expects(:touch).with config.logfile
+    FileUtils.expects(:mkdir_p).with File.dirname(config.logfile)
+    FileUtils.expects(:mkdir_p).with config.puppetdir
+    Boxen::Util.expects(:sudo).with *puppet.command
+
+    puppet.run
+  end
+
+  def assert_flag(flag, flags)
+    assert flags.include?(flag), "Flags must include #{flag}."
+  end
+
+  def assert_flag_value(flag, value, flags)
+    pair = [flag, value]
+
+    found = (0..flags.size).detect do |i|
+      candidate = flags[i, pair.size]
+      value == :anything ? candidate.size == pair.size : candidate == pair
+    end
+
+    assert found, "Flags must include #{flag} #{value}."
+  end
+
+  def test_status
+    status = Boxen::Puppeteer::Status.new(0)
+    assert status.success?
+
+    status = Boxen::Puppeteer::Status.new(2)
+    assert status.success?
+
+    status = Boxen::Puppeteer::Status.new(1)
+    refute status.success?
+  end
+end

data/test/boxen_runner_test.rb

@@ -0,0 +1,171 @@
+require "boxen/test"
+require "boxen/runner"
+
+class BoxenRunnerTest < Boxen::Test
+  def setup
+    @config = Boxen::Config.new
+    @flags  = Boxen::Flags.new
+    @runner = Boxen::Runner.new(@config, @flags)
+
+    $stdout.stubs(:puts).returns(true)
+    $stdout.stubs(:write).returns(true)
+  end
+
+  def test_initialize
+    config = Boxen::Config.new
+    flags  = Boxen::Flags.new
+
+    runner = Boxen::Runner.new(config, flags)
+
+    assert_equal config, runner.config
+    assert_equal flags,  runner.flags
+    assert_equal config, runner.puppet.config
+  end
+
+  HookYes = Struct.new(:config, :checkout, :puppet, :result)
+  HookNo  = Struct.new(:config, :checkout, :puppet, :result)
+  def test_report
+    runner = Boxen::Runner.new(@config, @flags)
+    runner.stubs(:hooks).returns([HookYes, HookNo])
+
+    hook_yes = stub('HookYes')
+    hook_no  = stub('HookNo')
+
+    HookYes.stubs(:new).returns(hook_yes)
+    HookNo.stubs(:new).returns(hook_no)
+
+    hook_yes.expects(:run).once
+    hook_no.expects(:run).once
+
+    runner.report(stub('result'))
+  end
+
+  def test_disable_service
+    config = Boxen::Config.new
+    flags  = Boxen::Flags.new('--disable-service', 'test')
+    runner = Boxen::Runner.new config, flags
+
+    service = mock('service', :disable => true)
+    Boxen::Service.stubs(:new).returns(service)
+
+    assert_raises(SystemExit) do
+      runner.process
+    end
+  end
+
+  def test_enable_service
+    config = Boxen::Config.new
+    flags  = Boxen::Flags.new('--enable-service', 'test')
+    runner = Boxen::Runner.new config, flags
+
+    service = mock('service', :enable => true)
+    Boxen::Service.stubs(:new).returns(service)
+
+    assert_raises(SystemExit) do
+      runner.process
+    end
+  end
+
+  def test_restart_service
+    config = Boxen::Config.new
+    flags  = Boxen::Flags.new('--restart-service', 'test')
+    runner = Boxen::Runner.new config, flags
+
+    service = mock('service')
+    service.expects(:disable).once
+    service.expects(:enable).once
+
+    Boxen::Service.stubs(:new).returns(service)
+
+    assert_raises(SystemExit) do
+      runner.process
+    end
+  end
+
+  def test_disable_services
+    config = Boxen::Config.new
+    flags  = Boxen::Flags.new('--disable-services')
+    runner = Boxen::Runner.new config, flags
+
+    services = Array.new(3) { mock('service', :disable => true) }
+    Boxen::Service.stubs(:list).returns(services)
+
+    assert_raises(SystemExit) do
+      runner.process
+    end
+  end
+
+  def test_enable_services
+    config = Boxen::Config.new
+    flags  = Boxen::Flags.new('--enable-services')
+    runner = Boxen::Runner.new config, flags
+
+    services = Array.new(3) { mock('service', :enable => true) }
+    Boxen::Service.stubs(:list).returns(services)
+
+    assert_raises(SystemExit) do
+      runner.process
+    end
+  end
+
+  def test_restart_services
+    config = Boxen::Config.new
+    flags  = Boxen::Flags.new('--restart-services')
+    runner = Boxen::Runner.new config, flags
+
+    services = Array.new(3) { mock('service') }
+    services.each do |service|
+      service.expects(:disable).once
+      service.expects(:enable).once
+    end
+    Boxen::Service.stubs(:list_enabled).returns(services)
+
+    assert_raises(SystemExit) do
+      runner.process
+    end
+  end
+
+  def test_list_services
+    config = Boxen::Config.new
+    flags  = Boxen::Flags.new('--list-services')
+    runner = Boxen::Runner.new config, flags
+
+    Boxen::Service.expects(:list).returns(%w[a list of services])
+
+    assert_raises(SystemExit) do
+      runner.process
+    end
+  end
+
+  def test_specify_project
+    skip "busted and probably due to be replaced if @jbarnette can fix it"
+    fact = 'cli_boxen_projects'
+    refute Facter.value(fact)
+
+    project = 'some_project'
+    flags   = Boxen::Flags.new(project)
+
+    runner = Boxen::Runner.new(@config, flags)
+    runner.puppet.expects(:run).with().returns(true)
+    runner.process
+    assert_equal project, Facter.value(fact)
+
+
+    project = 'other_project'
+    flags   = Boxen::Flags.new('--debug', project)
+
+    runner = Boxen::Runner.new(@config, flags)
+    runner.puppet.expects(:run).with().returns(true)
+    runner.process
+    assert_equal project, Facter.value(fact)
+
+
+    projects = %w[my cool projects]
+    flags    = Boxen::Flags.new('--noop', *projects)
+
+    runner = Boxen::Runner.new(@config, flags)
+    runner.puppet.expects(:run).with().returns(true)
+    runner.process
+    assert_equal projects.join(','), Facter.value(fact)
+  end
+end