shipit-engine 0.27.1 → 0.28.0

data/test/jobs/update_github_last_deployed_ref_job_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+
+module Shipit
+  class UpdateGithubLastDeployedRefJobTest < ActiveSupport::TestCase
+    setup do
+      @stack = shipit_stacks(:shipit)
+      @job = UpdateGithubLastDeployedRefJob.new
+      @deploy = @stack.deploys.last
+      @commit = @deploy.until_commit
+      @api_client = Shipit.github.api
+      @expected_ref_prefix = "shipit-deploy/#{@stack.environment}"
+      @expected_name = @stack.github_repo_name
+      @expected_sha = @commit.sha
+
+      expected_ref = ["refs", @expected_ref_prefix].join('/')
+      ref_url = "http://api.github.test.com/shopify/shipit-engine/git/#{expected_ref}"
+      commit_url = "https://api.github.test.com/repos/shopify/shipit-engine/git/commits/#{@commit.sha}"
+      response_inner_obj = OpenStruct.new(sha: @commit.sha, type: "commit", url: commit_url)
+      @response = OpenStruct.new(ref: expected_ref, node_id: "blah", url: ref_url, object: response_inner_obj)
+    end
+
+    test "#perform will create a ref when one is not present" do
+      Octokit::UnprocessableEntity.any_instance.stubs(:build_error_message).returns("Reference does not exist")
+
+      @api_client.expects(:update_ref).with(@expected_name, @expected_ref_prefix, @expected_sha).raises(Octokit::UnprocessableEntity)
+      @api_client.expects(:create_ref).with(@expected_name, @expected_ref_prefix, @expected_sha).returns(@response)
+
+      result = @job.perform(@stack)
+
+      assert_equal @response, result
+    end
+
+    test "#perform will update a ref when one is present" do
+      prior_response = @response.dup
+      prior_response.object = prior_response.object.dup
+      new_sha = "some_new_sha"
+      @response.object.sha = new_sha
+      @commit.sha = new_sha
+      @commit.save
+
+      @api_client.expects(:update_ref).with(@expected_name, @expected_ref_prefix, new_sha).returns(@response)
+
+      result = @job.perform(@stack)
+
+      assert_equal @response, result
+    end
+
+    test '#perform will raise an exception for non ref existence errors' do
+      Octokit::UnprocessableEntity.any_instance.stubs(:build_error_message).returns("Some other error.")
+
+      @api_client.expects(:update_ref).with(@expected_name, @expected_ref_prefix, @expected_sha).raises(Octokit::UnprocessableEntity)
+      @api_client.expects(:create_ref).with(@expected_name, @expected_ref_prefix, @expected_sha).never
+
+      assert_raises Octokit::UnprocessableEntity do
+        @job.perform(@stack)
+      end
+    end
+
+    test '#perform skips unsuccessful deploys when finding sha to use' do
+      prior_response = @response.dup
+      prior_response.object = prior_response.object.dup
+      new_sha = "some_new_sha"
+      @response.object.sha = new_sha
+      @commit.sha = new_sha
+      @commit.save
+
+      new_deploy = @stack.deploys.last.dup
+      new_commit = new_deploy.until_commit.dup
+      new_commit.sha = "some fake sha"
+      new_deploy.until_commit = new_commit
+      new_deploy.id = nil
+      new_deploy.status = "faulty"
+      new_deploy.save
+
+      @api_client.expects(:update_ref).with(@expected_name, @expected_ref_prefix, new_sha).returns(@response)
+      result = @job.perform(@stack)
+
+      assert_equal @response, result
+
+      new_deploy.reload
+      new_deploy.status = "success"
+      new_deploy.save
+
+      @api_client.expects(:update_ref).with(@expected_name, @expected_ref_prefix, new_commit.sha).returns(@response)
+      @job.perform(@stack)
+    end
+  end
+end

data/test/models/commits_test.rb

@@ -35,6 +35,33 @@ module Shipit
       end
     end
 
+    test '.create_from_github handle commits with empty message' do
+      assert_difference -> { Commit.count }, +1 do
+        @stack.commits.create_from_github!(
+          resource(
+            sha: '2adaad1ad30c235d3a6e7981dfc1742f7ecb1e85',
+            author: {},
+            committer: {},
+            commit: {
+              author: {
+                name: 'Lando Walrussian',
+                email: 'walrus@shopify.com',
+                date: Time.now,
+              },
+              committer: {
+                name: 'Lando Walrussian',
+                email: 'walrus@shopify.com',
+                date: Time.now,
+              },
+              message: '',
+            },
+          ),
+        )
+      end
+      commit = Commit.last
+      refute_predicate commit, :revert?
+    end
+
     test '.create_from_github handle PRs merged by another Shipit stacks' do
       assert_difference -> { Commit.count }, +1 do
         @stack.commits.create_from_github!(
@@ -247,7 +274,7 @@ module Shipit
 
     test "#creating a commit update the undeployed_commits_count" do
       walrus = shipit_users(:walrus)
-      assert_equal 1, @stack.undeployed_commits_count
+      assert_equal 2, @stack.undeployed_commits_count
       @stack.commits.create!(
         author: walrus,
         committer: walrus,
@@ -417,6 +444,66 @@ module Shipit
       assert_predicate commit, :deployable?
     end
 
+    test "#lock sets the lock author and sets the locked flag" do
+      user = shipit_users(:shipit)
+
+      @commit.lock(user)
+
+      assert_predicate(@commit, :locked?)
+      assert_equal(user, @commit.lock_author)
+    end
+
+    test "#lock does not set the lock author if the user is anonymous" do
+      user = Shipit::AnonymousUser.new
+
+      @commit.lock(user)
+
+      assert_predicate(@commit, :locked?)
+      assert_nil(@commit.lock_author_id)
+    end
+
+    test ".lock_all sets the lock author and sets the locked flag" do
+      user = shipit_users(:shipit)
+
+      Commit.where(id: [@commit.id]).lock_all(user)
+
+      @commit.reload
+      assert_predicate(@commit, :locked?)
+      assert_equal(user, @commit.lock_author)
+    end
+
+    test ".lock_all does not set the lock author if the user is anonymous" do
+      user = Shipit::AnonymousUser.new
+
+      Commit.where(id: [@commit.id]).lock_all(user)
+
+      @commit.reload
+      assert_predicate(@commit, :locked?)
+      assert_nil(@commit.lock_author_id)
+    end
+
+    test "#lock_author defaults to AnonymousUser" do
+      assert_nil(@commit.lock_author_id)
+      assert_kind_of(Shipit::AnonymousUser, @commit.lock_author)
+
+      user = shipit_users(:shipit)
+      @commit.lock(user)
+
+      assert_kind_of(Shipit::User, @commit.lock_author)
+    end
+
+    test "#unlock clears the lock author and resets the locked flag" do
+      user = shipit_users(:shipit)
+      @commit.lock(user)
+      assert_predicate(@commit, :locked?)
+      assert_equal(user, @commit.lock_author)
+
+      @commit.unlock
+
+      refute_predicate(@commit, :locked?)
+      assert_nil(@commit.lock_author_id)
+    end
+
     expected_webhook_transitions = { # we expect deployable_status to fire on these transitions, and not on any others
       'unknown' => %w(pending success failure error),
       'pending' => %w(success failure error),

data/test/models/deploy_spec_test.rb

@@ -323,7 +323,11 @@ module Shipit
       file = Pathname.new('/tmp/fake_setup.py')
       file.write('foo')
       @spec.stubs(:setup_dot_py).returns(file)
-      steps = ['assert-egg-version-tag /tmp/fake_setup.py', 'python setup.py register sdist upload']
+      steps = [
+        'assert-egg-version-tag /tmp/fake_setup.py',
+        'python setup.py register sdist',
+        'twine upload dist/*',
+      ]
       assert_equal steps, @spec.deploy_steps
     end
 
@@ -732,6 +736,7 @@ module Shipit
 
     test 'lerna monorepos have a checklist' do
       @spec.stubs(:lerna?).returns(true).at_least_once
+      @spec.stubs(:lerna_config).returns('lerna' => '2.0.0', 'version' => '1.0.0')
       assert_match(/lerna publish --skip-npm/, @spec.review_checklist[0])
     end
 
@@ -744,10 +749,18 @@ module Shipit
       file = Pathname.new('/tmp/fake_lerna.json')
       file.write('{"version": "1.0.0-beta.1"}')
 
-      @spec.expects(:lerna_json).returns(file)
+      @spec.expects(:lerna_json).at_least_once.returns(file)
       assert_equal '1.0.0-beta.1', @spec.lerna_version
     end
 
+    test '#lerna_lerna returns the lerna version specified' do
+      file = Pathname.new('/tmp/fake_lerna.json')
+      file.write('{"version": "1.0.0-beta.1", "lerna": "3.13.3"}')
+
+      @spec.expects(:lerna_json).at_least_once.returns(file)
+      assert_equal Gem::Version.new('3.13.3'), @spec.lerna_lerna
+    end
+
     test '#package_version returns the version number' do
       file = Pathname.new('/tmp/fake_package.json')
       file.write('{"version": "1.0.0-beta.1"}')
@@ -780,18 +793,32 @@ module Shipit
 
     test '#publish_lerna_packages checks if independent version tags exist, and then invokes lerna deploy script' do
       @spec.stubs(:lerna?).returns(true)
-      @spec.stubs(:lerna_version).returns('independent')
+      @spec.stubs(:lerna_config).returns('lerna' => '2.0.0', 'version' => 'independent')
       assert_equal 'assert-lerna-independent-version-tags', @spec.deploy_steps[0]
       assert_equal 'publish-lerna-independent-packages', @spec.deploy_steps[1]
     end
 
     test '#publish_lerna_packages checks if fixed version tag exists, and then invokes lerna deploy script' do
       @spec.stubs(:lerna?).returns(true)
-      @spec.stubs(:lerna_version).returns('1.0.0')
+      @spec.stubs(:lerna_config).returns('lerna' => '2.0.0', 'version' => '1.0.0')
       assert_equal 'assert-lerna-fixed-version-tag', @spec.deploy_steps[0]
       assert_equal 'node_modules/.bin/lerna publish --yes --skip-git --repo-version 1.0.0 --force-publish=* --npm-tag latest --npm-client=npm --skip-npm=false', @spec.deploy_steps[1]
     end
 
+    test '#publish_lerna_packages checks if a newer version of lerna is used, and will then use the new publish syntax, correctly setting the `latest` dist tag' do
+      @spec.stubs(:lerna?).returns(true)
+      @spec.stubs(:lerna_config).returns('lerna' => '3.0.0', 'version' => '1.0.0')
+      assert_equal 'assert-lerna-fixed-version-tag', @spec.deploy_steps[0]
+      assert_equal 'node_modules/.bin/lerna publish from-git --yes --dist-tag latest', @spec.deploy_steps[1]
+    end
+
+    test '#publish_lerna_packages checks if a newer version of lerna is used, and will then use the new publish syntax, correctly setting the `next` dist tag' do
+      @spec.stubs(:lerna?).returns(true)
+      @spec.stubs(:lerna_config).returns('lerna' => '3.0.0', 'version' => 'v1.3.1-alpha.2')
+      assert_equal 'assert-lerna-fixed-version-tag', @spec.deploy_steps[0]
+      assert_equal 'node_modules/.bin/lerna publish from-git --yes --dist-tag next', @spec.deploy_steps[1]
+    end
+
     test '#enforce_publish_config? is false when Shipit.enforce_publish_config is nil' do
       Shipit.stubs(:enforce_publish_config).returns(nil)
       refute @spec.enforce_publish_config?
@@ -829,7 +856,8 @@ module Shipit
     end
 
     test '#valid_publish_config? is true when shipit does not enforce a publishConfig' do
-      @spec.stubs(:lerna_version).returns('1.0.0')
+      @spec.stubs(:lerna?).returns(true)
+      @spec.stubs(:lerna_config).returns('lerna' => '2.0.0', 'version' => '1.0.0')
       assert @spec.valid_publish_config?
     end
 
@@ -946,7 +974,7 @@ module Shipit
 
     test '#publish_lerna_packages guesses npm tag' do
       @spec.stubs(:lerna?).returns(true)
-      @spec.stubs(:lerna_version).returns('1.0.0-alpha.1')
+      @spec.stubs(:lerna_config).returns('lerna' => '2.0.0', 'version' => '1.0.0-alpha.1')
       assert_match(/--npm-tag next/, @spec.deploy_steps.last)
     end
 

data/test/models/deploys_test.rb

@@ -23,6 +23,16 @@ module Shipit
       assert_raise(RuntimeError) { Deploy.new.enqueue }
     end
 
+    test "run_now! when not persisted" do
+      assert_raise(RuntimeError) { Deploy.new.run_now! }
+    end
+
+    test "run_now! runs in foreground" do
+      PerformTaskJob.any_instance.expects(:perform).once
+
+      @deploy.run_now!
+    end
+
     test "working_directory" do
       assert_equal File.join(@deploy.stack.deploys_path, @deploy.id.to_s), @deploy.working_directory
     end
@@ -235,6 +245,13 @@ module Shipit
       end
     end
 
+    test "transitioning to success enqueues a last-deployed git reference update" do
+      @deploy = shipit_deploys(:shipit_running)
+      assert_enqueued_with(job: UpdateGithubLastDeployedRefJob, args: [@deploy.stack]) do
+        @deploy.complete!
+      end
+    end
+
     test "transitions to any state updates last deploy time to stack record" do
       @deploy = shipit_deploys(:shipit_running)
       @deploy.complete!
@@ -321,12 +338,289 @@ module Shipit
       assert_equal shipit_commits(:second), @stack.last_deployed_commit
     end
 
+    def create_test_stack
+      Shipit::Stack.create(
+        repo_owner: "shopify-test",
+        repo_name: "shipit-engine-test",
+        environment: 'production',
+        branch: "master",
+        merge_queue_enabled: true,
+        created_at: "2019-01-01 00:00:00",
+        updated_at: "2019-01-02 10:10:10",
+      )
+    end
+
+    def create_test_commit(stack_id:, user_id:)
+      Shipit::Commit.new(
+        stack_id: stack_id,
+        author_id: user_id,
+        sha: SecureRandom.hex(20),
+        additions: 2,
+        deletions: 0,
+        committer_id: user_id,
+        message: "Some commit message.",
+        authored_at: "2019-01-02 10:11:10",
+        committed_at: "2019-01-02 10:11:10",
+      )
+    end
+
+    def create_test_status(commit_id:, stack_id:, state: "success")
+      Shipit::Status.new(
+        description: "Description for commit #{commit_id}",
+        stack_id: stack_id,
+        commit_id: commit_id,
+        state: state,
+      )
+    end
+
+    def create_test_deploy(stack_id:, user_id:, since_commit_id:, until_commit_id: since_commit_id)
+      Shipit::Deploy.new(
+        stack_id: stack_id,
+        user_id: user_id,
+        since_commit_id: since_commit_id,
+        until_commit_id: until_commit_id,
+        status: "success",
+        type: "Shipit::Deploy",
+      )
+    end
+
+    # For test purposes, we want to fail fast if a series of records are given sequential ids.
+    # Check that the next item in the series is 1 greater than the last.
+    def assert_generated_record_ids_are_sequential(record_id_series)
+      record_id_series[0..-2].each_with_index do |id_element, index|
+        assert_equal id_element + 1, record_id_series[index + 1]
+      end
+    end
+
+    def generate_commits(amount:, stack_id:, user_id:, validate:)
+      commit_ids = []
+      amount.times do
+        commit = create_test_commit(stack_id: stack_id, user_id: user_id)
+        commit.save
+        commit.reload
+        commit_ids << commit.id
+      end
+
+      if validate then assert_generated_record_ids_are_sequential(commit_ids) end
+      commit_ids
+    end
+
     test "#trigger_revert rolls the stack back to before this deploy" do
-      assert_equal shipit_commits(:fourth), @stack.last_deployed_commit
-      rollback = @deploy.trigger_revert
+      user_id = @user.id
+      test_stack = create_test_stack
+      test_stack.save
+      test_stack.reload
+      stack_id = test_stack.id
+
+      # Create valid commit history for the stack. We need several commits to deploy and roll back through.
+      commit_ids = generate_commits(amount: 4, stack_id: stack_id, user_id: user_id, validate: true)
+      commit_ids.each { |commit_id| create_test_status(commit_id: commit_id, stack_id: stack_id, state: "success").save }
+
+      # Three deploys of commits 1-2, 2-3 and 3-4 respectively. Reverting last should result in Deploy 3 (commit 3) being latest.
+      3.times { |index| create_test_deploy(stack_id: stack_id, user_id: user_id, since_commit_id: commit_ids[index], until_commit_id: commit_ids[index + 1]).save }
+
+      # Get the reference with Rails-mutated field values.
+      commit3 = Shipit::Commit.second_to_last
+      commit4 = Shipit::Commit.last
+      deploy3 = Shipit::Deploy.last
+
+      assert_equal commit4, test_stack.last_deployed_commit
+
+      deploy_to_revert = test_stack.deploys.last
+
+      assert_equal deploy3, deploy_to_revert
+
+      rollback = deploy_to_revert.trigger_revert
       rollback.run!
       rollback.complete!
-      assert_equal shipit_commits(:first), @stack.last_deployed_commit
+
+      last_deploy = test_stack.last_completed_deploy
+
+      assert_equal commit3, test_stack.last_deployed_commit
+      assert_equal commit3, last_deploy.until_commit
+      assert_equal "Shipit::Rollback", last_deploy.type
+    end
+
+    test "#trigger_revert skips unsuccessful deploys when reverting" do
+      user_id = @user.id
+      test_stack = create_test_stack
+      test_stack.save
+      test_stack.reload
+      stack_id = test_stack.id
+
+      # Create valid commit history for the stack. We need several commits to deploy and roll back through.
+      commit_ids = generate_commits(amount: 4, stack_id: stack_id, user_id: user_id, validate: true)
+      commit_ids.each { |commit_id| create_test_status(commit_id: commit_id, stack_id: stack_id, state: "success").save }
+
+      # We want the following order of Deploys:
+      # 1. Success (commits 1-2)
+      # 2. Faulty (commits 2-3)
+      # 3. Rollback to Success (-> commits 1-2)
+      # 4. Running (commits 3-4)
+      # 5. Reversion of the running deploy to the last successful deploy. (-> commits 1-2, i.e. the successful deploy.)
+
+      deploy1 = create_test_deploy(stack_id: stack_id, user_id: user_id, since_commit_id: commit_ids[0], until_commit_id: commit_ids[1])
+      deploy1.save
+
+      deploy2 = create_test_deploy(stack_id: stack_id, user_id: user_id, since_commit_id: commit_ids[1], until_commit_id: commit_ids[2])
+      deploy2.status = "faulty"
+      deploy2.save
+
+      rollback = test_stack.deploys.second_to_last.trigger_rollback(@user)
+      rollback.run!
+      rollback.complete!
+
+      assert_equal commit_ids[1], test_stack.last_deployed_commit.id
+
+      deploy3 = create_test_deploy(stack_id: stack_id, user_id: user_id, since_commit_id: commit_ids[2], until_commit_id: commit_ids[3])
+      deploy3.status = "running"
+      deploy3.rollback_once_aborted = false
+      deploy3.save
+
+      running_deploy = deploy3.reload
+      running_deploy.abort!(aborted_by: @user)
+      running_deploy.reload
+
+      assert_equal "error", running_deploy.status
+
+      final_rollback = running_deploy.trigger_revert
+      final_rollback.run!
+      final_rollback.complete!
+
+      last_deploy = test_stack.last_completed_deploy
+
+      # The rollback deploy should be from the last commit until the second commit.
+      assert_equal "success", last_deploy.status
+      assert_equal "Shipit::Rollback", last_deploy.type
+      assert_equal commit_ids[-1], last_deploy.since_commit_id
+      assert_equal commit_ids[1], last_deploy.until_commit_id
+      assert_equal commit_ids[1], test_stack.last_deployed_commit.id
+    end
+
+    test "#trigger_revert skips non-deploy tasks when rolling back" do
+      # The revert functionality should only consider Shipit::Deploy and Shipit::Rollback when selecting a target to roll back to for the user.
+      # But it is possible for other task types to be defined, so we want to ensure that they are properly skipped, as we can't know whether they are 'valid' to roll back to.
+      user_id = @user.id
+      test_stack = create_test_stack
+      test_stack.save
+      test_stack.reload
+      stack_id = test_stack.id
+
+      # Create valid commit history for the stack. We need several commits to deploy and roll back through.
+      commit_ids = generate_commits(amount: 4, stack_id: stack_id, user_id: user_id, validate: true)
+      commit_ids.each { |commit_id| create_test_status(commit_id: commit_id, stack_id: stack_id, state: "success").save }
+
+      # We want the following order of Deploys:
+      # 1. Success (commits 1-2)
+      # 2. Success, but type is not of deploy (commits 2-3)
+      # 3. Running (commits 3-4)
+      # 4. Reversion of the running deploy to the last successful deploy. (-> commits 1-2, i.e. the successful deploy.)
+      # If the revert functionality doesn't restrict to deploys and rollbacks, then commit 3 will be latest deployed when the reversion is done.
+
+      deploy1 = create_test_deploy(stack_id: stack_id, user_id: user_id, since_commit_id: commit_ids[0], until_commit_id: commit_ids[1])
+      deploy1.save
+
+      deploy2 = create_test_deploy(stack_id: stack_id, user_id: user_id, since_commit_id: commit_ids[1], until_commit_id: commit_ids[2])
+      deploy2.type = "Shipit::Fake"
+      deploy2.save
+
+      deploy3 = create_test_deploy(stack_id: stack_id, user_id: user_id, since_commit_id: commit_ids[2], until_commit_id: commit_ids[3])
+      deploy3.status = "running"
+      deploy3.rollback_once_aborted = false
+      deploy3.save
+
+      running_deploy = deploy3.reload
+      running_deploy.abort!(aborted_by: @user)
+      running_deploy.reload
+
+      rollback = running_deploy.trigger_revert
+      rollback.run!
+      rollback.complete!
+
+      last_deploy = test_stack.last_completed_deploy
+      assert_equal "success", last_deploy.status
+      assert_equal "Shipit::Rollback", last_deploy.type
+      assert_equal commit_ids[-1], last_deploy.since_commit_id
+      assert_equal commit_ids[1], last_deploy.until_commit_id
+      assert_equal commit_ids[1], test_stack.last_deployed_commit.id
+    end
+
+    test "#trigger_revert skips deploys from other stacks" do
+      # The revert functionality should only consider Shipit::Deploy and Shipit::Rollback's from the same stack when selecting a target to roll back to for the user.
+      # But deploys and commits from other stacks can have ids between the current and the previous of this stack, so we want a test to ensure that the deploy
+      # from the correct stack is selected.
+      user_id = @user.id
+      test_stack = create_test_stack
+      test_stack.save
+      other_stack = create_test_stack
+      other_stack.repo_name += "_other"
+      other_stack.save
+      other_stack.reload
+      stack_id = test_stack.id
+
+      # Create valid commit history for the stack. We need several commits to deploy and roll back through.
+      commit_ids = generate_commits(amount: 4, stack_id: stack_id, user_id: user_id, validate: true)
+      commit_ids.each { |commit_id| create_test_status(commit_id: commit_id, stack_id: stack_id, state: "success").save }
+
+      # We want the following order of Deploys:
+      # 1. Success (commits 1-2)
+      # 2. Success, but belongs to a different stack (commits 2-3)
+      # 3. Running (commits 3-4)
+      # 4. Reversion of the running deploy to the last successful deploy of the same stack. (-> commits 1-2, i.e. the successful deploy.)
+      # If the revert functionality doesn't restrict to the correct stack, then commit 3 will be latest deployed when the reversion is done.
+
+      deploy1 = create_test_deploy(stack_id: stack_id, user_id: user_id, since_commit_id: commit_ids[0], until_commit_id: commit_ids[1])
+      deploy1.save
+
+      deploy2 = create_test_deploy(stack_id: other_stack.id, user_id: user_id, since_commit_id: commit_ids[1], until_commit_id: commit_ids[2])
+      deploy2.save
+
+      deploy3 = create_test_deploy(stack_id: stack_id, user_id: user_id, since_commit_id: commit_ids[2], until_commit_id: commit_ids[3])
+      deploy3.status = "running"
+      deploy3.rollback_once_aborted = false
+      deploy3.save
+
+      running_deploy = deploy3.reload
+      running_deploy.abort!(aborted_by: @user)
+      running_deploy.reload
+
+      rollback = running_deploy.trigger_revert
+      rollback.run!
+      rollback.complete!
+
+      last_deploy = test_stack.last_completed_deploy
+      assert_equal "success", last_deploy.status
+      assert_equal "Shipit::Rollback", last_deploy.type
+      assert_equal commit_ids[-1], last_deploy.since_commit_id
+      assert_equal commit_ids[1], last_deploy.until_commit_id
+      assert_equal commit_ids[1], test_stack.last_deployed_commit.id
+    end
+
+    test "#trigger_revert no prior deploy to roll back to" do
+      user_id = @user.id
+      test_stack = create_test_stack
+      test_stack.save
+      test_stack.reload
+      stack_id = test_stack.id
+
+      commit_ids = generate_commits(amount: 2, stack_id: stack_id, user_id: user_id, validate: true)
+      commit_ids.each { |commit_id| create_test_status(commit_id: commit_id, stack_id: stack_id, state: "success").save }
+      deploy1 = create_test_deploy(stack_id: stack_id, user_id: user_id, since_commit_id: commit_ids[0], until_commit_id: commit_ids[1])
+      deploy1.save
+
+      rollback = deploy1.trigger_revert
+      rollback.run!
+      rollback.complete!
+
+      assert_equal deploy1.until_commit_id, rollback.since_commit_id
+      assert_equal deploy1.since_commit_id, rollback.until_commit_id
+
+      last_deploy = test_stack.last_completed_deploy
+      assert_equal "success", last_deploy.status
+      assert_equal "Shipit::Rollback", last_deploy.type
+      assert_equal deploy1.until_commit_id, last_deploy.since_commit_id
+      assert_equal deploy1.since_commit_id, last_deploy.until_commit_id
+      assert_equal deploy1.since_commit_id, test_stack.last_deployed_commit.id
     end
 
     test "#trigger_rollback creates a new Rollback" do
@@ -525,7 +819,7 @@ module Shipit
       @deploy = shipit_deploys(:canaries_running)
       @deploy.ping
 
-      assert_difference -> { ReleaseStatus.count }, +3 do
+      assert_difference -> { ReleaseStatus.count }, +2 do
         assert_equal 'running', @deploy.status
         assert_not_equal 'failure', @deploy.last_release_status.state
 
@@ -545,16 +839,24 @@ module Shipit
 
     test "manually triggered rollbacks sets the release status as failure" do
       @deploy = shipit_deploys(:canaries_validating)
+      @middle_deploy = shipit_deploys(:canaries_faulty)
+      @rollback_to_deploy = shipit_deploys(:canaries_success)
 
-      assert_difference -> { ReleaseStatus.count }, +1 do
+      assert_difference -> { ReleaseStatus.count }, +2 do
         assert_equal 'validating', @deploy.status
         assert_equal 'pending', @deploy.last_release_status.state
 
-        @deploy.trigger_rollback(force: true)
+        @rollback_to_deploy.trigger_rollback(force: true)
+        @rollback_to_deploy.reload
         @deploy.reload
 
         assert_equal 'faulty', @deploy.status
         assert_equal 'failure', @deploy.last_release_status.state
+
+        assert_equal 'faulty', @middle_deploy.status
+        assert_equal 'failure', @middle_deploy.last_release_status.state
+
+        assert_equal 'success', @rollback_to_deploy.status
       end
     end