boxen 2.9.0 → 3.0.0.beta1

data/test/command/help_test.rb

@@ -0,0 +1,49 @@
+require "boxen/command/help"
+
+class FooBar
+  def self.detailed_help
+    "okay fine I'll help you"
+  end
+
+  def self.help
+    "help yourself"
+  end
+end
+
+class BarBaz
+  def self.help
+    "no you"
+  end
+end
+
+describe Boxen::Command::Help do
+  before do
+    @config = mock("config")
+
+    Boxen::Command.reset!
+    Boxen::Command.register :foo_bar, FooBar
+    Boxen::Command.register :bar_baz, BarBaz
+    Boxen::Command.register :help, Boxen::Command::Help
+  end
+
+  after do
+    Boxen::Command.reset!
+  end
+
+  it "can write help for all commands" do
+    stdout, _ = capture_io do
+      Boxen::Command.invoke(:help, @config)
+    end
+
+    assert_match "    foo_bar          help yourself", stdout
+    assert_match "    bar_baz          no you", stdout
+  end
+
+  it "can write detailed help for a single command" do
+    stdout, _ = capture_io do
+      Boxen::Command.invoke(:help, @config, "foo_bar")
+    end
+
+    assert_match "okay fine I'll help you", stdout
+  end
+end

data/test/command/project/install_test.rb

@@ -0,0 +1,34 @@
+require "boxen/command/project/install"
+require "tmpdir"
+
+describe Boxen::Command::Project::Install do
+  before do
+    @config = mock("config")
+  end
+
+  describe "#run" do
+    before do
+      Boxen::Command.expects(:invoke).with('run', @config)
+    end
+
+    it "installs a single project" do
+      Dir.mktmpdir { |dir|
+        @config.stubs(:repodir).returns(dir)
+        Boxen::Command::Project::Install.new(@config, 'awesome-project').run
+
+        projects = File.read("#{dir}/.projects")
+        assert_equal projects, "awesome-project"
+      }
+    end
+
+    it "installs multiple projects" do
+      Dir.mktmpdir { |dir|
+        @config.stubs(:repodir).returns(dir)
+        Boxen::Command::Project::Install.new(@config, 'awesome-project', 'better-project').run
+
+        projects = File.read("#{dir}/.projects")
+        assert_equal projects, "awesome-project,better-project"
+      }
+    end
+  end
+end

data/test/command/project_test.rb

@@ -0,0 +1,32 @@
+require "boxen/command/project"
+
+describe Boxen::Command::Project do
+  before do
+    @config = mock("config")
+  end
+
+  describe "#run" do
+    before do
+      @config.stubs(:projects).returns([
+        mock("project-a", :name => "puppet-boxen"),
+        mock("project-b", :name => "puppet-ruby")
+      ])
+    end
+
+    it "displays the projects we know about" do
+      stdout, _ = capture_io do
+        Boxen::Command::Project.new(@config).run
+      end
+
+      assert_equal stdout, <<-EOS
+Boxen knows about the following projects:
+
+    puppet-boxen
+    puppet-ruby
+
+You can install any of them by running \"boxen project:install <project>\"
+
+EOS
+    end
+  end
+end

data/test/command/run_test.rb

@@ -0,0 +1,21 @@
+require "boxen/command/run"
+
+describe Boxen::Command::Run do
+  before do
+    @config = mock("config")
+  end
+
+  it "should enable puppet reports" do
+    command = Boxen::Command::Run.new(@config, "--report")
+    assert command.report?
+  end
+  it "should enable puppet profiling" do
+    command = Boxen::Command::Run.new(@config, "--profile")
+    assert command.profile?
+  end
+
+  it "should enable puppet's future parser" do
+    command = Boxen::Command::Run.new(@config, "--future-parser")
+    assert command.future_parser?
+  end
+end

data/test/command/service/disable_test.rb

@@ -0,0 +1,49 @@
+require "boxen/command/service/disable"
+
+describe Boxen::Command::Service::Disable do
+  describe "given arguments" do
+    before do
+      @config = mock("config")
+      @single_c_thread = mock("service",
+                              :name    => "single_c_thread",
+                              :disable => true)
+
+      Boxen::Service.stubs(:new).with("single_c_thread").returns(@single_c_thread)
+    end
+
+    it "should disable the service" do
+      stdout, _ = capture_io do
+        Boxen::Command::Service::Disable.new(@config, "single_c_thread").run
+      end
+
+      assert_equal stdout, "Disabling service: single_c_thread\n"
+    end
+  end
+
+  describe "given no arguments" do
+    before do
+      @config = mock("config")
+      @single_c_thread = mock("service",
+                              :name    => "single_c_thread",
+                              :disable => true)
+
+      @many_pthreads = mock("service",
+                            :name    => "many_pthreads",
+                            :disable => true)
+
+      Boxen::Service.stubs(:list).
+        returns([@single_c_thread, @many_pthreads])
+    end
+
+    it "should enable all services" do
+      stdout, _ = capture_io do
+        Boxen::Command::Service::Disable.new(@config).run
+      end
+
+      assert_equal stdout, <<-EOS
+Disabling service: single_c_thread
+Disabling service: many_pthreads
+EOS
+    end
+  end
+end

data/test/command/service/enable_test.rb

@@ -0,0 +1,49 @@
+require "boxen/command/service/enable"
+
+describe Boxen::Command::Service::Enable do
+  describe "given arguments" do
+    before do
+      @config = mock("config")
+      @single_c_thread = mock("service",
+                              :name   => "single_c_thread",
+                              :enable => true)
+
+      Boxen::Service.stubs(:new).with("single_c_thread").returns(@single_c_thread)
+    end
+
+    it "should enable the service" do
+      stdout, _ = capture_io do
+        Boxen::Command::Service::Enable.new(@config, "single_c_thread").run
+      end
+
+      assert_equal stdout, "Enabling service: single_c_thread\n"
+    end
+  end
+
+  describe "given no arguments" do
+    before do
+      @config = mock("config")
+      @single_c_thread = mock("service",
+                              :name   => "single_c_thread",
+                              :enable => true)
+
+      @many_pthreads = mock("service",
+                            :name   => "many_pthreads",
+                            :enable => true)
+
+      Boxen::Service.stubs(:list).
+        returns([@single_c_thread, @many_pthreads])
+    end
+
+    it "should enable all services" do
+      stdout, _ = capture_io do
+        Boxen::Command::Service::Enable.new(@config).run
+      end
+
+      assert_equal stdout, <<-EOS
+Enabling service: single_c_thread
+Enabling service: many_pthreads
+EOS
+    end
+  end
+end

data/test/command/service/restart_test.rb

@@ -0,0 +1,53 @@
+require "boxen/command/service/restart"
+
+
+describe Boxen::Command::Service::Restart do
+  describe "with args" do
+    before do
+      @config = mock("config")
+      @single_c_thread = mock("service",
+                              :name    => "single_c_thread",
+                              :enable  => true,
+                              :disable => true)
+
+      Boxen::Service.stubs(:new).with("single_c_thread").returns(@single_c_thread)
+    end
+
+    it "should restart the service" do
+      stdout, _ = capture_io do
+        Boxen::Command::Service::Restart.new(@config, "single_c_thread").run
+      end
+
+      assert_equal stdout, "Restarting service: single_c_thread\n"
+    end
+  end
+
+  describe "without args" do
+    before do
+      @config = mock("config")
+      @single_c_thread = mock("service",
+                              :name    => "single_c_thread",
+                              :enable  => true,
+                              :disable => true)
+
+      @many_pthreads = mock("service",
+                            :name    => "many_pthreads",
+                            :enable  => true,
+                            :disable => true)
+
+      Boxen::Service.stubs(:list_enabled).
+        returns([@single_c_thread, @many_pthreads])
+    end
+
+    it "should enable all services" do
+      stdout, _ = capture_io do
+        Boxen::Command::Service::Restart.new(@config).run
+      end
+
+      assert_equal stdout, <<-EOS
+Restarting service: single_c_thread
+Restarting service: many_pthreads
+EOS
+    end
+  end
+end

data/test/command/service_test.rb

@@ -0,0 +1,55 @@
+require "boxen/command/service"
+
+describe Boxen::Command::Service do
+  before do
+    @config = Minitest::Mock.new
+  end
+
+  describe "#run" do
+    before do
+      Boxen::Service.stubs(:list).returns([
+                                           mock("service", :name => "foo"),
+                                           mock("service", :name => "bar")
+                                          ])
+    end
+
+    it "displays the list of services we know about" do
+      stdout, _ = capture_io do
+        Boxen::Command::Service.new(@config).run
+      end
+
+      assert_equal stdout, <<-EOS
+Boxen manages the following services:
+
+    foo
+    bar
+EOS
+    end
+  end
+
+  describe "#services" do
+    before do
+      @foobar = mock()
+    end
+
+    describe "given args" do
+      before do
+        Boxen::Service.stubs(:new).with("foobar").returns(@foobar)
+      end
+
+      it "collects services based on args" do
+        assert_equal [@foobar], Boxen::Command::Service.new(@config, "foobar").services
+      end
+    end
+
+    describe "given no args" do
+      before do
+        Boxen::Service.stubs(:list).returns([@foobar])
+      end
+
+      it "collects all services" do
+        assert_equal [@foobar], Boxen::Command::Service.new(@config).services
+      end
+    end
+  end
+end

data/test/command/version_test.rb

@@ -0,0 +1,15 @@
+require "boxen/command/version"
+
+describe Boxen::Command::Version do
+  let(:instance) { Boxen::Command::Version.new(mock("config")) }
+
+  it "writes the boxen version to standard out, duh" do
+    instance.stubs(:version).returns("100.0.0")
+
+    stdout, _ = capture_io do
+      instance.run
+    end
+
+    assert_match "Boxen 100.0.0", stdout
+  end
+end

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

@@ -3,7 +3,7 @@ require "boxen/postflight"
 
 class BoxenPostflightActiveTest < Boxen::Test
   def setup
-    @check = Boxen::Postflight::Active.new :config
+    @check = Boxen::Postflight::Active.new :config, :command
   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
+    @check = Boxen::Postflight::Active.new config, :command
 
-    stdout, stderr = capture_io do
+    _, stderr = capture_io do
       @check.run
     end
 

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

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