shipit-engine 0.5.2 → 0.6.0

data/test/helpers/fixture_aliases_helper.rb

@@ -1,9 +1,9 @@
 module FixtureAliasesHelper
-  def deploys(*args)
-    tasks(*args)
+  def shipit_deploys(*args)
+    shipit_tasks(*args)
   end
 
-  def rollbacks(*args)
-    tasks(*args)
+  def shipit_rollbacks(*args)
+    shipit_tasks(*args)
   end
 end

data/test/jobs/cache_deploy_spec_job_test.rb

@@ -1,21 +1,23 @@
 require 'test_helper'
 require 'tmpdir'
 
-class CacheDeploySpecJobTest < ActiveSupport::TestCase
-  setup do
-    @stack = stacks(:shipit)
-    @last_commit = commits(:fifth)
-    @job = CacheDeploySpecJob.new
-  end
+module Shipit
+  class CacheDeploySpecJobTest < ActiveSupport::TestCase
+    setup do
+      @stack = shipit_stacks(:shipit)
+      @last_commit = shipit_commits(:fifth)
+      @job = CacheDeploySpecJob.new
+    end
 
-  test "#perform checkout the repository to the last recorded commit and cache the deploy spec" do
-    @stack.update!(cached_deploy_spec: DeploySpec.new('review' => {'checklist' => %w(foo bar)}))
+    test "#perform checkout the repository to the last recorded commit and cache the deploy spec" do
+      @stack.update!(cached_deploy_spec: DeploySpec.new('review' => {'checklist' => %w(foo bar)}))
 
-    dir = Pathname(Dir.tmpdir)
-    StackCommands.any_instance.expects(:with_temporary_working_directory).with(commit: @last_commit).yields(dir)
+      dir = Pathname(Dir.tmpdir)
+      StackCommands.any_instance.expects(:with_temporary_working_directory).with(commit: @last_commit).yields(dir)
 
-    assert_equal %w(foo bar), @stack.checklist
-    @job.perform(@stack)
-    assert_equal [], @stack.reload.checklist
+      assert_equal %w(foo bar), @stack.checklist
+      @job.perform(@stack)
+      assert_equal [], @stack.reload.checklist
+    end
   end
 end

data/test/jobs/chunk_rollup_job_test.rb

@@ -1,41 +1,43 @@
 require 'test_helper'
 
-class ChunkRollupJobTest < ActiveSupport::TestCase
-  setup do
-    @task = tasks(:shipit)
-    @job = ChunkRollupJob.new
-  end
+module Shipit
+  class ChunkRollupJobTest < ActiveSupport::TestCase
+    setup do
+      @task = shipit_tasks(:shipit)
+      @job = ChunkRollupJob.new
+    end
 
-  test "#perform combines all the chunks into a output and sets rolled_up to true" do
-    expected_output = @task.chunk_output
-    assert @task.output.blank?
+    test "#perform combines all the chunks into a output and sets rolled_up to true" do
+      expected_output = @task.chunk_output
+      assert @task.output.blank?
 
-    @job.perform(@task)
+      @job.perform(@task)
 
-    @task.reload
-    assert_equal 0, @task.chunks.count
-    assert @task.output.present?
-    assert_equal expected_output, @task.chunk_output
-    assert @task.rolled_up
-  end
+      @task.reload
+      assert_equal 0, @task.chunks.count
+      assert @task.output.present?
+      assert_equal expected_output, @task.chunk_output
+      assert @task.rolled_up
+    end
 
-  test "#peform ignores non-finished jobs" do
-    logger = mock
-    logger.expects(:error).once
-    @job.stubs(logger: logger)
+    test "#peform ignores non-finished jobs" do
+      logger = mock
+      logger.expects(:error).once
+      @job.stubs(logger: logger)
 
-    @task.update_attribute(:status, :pending)
+      @task.update_attribute(:status, :pending)
 
-    @job.perform(@task)
-  end
+      @job.perform(@task)
+    end
 
-  test "#perform ignores tasks already rolled up" do
-    logger = mock
-    logger.expects(:error).once
-    @job.stubs(logger: logger)
+    test "#perform ignores tasks already rolled up" do
+      logger = mock
+      logger.expects(:error).once
+      @job.stubs(logger: logger)
 
-    @task.rolled_up = true
+      @task.rolled_up = true
 
-    @job.perform(@task)
+      @job.perform(@task)
+    end
   end
 end

data/test/jobs/deliver_hook_job_test.rb

@@ -1,14 +1,16 @@
 require 'test_helper'
 
-class DeliverHookJobTest < ActiveSupport::TestCase
-  setup do
-    @delivery = deliveries(:scheduled_shipit_deploy)
-    @job = DeliverHookJob.new
-  end
+module Shipit
+  class DeliverHookJobTest < ActiveSupport::TestCase
+    setup do
+      @delivery = shipit_deliveries(:scheduled_shipit_deploy)
+      @job = DeliverHookJob.new
+    end
 
-  test "#perform delivers a delivery" do
-    FakeWeb.register_uri(:post, @delivery.url, body: 'OK')
-    @job.perform(@delivery)
-    assert_equal 'sent', @delivery.reload.status
+    test "#perform delivers a delivery" do
+      FakeWeb.register_uri(:post, @delivery.url, body: 'OK')
+      @job.perform(@delivery)
+      assert_equal 'sent', @delivery.reload.status
+    end
   end
 end

data/test/jobs/destroy_stack_job_test.rb

@@ -1,16 +1,18 @@
 require 'test_helper'
 
-class DestroyStackJobTest < ActiveSupport::TestCase
-  setup do
-    @job = DestroyStackJob.new
-    @stack = Stack.first
-  end
+module Shipit
+  class DestroyStackJobTest < ActiveSupport::TestCase
+    setup do
+      @job = DestroyStackJob.new
+      @stack = Stack.first
+    end
 
-  test "perform destroys the received stack" do
-    Shipit.github_api.expects(:remove_hook).times(@stack.github_hooks.count)
+    test "perform destroys the received stack" do
+      Shipit.github_api.expects(:remove_hook).times(@stack.github_hooks.count)
 
-    assert_difference -> { Stack.count }, -1 do
-      @job.perform(@stack)
+      assert_difference -> { Stack.count }, -1 do
+        @job.perform(@stack)
+      end
     end
   end
 end

data/test/jobs/emit_event_job_test.rb

@@ -1,14 +1,16 @@
 require 'test_helper'
 
-class EmitEventJobTest < ActiveSupport::TestCase
-  setup do
-    @stack = stacks(:shipit)
-    @job = EmitEventJob.new
-  end
+module Shipit
+  class EmitEventJobTest < ActiveSupport::TestCase
+    setup do
+      @stack = shipit_stacks(:shipit)
+      @job = EmitEventJob.new
+    end
 
-  test "#perform schedule deliveries" do
-    assert_difference -> { Delivery.scheduled.count }, 2 do
-      @job.perform(event: :deploy, stack_id: @stack.id, payload: {foo: 42}.to_json)
+    test "#perform schedule deliveries" do
+      assert_difference -> { Delivery.scheduled.count }, 2 do
+        @job.perform(event: :deploy, stack_id: @stack.id, payload: {foo: 42}.to_json)
+      end
     end
   end
 end

data/test/jobs/fetch_commit_stats_job_test.rb

@@ -1,13 +1,15 @@
 require 'test_helper'
 
-class FetchCommitStatsJobTest < ActiveSupport::TestCase
-  setup do
-    @commit = commits(:first)
-    @job = FetchCommitStatsJob.new
-  end
+module Shipit
+  class FetchCommitStatsJobTest < ActiveSupport::TestCase
+    setup do
+      @commit = shipit_commits(:first)
+      @job = FetchCommitStatsJob.new
+    end
 
-  test "#perform call #fetch_stats! on the provided commit" do
-    @commit.expects(:fetch_stats!).once
-    @job.perform(@commit)
+    test "#perform call #fetch_stats! on the provided commit" do
+      @commit.expects(:fetch_stats!).once
+      @job.perform(@commit)
+    end
   end
 end

data/test/jobs/fetch_deployed_revision_job_test.rb

@@ -1,30 +1,32 @@
 require 'test_helper'
 
-class FetchDeployedRevisionJobTest < ActiveSupport::TestCase
-  setup do
-    @stack = stacks(:shipit)
-    @job = FetchDeployedRevisionJob.new
-    @commit = commits(:fifth)
-  end
+module Shipit
+  class FetchDeployedRevisionJobTest < ActiveSupport::TestCase
+    setup do
+      @stack = shipit_stacks(:shipit)
+      @job = FetchDeployedRevisionJob.new
+      @commit = shipit_commits(:fifth)
+    end
 
-  test 'the job abort if the stack is deploying' do
-    @stack.expects(:deploying?).returns(true)
-    assert_no_difference 'Deploy.count' do
-      @job.perform(@stack)
+    test 'the job abort if the stack is deploying' do
+      @stack.expects(:deploying?).returns(true)
+      assert_no_difference 'Deploy.count' do
+        @job.perform(@stack)
+      end
     end
-  end
 
-  test 'the job abort if #fetch_deployed_revision returns nil' do
-    @stack.expects(:deploying?).returns(false)
-    StackCommands.any_instance.expects(:fetch_deployed_revision).returns(nil)
-    @stack.expects(:update_deployed_revision).never
-    @job.perform(@stack)
-  end
+    test 'the job abort if #fetch_deployed_revision returns nil' do
+      @stack.expects(:deploying?).returns(false)
+      StackCommands.any_instance.expects(:fetch_deployed_revision).returns(nil)
+      @stack.expects(:update_deployed_revision).never
+      @job.perform(@stack)
+    end
 
-  test 'the job call update_deployed_revision if #fetch_deployed_revision returns something' do
-    @stack.expects(:deploying?).returns(false)
-    StackCommands.any_instance.expects(:fetch_deployed_revision).returns(@commit.sha)
-    @stack.expects(:update_deployed_revision).with(@commit.sha)
-    @job.perform(@stack)
+    test 'the job call update_deployed_revision if #fetch_deployed_revision returns something' do
+      @stack.expects(:deploying?).returns(false)
+      StackCommands.any_instance.expects(:fetch_deployed_revision).returns(@commit.sha)
+      @stack.expects(:update_deployed_revision).with(@commit.sha)
+      @job.perform(@stack)
+    end
   end
 end

data/test/jobs/github_sync_job_test.rb

@@ -1,67 +1,69 @@
 require 'test_helper'
 
-class GithubSyncJobTest < ActiveSupport::TestCase
-  setup do
-    @job = GithubSyncJob.new
-    @stack = stacks(:shipit)
-    @github_commits = stub
-  end
+module Shipit
+  class GithubSyncJobTest < ActiveSupport::TestCase
+    setup do
+      @job = GithubSyncJob.new
+      @stack = shipit_stacks(:shipit)
+      @github_commits = stub
+    end
 
-  test "#perform fetch commits from the API" do
-    Stack.any_instance.expects(:github_commits).returns(@github_commits)
-    @job.expects(:fetch_missing_commits).yields.returns([[], nil])
-    @job.perform(stack_id: @stack.id)
-  end
+    test "#perform fetch commits from the API" do
+      Stack.any_instance.expects(:github_commits).returns(@github_commits)
+      @job.expects(:fetch_missing_commits).yields.returns([[], nil])
+      @job.perform(stack_id: @stack.id)
+    end
 
-  test "#perform finally enqueue a CacheDeploySpecJob" do
-    Stack.any_instance.stubs(:github_commits).returns(@github_commits)
-    @job.stubs(:fetch_missing_commits).yields.returns([[], nil])
+    test "#perform finally enqueue a CacheDeploySpecJob" do
+      Stack.any_instance.stubs(:github_commits).returns(@github_commits)
+      @job.stubs(:fetch_missing_commits).yields.returns([[], nil])
 
-    assert_enqueued_with(job: CacheDeploySpecJob, args: [@stack]) do
-      @job.perform(stack_id: @stack.id)
+      assert_enqueued_with(job: CacheDeploySpecJob, args: [@stack]) do
+        @job.perform(stack_id: @stack.id)
+      end
     end
-  end
 
-  test "#perform mark all childs of the common parent as detached" do
-    Stack.any_instance.expects(:github_commits).returns(@github_commits)
-    @job.expects(:fetch_missing_commits).yields.returns([[], commits(:third)])
+    test "#perform mark all childs of the common parent as detached" do
+      Stack.any_instance.expects(:github_commits).returns(@github_commits)
+      @job.expects(:fetch_missing_commits).yields.returns([[], shipit_commits(:third)])
 
-    refute commits(:fourth).reload.detached?
-    refute commits(:fifth).reload.detached?
+      refute shipit_commits(:fourth).reload.detached?
+      refute shipit_commits(:fifth).reload.detached?
 
-    @job.perform(stack_id: @stack.id)
+      @job.perform(stack_id: @stack.id)
 
-    assert commits(:fourth).reload.detached?
-    assert commits(:fifth).reload.detached?
-  end
+      assert shipit_commits(:fourth).reload.detached?
+      assert shipit_commits(:fifth).reload.detached?
+    end
 
-  test "#fetch_missing_commits returns the commits in the reverse order if it doesn't know the parent" do
-    last = stub(sha: 123)
-    first = stub(sha: 345)
-    Shipit::FirstParentCommitsIterator.any_instance.stubs(:each).multiple_yields(last, first)
-    @job.stubs(lookup_commit: nil)
+    test "#fetch_missing_commits returns the commits in the reverse order if it doesn't know the parent" do
+      last = stub(sha: 123)
+      first = stub(sha: 345)
+      Shipit::FirstParentCommitsIterator.any_instance.stubs(:each).multiple_yields(last, first)
+      @job.stubs(lookup_commit: nil)
 
-    commits, parent = @job.fetch_missing_commits { stub }
-    assert_nil parent
-    assert_equal [first, last], commits
-  end
+      commits, parent = @job.fetch_missing_commits { stub }
+      assert_nil parent
+      assert_equal [first, last], commits
+    end
 
-  test "#fetch_missing_commits returns the commits in the reverse order if it knows the parent" do
-    last = stub(sha: 123)
-    first = stub(sha: 345)
-    Shipit::FirstParentCommitsIterator.any_instance.stubs(:each).multiple_yields(last, first)
-    @job.stubs(:lookup_commit).with(123).returns(nil)
-    @job.stubs(:lookup_commit).with(345).returns(first)
+    test "#fetch_missing_commits returns the commits in the reverse order if it knows the parent" do
+      last = stub(sha: 123)
+      first = stub(sha: 345)
+      Shipit::FirstParentCommitsIterator.any_instance.stubs(:each).multiple_yields(last, first)
+      @job.stubs(:lookup_commit).with(123).returns(nil)
+      @job.stubs(:lookup_commit).with(345).returns(first)
 
-    commits, parent = @job.fetch_missing_commits { stub }
-    assert_equal first, parent
-    assert_equal [last], commits
-  end
+      commits, parent = @job.fetch_missing_commits { stub }
+      assert_equal first, parent
+      assert_equal [last], commits
+    end
 
-  test "if GitHub returns a 404, the stacks is marked as inaccessible" do
-    @job.expects(:fetch_missing_commits).raises(Octokit::NotFound)
-    @job.perform(stack_id: @stack.id)
+    test "if GitHub returns a 404, the stacks is marked as inaccessible" do
+      @job.expects(:fetch_missing_commits).raises(Octokit::NotFound)
+      @job.perform(stack_id: @stack.id)
 
-    assert_equal true, @stack.reload.inaccessible_since?
+      assert_equal true, @stack.reload.inaccessible_since?
+    end
   end
 end

data/test/jobs/perform_task_job_test.rb

@@ -1,102 +1,104 @@
 require 'test_helper'
 
-class PerformTaskJobTest < ActiveSupport::TestCase
-  setup do
-    @job = PerformTaskJob.new
-    @deploy = deploys(:shipit_pending)
-    @stack = stacks(:shipit)
-  end
-
-  test "#perform fetch commits from the API" do
-    @job.stubs(:capture)
-    @commands = stub(:commands)
-    Commands.expects(:for).with(@deploy).returns(@commands)
-
-    @commands.expects(:fetch).once
-    @commands.expects(:clone).once
-    @commands.expects(:checkout).with(@deploy.until_commit).once
-    @commands.expects(:install_dependencies).returns([]).once
-    @commands.expects(:perform).returns([]).once
+module Shipit
+  class PerformTaskJobTest < ActiveSupport::TestCase
+    setup do
+      @job = PerformTaskJob.new
+      @deploy = shipit_deploys(:shipit_pending)
+      @stack = shipit_stacks(:shipit)
+    end
 
-    @deploy.expects(:clear_working_directory)
+    test "#perform fetch commits from the API" do
+      @job.stubs(:capture)
+      @commands = stub(:commands)
+      Commands.expects(:for).with(@deploy).returns(@commands)
 
-    @job.perform(@deploy)
-  end
+      @commands.expects(:fetch).once
+      @commands.expects(:clone).once
+      @commands.expects(:checkout).with(@deploy.until_commit).once
+      @commands.expects(:install_dependencies).returns([]).once
+      @commands.expects(:perform).returns([]).once
 
-  test "#perform enqueues a FetchDeployedRevisionJob" do
-    Dir.stubs(:chdir).yields
-    DeployCommands.any_instance.expects(:perform).returns([])
-    @job.stubs(:capture)
+      @deploy.expects(:clear_working_directory)
 
-    Hook.expects(:emit).twice
-    assert_enqueued_with(job: FetchDeployedRevisionJob, args: [@deploy.stack]) do
       @job.perform(@deploy)
     end
-  end
 
-  test "marks deploy as successful" do
-    Dir.stubs(:chdir).yields
-    DeployCommands.any_instance.expects(:perform).returns([])
-    @job.stubs(:capture)
+    test "#perform enqueues a FetchDeployedRevisionJob" do
+      Dir.stubs(:chdir).yields
+      DeployCommands.any_instance.expects(:perform).returns([])
+      @job.stubs(:capture)
 
-    @job.perform(@deploy)
-    assert_equal 'success', @deploy.reload.status
-  end
+      Hook.expects(:emit).twice
+      assert_enqueued_with(job: FetchDeployedRevisionJob, args: [@deploy.stack]) do
+        @job.perform(@deploy)
+      end
+    end
+
+    test "marks deploy as successful" do
+      Dir.stubs(:chdir).yields
+      DeployCommands.any_instance.expects(:perform).returns([])
+      @job.stubs(:capture)
 
-  test "marks deploy as `error` if any application error is raised" do
-    @job.expects(:capture).raises("some error")
-    assert_nothing_raised do
       @job.perform(@deploy)
+      assert_equal 'success', @deploy.reload.status
     end
-    assert_equal 'error', @deploy.reload.status
-    assert_includes @deploy.chunk_output, 'RuntimeError: some error'
-  end
 
-  test "marks deploy as `failed` if a command exit with an error code" do
-    @job.expects(:capture).raises(Command::Error.new('something'))
-    @job.perform(@deploy)
-    assert_equal 'failed', @deploy.reload.status
-  end
+    test "marks deploy as `error` if any application error is raised" do
+      @job.expects(:capture).raises("some error")
+      assert_nothing_raised do
+        @job.perform(@deploy)
+      end
+      assert_equal 'error', @deploy.reload.status
+      assert_includes @deploy.chunk_output, 'RuntimeError: some error'
+    end
 
-  test "bail out if deploy is not pending" do
-    @deploy.run!
-    @job.expects(:capture).never
-    @job.perform(@deploy)
-  end
+    test "marks deploy as `failed` if a command exit with an error code" do
+      @job.expects(:capture).raises(Command::Error.new('something'))
+      @job.perform(@deploy)
+      assert_equal 'failed', @deploy.reload.status
+    end
 
-  test "mark deploy as error if a command timeout" do
-    Timeout.expects(:timeout).raises(Timeout::Error.new)
-    Command.any_instance.expects(:terminate!)
-    assert_nothing_raised do
+    test "bail out if deploy is not pending" do
+      @deploy.run!
+      @job.expects(:capture).never
       @job.perform(@deploy)
     end
-    assert @deploy.reload.error?
-    assert_includes @deploy.chunk_output, 'Timeout::Error'
-  end
 
-  test "records stack support for rollbacks and fetching deployed revision" do
-    @job.stubs(:capture)
-    @commands = stub(:commands)
-    @commands.stubs(:fetch).returns([])
-    @commands.stubs(:clone).returns([])
-    @commands.stubs(:checkout).returns([])
-    @commands.stubs(:install_dependencies).returns([])
-    @commands.stubs(:perform).returns([])
-    DeployCommands.expects(:new).with(@deploy).returns(@commands)
-    @deploy.stubs(:clear_working_directory)
+    test "mark deploy as error if a command timeout" do
+      Timeout.expects(:timeout).raises(Timeout::Error.new)
+      Command.any_instance.expects(:terminate!)
+      assert_nothing_raised do
+        @job.perform(@deploy)
+      end
+      assert @deploy.reload.error?
+      assert_includes @deploy.chunk_output, 'Timeout::Error'
+    end
 
-    @stack.update!(cached_deploy_spec: DeploySpec.new({}))
+    test "records stack support for rollbacks and fetching deployed revision" do
+      @job.stubs(:capture)
+      @commands = stub(:commands)
+      @commands.stubs(:fetch).returns([])
+      @commands.stubs(:clone).returns([])
+      @commands.stubs(:checkout).returns([])
+      @commands.stubs(:install_dependencies).returns([])
+      @commands.stubs(:perform).returns([])
+      DeployCommands.expects(:new).with(@deploy).returns(@commands)
+      @deploy.stubs(:clear_working_directory)
 
-    refute @stack.supports_rollback?
-    refute @stack.supports_fetch_deployed_revision?
+      @stack.update!(cached_deploy_spec: DeploySpec.new({}))
 
-    @job.perform(@deploy)
-    @stack.reload
+      refute @stack.supports_rollback?
+      refute @stack.supports_fetch_deployed_revision?
 
-    DeploySpec.any_instance.expects(:supports_fetch_deployed_revision?).returns(true)
-    DeploySpec.any_instance.expects(:supports_rollback?).returns(true)
+      @job.perform(@deploy)
+      @stack.reload
 
-    assert @stack.supports_rollback?
-    assert @stack.supports_fetch_deployed_revision?
+      DeploySpec.any_instance.expects(:supports_fetch_deployed_revision?).returns(true)
+      DeploySpec.any_instance.expects(:supports_rollback?).returns(true)
+
+      assert @stack.supports_rollback?
+      assert @stack.supports_fetch_deployed_revision?
+    end
   end
 end