shipit-engine 0.11.0 → 0.12.0

data/test/controllers/api/deploys_controller_test.rb

@@ -12,7 +12,7 @@ module Shipit
 
       test "#create triggers a new deploy for the stack" do
         assert_difference -> { @stack.deploys.count }, 1 do
-          post :create, stack_id: @stack.to_param, sha: @commit.sha
+          post :create, params: {stack_id: @stack.to_param, sha: @commit.sha}
         end
         assert_response :accepted
         assert_json 'status', 'pending'
@@ -20,7 +20,7 @@ module Shipit
 
       test "#create triggers a new deploy for whitelisted variables" do
         correct_env = {'SAFETY_DISABLED' => 1}
-        post :create, stack_id: @stack.to_param, sha: @commit.sha, env: correct_env
+        post :create, params: {stack_id: @stack.to_param, sha: @commit.sha, env: correct_env}
         assert_response :accepted
         assert_json 'type', 'deploy'
         assert_json 'status', 'pending'
@@ -28,26 +28,26 @@ module Shipit
 
       test "#create refuses to trigger a new deploy with incorrect variables" do
         incorrect_env = {'DANGEROUS_VARIABLE' => 1}
-        post :create, stack_id: @stack.to_param, sha: @commit.sha, env: incorrect_env
+        post :create, params: {stack_id: @stack.to_param, sha: @commit.sha, env: incorrect_env}
         assert_response :unprocessable_entity
         assert_json 'message', 'Variables DANGEROUS_VARIABLE have not been whitelisted'
       end
 
       test "#create use the claimed user as author" do
         request.headers['X-Shipit-User'] = @user.login
-        post :create, stack_id: @stack.to_param, sha: @commit.sha
+        post :create, params: {stack_id: @stack.to_param, sha: @commit.sha}
         deploy = Deploy.last
         deploy.user == @user
       end
 
       test "#create renders a 422 if the sha isn't found" do
-        post :create, stack_id: @stack.to_param, sha: '123443543545'
+        post :create, params: {stack_id: @stack.to_param, sha: '123443543545'}
         assert_response :unprocessable_entity
         assert_json 'errors', 'sha' => ['Unknown revision']
       end
 
       test "#create renders a 422 if the sha format is invalid" do
-        post :create, stack_id: @stack.to_param, sha: '1'
+        post :create, params: {stack_id: @stack.to_param, sha: '1'}
         assert_response :unprocessable_entity
         assert_json 'errors', 'sha' => ['is too short (minimum is 6 characters)']
       end
@@ -56,7 +56,7 @@ module Shipit
         @stack.update!(lock_reason: 'Something broken')
 
         assert_no_difference -> { @stack.deploys.count } do
-          post :create, stack_id: @stack.to_param, sha: @commit.sha
+          post :create, params: {stack_id: @stack.to_param, sha: @commit.sha}
         end
         assert_response :unprocessable_entity
         assert_json 'errors.force', ["Can't deploy a locked stack"]
@@ -66,7 +66,7 @@ module Shipit
         @stack.update!(lock_reason: 'Something broken')
 
         assert_difference -> { @stack.deploys.count }, 1 do
-          post :create, stack_id: @stack.to_param, sha: @commit.sha, force: true
+          post :create, params: {stack_id: @stack.to_param, sha: @commit.sha, force: 'true'}
         end
         assert_response :accepted
         assert_json 'status', 'pending'

data/test/controllers/api/hooks_controller_test.rb

@@ -26,7 +26,7 @@ module Shipit
       test "#index with a stack_id returns the list of scoped hooks" do
         hook = Hook.scoped_to(@stack).first
 
-        get :index, stack_id: @stack.to_param
+        get :index, params: {stack_id: @stack.to_param}
         assert_response :ok
         assert_json '0.id', hook.id
         assert_json '0.delivery_url', hook.delivery_url
@@ -37,7 +37,7 @@ module Shipit
       test "#show returns the hooks" do
         hook = Hook.scoped_to(@stack).first
 
-        get :show, stack_id: @stack.to_param, id: hook.id
+        get :show, params: {stack_id: @stack.to_param, id: hook.id}
         assert_response :ok
 
         assert_json 'id', hook.id
@@ -48,7 +48,7 @@ module Shipit
 
       test "#create adds a new hook" do
         assert_difference -> { Hook.count }, 1 do
-          post :create, delivery_url: 'https://example.com/hook', events: %w(deploy rollback)
+          post :create, params: {delivery_url: 'https://example.com/hook', events: %w(deploy rollback)}
         end
         hook = Hook.last
         assert_json 'delivery_url', 'https://example.com/hook'
@@ -57,28 +57,30 @@ module Shipit
       end
 
       test "#create do not allow to set protected attributes" do
-        post :create, delivery_url: 'https://example.com/hook',
-                      events: %w(deploy rollback),
-                      created_at: 2.months.ago.to_s(:db)
+        post :create, params: {
+          delivery_url: 'https://example.com/hook',
+          events: %w(deploy rollback),
+          created_at: 2.months.ago.to_s(:db),
+        }
         Hook.last.created_at > 2.seconds.ago
       end
 
       test "#create returns validation errors" do
-        post :create, delivery_url: '../etc/passwd', events: %w(deploy)
+        post :create, params: {delivery_url: '../etc/passwd', events: %w(deploy)}
         assert_response :unprocessable_entity
         assert_json 'errors', 'delivery_url' => ['is not a valid URL']
       end
 
       test "#update changes an existing hook" do
         hook = Hook.global.first
-        patch :update, id: hook.id, delivery_url: 'https://shipit.com/'
+        patch :update, params: {id: hook.id, delivery_url: 'https://shipit.com/'}
         assert_response :ok
         assert_json 'delivery_url', 'https://shipit.com/'
       end
 
       test "#destroy removes an existing hook" do
         hook = Hook.global.first
-        delete :destroy, id: hook.id
+        delete :destroy, params: {id: hook.id}
         assert_response :no_content
       end
     end

data/test/controllers/api/locks_controller_test.rb

@@ -9,20 +9,21 @@ module Shipit
       end
 
       test "#create sets a lock" do
-        post :create, stack_id: @stack.to_param, reason: 'Just for fun!'
+        post :create, params: {stack_id: @stack.to_param, reason: 'Just for fun!'}
         assert_response :ok
         assert_json 'is_locked', true
         assert_json 'lock_reason', 'Just for fun!'
+        assert_json { |json| assert_not_nil json['locked_since'] }
       end
 
       test "#create fails if already locked" do
         @stack.update!(lock_reason: "Don't forget me")
-        post :create, stack_id: @stack.to_param, reason: 'Just for fun!'
+        post :create, params: {stack_id: @stack.to_param, reason: 'Just for fun!'}
         assert_response :conflict
       end
 
       test "#update sets a lock" do
-        put :update, stack_id: @stack.to_param, reason: 'Just for fun!'
+        put :update, params: {stack_id: @stack.to_param, reason: 'Just for fun!'}
         assert_response :ok
         assert_json 'is_locked', true
         assert_json 'lock_reason', 'Just for fun!'
@@ -30,17 +31,26 @@ module Shipit
 
       test "#update can override a previous lock" do
         @stack.update!(lock_reason: 'Meh...')
-        put :update, stack_id: @stack.to_param, reason: 'Just for fun!'
+        put :update, params: {stack_id: @stack.to_param, reason: 'Just for fun!'}
         assert_response :ok
         assert_json 'is_locked', true
         assert_json 'lock_reason', 'Just for fun!'
       end
 
+      test "#update does not override previous locked_since" do
+        since = Time.current.round
+        @stack.update!(lock_reason: 'Meh...', locked_since: since)
+        put :update, params: {stack_id: @stack.to_param, reason: 'Just for fun!'}
+        assert_response :ok
+        assert_json 'locked_since', since.utc.iso8601(3)
+      end
+
       test "#destroy clears the lock" do
-        @stack.update!(lock_reason: 'Meh...')
-        delete :destroy, stack_id: @stack.to_param
+        @stack.update!(lock_reason: 'Meh...', locked_since: Time.current)
+        delete :destroy, params: {stack_id: @stack.to_param}
         assert_response :ok
         assert_json 'is_locked', false
+        assert_json { |json| assert_nil json['locked_since'] }
       end
     end
   end

data/test/controllers/api/outputs_controller_test.rb

@@ -11,7 +11,7 @@ module Shipit
       test "#show returns the task output as plain text" do
         task = @stack.tasks.last
 
-        get :show, stack_id: @stack.to_param, task_id: task.id
+        get :show, params: {stack_id: @stack.to_param, task_id: task.id}
         assert_response :ok
         assert_equal 'text/plain', response.content_type
         assert_equal task.chunk_output, response.body

data/test/controllers/api/stacks_controller_test.rb

@@ -8,6 +8,51 @@ module Shipit
         @stack = shipit_stacks(:shipit)
       end
 
+      test "#create fails with insufficient permissions" do
+        @client.permissions.delete('write:stack')
+        @client.save!
+
+        assert_no_difference 'Stack.count' do
+          post :create, params: {repo_name: 'rails', repo_owner: 'rails', environment: 'staging', branch: 'staging'}
+        end
+
+        assert_response :forbidden
+        assert_json 'message', 'This operation requires the `write:stack` permission'
+      end
+
+      test "#create fails with invalid stack" do
+        assert_no_difference "Stack.count" do
+          post :create, params: {repo_owner: 'some', repo_name: 'owner/path'}
+        end
+        assert_response :unprocessable_entity
+        assert_json 'errors', 'repo_name' => ['is invalid']
+      end
+
+      test "#create creates a stack and renders it back" do
+        assert_difference -> { Stack.count } do
+          post :create, params: {repo_name: 'rails', repo_owner: 'rails', environment: 'staging', branch: 'staging'}
+        end
+
+        assert_response :ok
+        assert_json 'id', Stack.last.id
+      end
+
+      test "#create fails to create stack if it already exists" do
+        Stack.create!(
+          repo_name: 'rails',
+          repo_owner: 'rails',
+          environment: 'staging',
+          branch: 'staging',
+        )
+
+        assert_no_difference -> { Stack.count } do
+          post :create, params: {repo_name: 'rails', repo_owner: 'rails', environment: 'staging', branch: 'staging'}
+        end
+
+        assert_response :unprocessable_entity
+        assert_json 'errors', 'repo_name' => ['cannot be used more than once with this environment']
+      end
+
       test "#index returns a list of stacks" do
         stack = Stack.last
 
@@ -20,7 +65,7 @@ module Shipit
       end
 
       test "#index is paginable" do
-        get :index, page_size: 1
+        get :index, params: {page_size: 1}
         assert_json do |list|
           assert_instance_of Array, list
           assert_equal 1, list.size
@@ -32,7 +77,7 @@ module Shipit
       end
 
       test "the `next` link is not provided when the last page is reached" do
-        get :index, page_size: Stack.count
+        get :index, params: {page_size: Stack.count}
         assert_no_link 'next'
       end
 
@@ -52,7 +97,7 @@ module Shipit
       end
 
       test "#show renders the stack" do
-        get :show, id: @stack.to_param
+        get :show, params: {id: @stack.to_param}
         assert_response :ok
         assert_json 'id', @stack.id
       end

data/test/controllers/api/tasks_controller_test.rb

@@ -11,7 +11,7 @@ module Shipit
       test "#index returns a list of tasks" do
         task = @stack.tasks.last
 
-        get :index, stack_id: @stack.to_param
+        get :index, params: {stack_id: @stack.to_param}
         assert_response :ok
         assert_json '0.id', task.id
       end
@@ -19,13 +19,13 @@ module Shipit
       test "#show returns a task" do
         task = @stack.tasks.last
 
-        get :show, stack_id: @stack.to_param, id: task.id
+        get :show, params: {stack_id: @stack.to_param, id: task.id}
         assert_response :ok
         assert_json 'id', task.id
       end
 
       test "#trigger triggers a custom task" do
-        post :trigger, stack_id: @stack.to_param, task_name: 'restart'
+        post :trigger, params: {stack_id: @stack.to_param, task_name: 'restart'}
         assert_response :accepted
         assert_json 'type', 'task'
         assert_json 'status', 'pending'
@@ -33,21 +33,21 @@ module Shipit
 
       test "#trigger refuses to trigger a task with tasks not whitelisted" do
         env = {'DANGEROUS_VARIABLE' => 'bar'}
-        post :trigger, stack_id: @stack.to_param, task_name: 'restart', env: env
+        post :trigger, params: {stack_id: @stack.to_param, task_name: 'restart', env: env}
         assert_response :unprocessable_entity
         assert_json 'message', 'Variables DANGEROUS_VARIABLE have not been whitelisted'
       end
 
       test "#trigger triggers a task with only whitelisted env variables" do
         env = {'FOO' => 'bar'}
-        post :trigger, stack_id: @stack.to_param, task_name: 'restart', env: env
+        post :trigger, params: {stack_id: @stack.to_param, task_name: 'restart', env: env}
         assert_response :accepted
         assert_json 'type', 'task'
         assert_json 'status', 'pending'
       end
 
       test "#trigger returns a 404 when the task doesn't exist" do
-        post :trigger, stack_id: @stack.to_param, task_name: 'doesnt_exist'
+        post :trigger, params: {stack_id: @stack.to_param, task_name: 'doesnt_exist'}
         assert_response :not_found
       end
     end

data/test/controllers/commit_checks_controller_test.rb

@@ -12,7 +12,7 @@ module Shipit
     end
 
     test ":tail is success" do
-      get :tail, stack_id: @stack.to_param, sha: @commit.sha
+      get :tail, params: {stack_id: @stack.to_param, sha: @commit.sha}
       assert_response :success
       assert_json 'output', 'foobar'
       assert_json 'url', stack_tail_commit_checks_path(@stack, sha: @commit.sha, since: 6)
@@ -21,14 +21,14 @@ module Shipit
 
     test ":tail doesn't provide another url if the task is finished" do
       @checks.status = 'success'
-      get :tail, stack_id: @stack.to_param, sha: @commit.sha
+      get :tail, params: {stack_id: @stack.to_param, sha: @commit.sha}
       assert_response :success
       assert_json 'url', nil
     end
 
     test ":tail returns only the output after the provided offset" do
       @checks.status = 'success'
-      get :tail, stack_id: @stack.to_param, sha: @commit.sha, since: 5
+      get :tail, params: {stack_id: @stack.to_param, sha: @commit.sha, since: 5}
       assert_response :success
       assert_json 'output', 'r'
     end

data/test/controllers/deploys_controller_test.rb

@@ -11,30 +11,30 @@ module Shipit
     end
 
     test ":show is success" do
-      get :show, stack_id: @stack.to_param, id: @deploy.id
+      get :show, params: {stack_id: @stack.to_param, id: @deploy.id}
       assert_response :success
     end
 
     test "deploys can be observed as raw text" do
-      get :show, stack_id: @stack, id: @deploy.id, format: "txt"
+      get :show, params: {stack_id: @stack, id: @deploy.id, format: 'txt'}
       assert_response :success
       assert_equal("text/plain", @response.content_type)
     end
 
     test ":new is success" do
-      get :new, stack_id: @stack.to_param, sha: @commit.sha
+      get :new, params: {stack_id: @stack.to_param, sha: @commit.sha}
       assert_response :success
     end
 
     test ":new works for not yet deployed stacks" do
       @stack = shipit_stacks(:undeployed_stack)
-      get :new, stack_id: @stack.to_param, sha: @stack.commits.last.sha
+      get :new, params: {stack_id: @stack.to_param, sha: @stack.commits.last.sha}
     end
 
     test ":new shows a warning if a deploy is already running" do
       shipit_deploys(:shipit_running).update_column(:status, 'running')
 
-      get :new, stack_id: @stack.to_param, sha: @commit.sha
+      get :new, params: {stack_id: @stack.to_param, sha: @commit.sha}
       assert_response :success
       assert_select '.warning.concurrent-deploy h2' do |elements|
         assert_equal 'Lando Walrussian is already deploying!', elements.first.text
@@ -44,19 +44,19 @@ module Shipit
 
     test ":create persists a new deploy" do
       assert_difference '@stack.deploys.count', 1 do
-        post :create, stack_id: @stack.to_param, deploy: {until_commit_id: @commit.id}
+        post :create, params: {stack_id: @stack.to_param, deploy: {until_commit_id: @commit.id}}
       end
     end
 
     test ":create can receive an :env hash" do
       env = {'SAFETY_DISABLED' => '1'}
-      post :create, stack_id: @stack.to_param, deploy: {until_commit_id: @commit.id, env: env}
+      post :create, params: {stack_id: @stack.to_param, deploy: {until_commit_id: @commit.id, env: env}}
       new_deploy = Deploy.last
       assert_equal env, new_deploy.env
     end
 
     test ":create ignore :env keys not declared in the deploy spec" do
-      post :create, stack_id: @stack.to_param, deploy: {until_commit_id: @commit.id, env: {'H4X0R' => '1'}}
+      post :create, params: {stack_id: @stack.to_param, deploy: {until_commit_id: @commit.id, env: {'H4X0R' => '1'}}}
       new_deploy = Deploy.last
       assert_equal({}, new_deploy.env)
     end
@@ -65,7 +65,7 @@ module Shipit
       shipit_deploys(:shipit_running).update_column(:status, 'running')
 
       assert_difference '@stack.deploys.count', 1 do
-        post :create, stack_id: @stack.to_param, deploy: {until_commit_id: @commit.id}, force: true
+        post :create, params: {stack_id: @stack.to_param, deploy: {until_commit_id: @commit.id}, force: 'true'}
       end
     end
 
@@ -73,26 +73,26 @@ module Shipit
       shipit_deploys(:shipit_running).update_column(:status, 'running')
 
       assert_no_difference '@stack.deploys.count' do
-        post :create, stack_id: @stack.to_param, deploy: {until_commit_id: @commit.id}
+        post :create, params: {stack_id: @stack.to_param, deploy: {until_commit_id: @commit.id}}
       end
       assert_redirected_to new_stack_deploy_path(@stack, sha: @commit.sha)
     end
 
     test ":create redirects to the new deploy" do
-      post :create, stack_id: @stack.to_param, deploy: {until_commit_id: @commit.id}
+      post :create, params: {stack_id: @stack.to_param, deploy: {until_commit_id: @commit.id}}
       new_deploy = Deploy.last
       assert_redirected_to stack_deploy_path(@stack, new_deploy)
     end
 
     test ":rollback is success" do
-      get :rollback, stack_id: @stack.to_param, id: @deploy.id
+      get :rollback, params: {stack_id: @stack.to_param, id: @deploy.id}
       assert_response :success
     end
 
     test ":rollback shows a warning if a deploy is already running" do
       shipit_deploys(:shipit_running).update_column(:status, 'running')
 
-      get :rollback, stack_id: @stack.to_param, id: @deploy.id
+      get :rollback, params: {stack_id: @stack.to_param, id: @deploy.id}
       assert_response :success
       assert_select '.warning.concurrent-deploy h2' do |elements|
         assert_equal 'Lando Walrussian is already deploying!', elements.first.text

data/test/controllers/rollbacks_controller_test.rb

@@ -11,37 +11,37 @@ module Shipit
 
     test ":create persists a new rollback" do
       assert_difference '@stack.rollbacks.count', 1 do
-        post :create, stack_id: @stack.to_param, rollback: {parent_id: @deploy.id}
+        post :create, params: {stack_id: @stack.to_param, rollback: {parent_id: @deploy.id}}
       end
     end
 
     test ":create can receive an :env hash" do
       env = {'SAFETY_DISABLED' => '1'}
-      post :create, stack_id: @stack.to_param, rollback: {parent_id: @deploy.id, env: env}
+      post :create, params: {stack_id: @stack.to_param, rollback: {parent_id: @deploy.id, env: env}}
       new_rollback = Rollback.last
       assert_equal env, new_rollback.env
     end
 
     test ":create ignore :env keys not declared in the deploy spec" do
-      post :create, stack_id: @stack.to_param, rollback: {parent_id: @deploy.id, env: {'H4X0R' => '1'}}
+      post :create, params: {stack_id: @stack.to_param, rollback: {parent_id: @deploy.id, env: {'H4X0R' => '1'}}}
       new_rollback = Rollback.last
       assert_equal({}, new_rollback.env)
     end
 
     test ":create redirects to the new deploy" do
-      post :create, stack_id: @stack.to_param, rollback: {parent_id: @deploy.id}
+      post :create, params: {stack_id: @stack.to_param, rollback: {parent_id: @deploy.id}}
       assert_redirected_to stack_deploy_path(@stack, Rollback.last)
     end
 
     test ":create locks deploys" do
-      post :create, stack_id: @stack.to_param, rollback: {parent_id: @deploy.id}
+      post :create, params: {stack_id: @stack.to_param, rollback: {parent_id: @deploy.id}}
       assert @stack.reload.locked?
     end
 
     test ":create redirects back to the :new page if there is an active deploy" do
       shipit_deploys(:shipit_running).update_column(:status, 'running')
       assert_no_difference '@stack.deploys.count' do
-        post :create, stack_id: @stack.to_param, rollback: {parent_id: @deploy.id}
+        post :create, params: {stack_id: @stack.to_param, rollback: {parent_id: @deploy.id}}
       end
       assert_redirected_to rollback_stack_deploy_path(@stack, @deploy)
     end
@@ -49,7 +49,7 @@ module Shipit
     test ":create with `force` option ignore the active deploys" do
       shipit_deploys(:shipit_running).update_column(:status, 'running')
       assert_difference '@stack.deploys.count', 1 do
-        post :create, stack_id: @stack.to_param, rollback: {parent_id: @deploy.id}, force: true
+        post :create, params: {stack_id: @stack.to_param, rollback: {parent_id: @deploy.id}, force: 'true'}
       end
       assert_redirected_to stack_deploy_path(@stack, Rollback.last)
     end