boxen 3.0.0.beta1 → 3.1.0

data/test/{postflight/boxen_postflight_web_hook_test.rb → boxen_hook_web_test.rb}

@@ -1,18 +1,17 @@
-require 'boxen/test'
-require 'boxen/postflight'
-require 'boxen/postflight/web_hook'
+require "boxen/test"
+require "boxen/hook/web"
 
 class Boxen::Config
   attr_writer :api
 end
 
-class BoxenPostflightWebHookTest < Boxen::Test
+class BoxenHookWebTest < Boxen::Test
   def setup
     @config   = Boxen::Config.new
     @checkout = Boxen::Checkout.new(@config)
-    @command  = stub 'command', :success? => true
-    @hook = Boxen::Postflight::WebHook.new @config, @command
-    @hook.checkout = @checkout
+    @puppet   = mock 'puppeteer'
+    @result   = stub 'result', :success? => true
+    @hook = Boxen::Hook::Web.new @config, @checkout, @puppet, @result
   end
 
   def test_enabled
@@ -30,18 +29,18 @@ class BoxenPostflightWebHookTest < Boxen::Test
     ENV['BOXEN_WEB_HOOK_URL'] = original
   end
 
-  def test_ok
+  def test_perform
     @hook.stubs(:enabled?).returns(false)
-    assert @hook.ok?
+    refute @hook.perform?
 
     @hook.stubs(:enabled?).returns(true)
-    refute @hook.ok?
+    assert @hook.perform?
   end
 
   def test_run
     @config.stubs(:user).returns('fred')
     @checkout.stubs(:sha).returns('87dbag3')
-    @command.stubs(:success?).returns(false)
+    @result.stubs(:success?).returns(false)
     now = Time.now
     Time.stubs(:now).returns(now)
 
@@ -56,4 +55,4 @@ class BoxenPostflightWebHookTest < Boxen::Test
 
     @hook.run
   end
-end
+end

data/test/{postflight/boxen_postflight_active_test.rb → boxen_postflight_active_test.rb}

@@ -3,7 +3,7 @@ require "boxen/postflight"
 
 class BoxenPostflightActiveTest < Boxen::Test
   def setup
-    @check = Boxen::Postflight::Active.new :config, :command
+    @check = Boxen::Postflight::Active.new :config
   end
 
   def test_ok?
@@ -18,9 +18,9 @@ class BoxenPostflightActiveTest < Boxen::Test
 
   def test_run
     config = stub :envfile => "foo"
-    @check = Boxen::Postflight::Active.new config, :command
+    @check = Boxen::Postflight::Active.new config
 
-    _, stderr = capture_io do
+    stdout, stderr = capture_io do
       @check.run
     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/{preflight/boxen_preflight_etc_my_cnf_test.rb → boxen_preflight_etc_my_cnf_test.rb}

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

data/test/{preflight/boxen_preflight_rvm_test.rb → boxen_preflight_rvm_test.rb}

@@ -3,7 +3,7 @@ require 'boxen/preflight/rvm'
 
 class BoxenPreflightRVMTest < Boxen::Test
   def test_directory_check
-    preflight = Boxen::Preflight::RVM.new(mock('config'), mock('command'))
+    preflight = Boxen::Preflight::RVM.new(mock('config'))
     File.expects(:exist?).with("#{ENV['HOME']}/.rvm").returns(false)
     assert preflight.ok?
   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