rocketjob_mission_control 3.0.0.rc1 → 3.0.0

data/spec/controllers/jobs/failures_controller_spec.rb

@@ -1,82 +0,0 @@
-require 'rails_helper'
-
-module RocketJobMissionControl
-  RSpec.describe Jobs::FailuresController do
-    routes { Engine.routes }
-
-    describe "GET #index" do
-      describe "with a failed job" do
-        let(:job) { spy(failed?: true, id: 42) }
-        let(:slice_errors) do
-          [
-            {
-              '_id'     =>
-                {
-                  'error_class' => 'BoomError',
-                },
-              'message' => ['boom'],
-              'count'   => '1337',
-            },
-          ]
-        end
-        let(:selected_exception) { spy(count: 1337, first: current_failure) }
-        let(:current_failure) { {'exception' => 'Doh! Something blew up!'} }
-
-        before do
-          allow(RocketJob::Job).to receive(:find).and_return(job)
-          allow(job).to receive_message_chain('input.collection.aggregate') { slice_errors }
-          allow(job).to receive_message_chain('input.collection.find.limit') { selected_exception }
-          get :index, job_id: job.id
-        end
-
-        context 'with slice errors' do
-          it 'succeeds' do
-            expect(response).to be_success
-          end
-          it 'returns the job' do
-            expect(assigns(:job)).to eq(job)
-          end
-          it 'returns the errors' do
-            expect(assigns(:slice_errors)).to eq(slice_errors)
-          end
-          it 'returns the first exception' do
-            expect(assigns(:failure_exception)).to eq(current_failure['exception'])
-          end
-        end
-
-        context 'with no slice errors' do
-          let(:slice_errors) { [] }
-
-          it 'succeeds' do
-            expect(response).to be_success
-          end
-          it 'returns the job' do
-            expect(assigns(:job)).to eq(job)
-          end
-          it 'returns no errors' do
-            expect(assigns(:slice_errors)).to eq(slice_errors)
-          end
-          it 'returns no exception' do
-            expect(assigns(:failure_exception)).to be_nil
-          end
-          it 'notifies the user' do
-            expect(flash[:notice]).to eq(I18n.t(:no_errors, scope: [:job, :failures]))
-          end
-        end
-      end
-
-      describe "with a job that is not failed" do
-        let(:job) { spy(failed?: false, id: 42) }
-
-        before do
-          allow(RocketJob::Job).to receive(:find).and_return(job)
-          get :index, job_id: job.id
-        end
-
-        it "redirects to the job" do
-          expect(response).to redirect_to(job_path(job.id))
-        end
-      end
-    end
-  end
-end

data/spec/controllers/jobs/index_filters_controller_spec.rb

@@ -1,66 +0,0 @@
-require 'rails_helper'
-
-module RocketJobMissionControl
-  module Jobs
-    RSpec.describe IndexFiltersController do
-      routes { Engine.routes }
-
-      states = %w(running paused completed aborted failed queued scheduled)
-
-      states.each_with_index do |state, i|
-        describe "GET ##{state}" do
-          describe "with no #{state} jobs" do
-            before do
-              get state.to_sym
-            end
-
-            it "succeeds" do
-              expect(response.status).to be(200)
-            end
-
-            it 'renders template' do
-              expect(response).to render_template(state)
-            end
-
-            it "returns no jobs" do
-              expect(assigns(:jobs).count).to eq(0)
-            end
-          end
-
-          describe "with #{state} jobs" do
-            let(:not_state) { states[i-1] }
-            let(:state_job) {
-              if state == 'scheduled'
-                RocketJob::Job.create(state: :queued, run_at: Date.tomorrow)
-              else
-                RocketJob::Job.create(state: state)
-              end
-            }
-
-            before do
-              RocketJob::Job.create(state: not_state)
-              get state.to_sym
-            end
-
-            after do
-              RocketJob::Server.delete_all
-              RocketJob::Job.delete_all
-            end
-
-            it "succeeds" do
-              expect(response.status).to be(200)
-            end
-
-            it 'renders template' do
-              expect(response).to render_template(state)
-            end
-
-            it "grabs a filtered list of rocket jobs" do
-              expect(assigns(:jobs)).to match_array([state_job])
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/controllers/jobs_controller_spec.rb

@@ -1,172 +0,0 @@
-require 'rails_helper'
-
-module RocketJobMissionControl
-  RSpec.shared_examples "a jobs update controller" do
-    describe "with an invalid job id" do
-      before do
-        RocketJob::Job.delete_all
-        allow(RocketJob::Job).to receive(:find).and_return(nil)
-        do_action
-      end
-
-      it "redirects" do
-        expect(response).to redirect_to(jobs_path)
-      end
-
-      it "adds a flash alert message" do
-        expect(flash[:alert]).to eq(I18n.t(:failure, scope: [:job, :find], id: 42))
-      end
-    end
-  end
-
-  RSpec.describe JobsController do
-    routes { Engine.routes }
-
-    [:pause, :resume, :abort, :retry, :fail].each do |state|
-      describe "PATCH ##{state}" do
-        it_behaves_like "a jobs update controller" do
-          let(:do_action) { patch state, id: 42, job: {id: 42, priority: 12} }
-        end
-
-        describe "with a valid job id" do
-          let(:job) { spy(id: 42, to_param: 42) }
-
-          before do
-            allow(RocketJob::Job).to receive(:find).and_return(job)
-            patch state, id: 42, job: {id: 42, priority: 12}
-          end
-
-          it "redirects to the job" do
-            expect(response).to redirect_to(job_path(42))
-          end
-
-          it "transitions the job" do
-            expect(job).to have_received("#{state}!".to_sym)
-          end
-        end
-      end
-    end
-
-    describe 'PATCH #run_now' do
-      let(:scheduled_job) { spy(id: 12, run_at: 2.days.from_now) }
-
-      before do
-        allow(RocketJob::Job).to receive(:find).and_return(scheduled_job)
-        patch :run_now, id: 12
-      end
-
-      it 'redirects to the scheduled_jobs_path' do
-        expect(response).to redirect_to(scheduled_jobs_path)
-      end
-
-      it 'updates run_at' do
-        expect(scheduled_job).to have_received(:update_attribute).with(:run_at, nil)
-      end
-    end
-
-
-    describe "PATCH #update" do
-      it_behaves_like "a jobs update controller" do
-        let(:do_action) { patch :update, id: 42, job: {id: 42, priority: 12} }
-      end
-
-      describe "with a valid job id" do
-        let(:job) { spy(id: 42, to_param: 42) }
-        let(:job_sanitizer) { spy() }
-
-        before do
-          allow(RocketJob::Job).to receive(:find).and_return(job)
-          allow(JobSanitizer).to receive(:new).and_return(job_sanitizer)
-          patch :update, id: 42, job: {id: 42, priority: 12}
-        end
-
-        it "redirects to the job" do
-          expect(response).to redirect_to(job_path(42))
-        end
-
-        it "updates the job correctly" do
-          expect(job).to have_received(:update_attributes)
-        end
-
-        it "calls sanitize" do
-          expect(job_sanitizer).to have_received(:sanitize)
-        end
-      end
-    end
-
-    describe "GET #show" do
-      let(:result) { spy(sort: []) }
-
-      before do
-        allow(RocketJob::Job).to receive(:limit).and_return(result)
-      end
-
-      describe "with an invalid job id" do
-        before do
-          allow(RocketJob::Job).to receive(:find).and_return(nil)
-          get :show, id: 42
-        end
-
-        it "redirects" do
-          expect(response).to redirect_to(jobs_path)
-        end
-
-        it "adds a flash alert message" do
-          expect(flash[:alert]).to eq(I18n.t(:failure, scope: [:job, :find], id: 42))
-        end
-      end
-
-      describe "with a valid job id" do
-        before do
-          allow(RocketJob::Job).to receive(:find).and_return('job')
-          get :show, id: 42
-        end
-
-        it "succeeds" do
-          expect(response.status).to be(200)
-        end
-
-        it "assigns the job" do
-          expect(assigns(:job)).to be_present
-        end
-      end
-    end
-
-    describe "GET #index" do
-      describe "with no jobs" do
-        before do
-          get :index
-        end
-
-        it "succeeds" do
-          expect(response.status).to be(200)
-        end
-
-        it "returns no jobs" do
-          expect(assigns(:jobs).count).to eq(0)
-        end
-      end
-
-      describe "with jobs" do
-        let(:jobs) { ['fake_job1', 'fake_job2'] }
-
-        before do
-          allow(RocketJob::Job).to receive(:sort).and_return(jobs)
-          get :index
-        end
-
-        it "succeeds" do
-          expect(response.status).to be(200)
-        end
-
-        it "grabs a sorted list of rocket jobs" do
-          expect(RocketJob::Job).to have_received(:sort).with(_id: :desc)
-        end
-
-        it "returns the jobs" do
-          expect(assigns(:jobs)).to eq(jobs)
-        end
-      end
-    end
-  end
-end

data/spec/controllers/workers/index_filters_controller_spec.rb

@@ -1,59 +0,0 @@
-require 'rails_helper'
-
-module RocketJobMissionControl
-  module Servers
-    RSpec.describe IndexFiltersController do
-      routes { Engine.routes }
-
-      states = %w(starting running paused stopping)
-
-      states.each_with_index do |state, i|
-        describe "GET ##{state}" do
-          describe "with no #{state} servers" do
-            before do
-              get state.to_sym
-            end
-
-            it "succeeds" do
-              expect(response.status).to be(200)
-            end
-
-            it 'renders template' do
-              expect(response).to render_template(state)
-            end
-
-            it "returns no jobs" do
-              expect(assigns(:servers).count).to eq(0)
-            end
-          end
-
-          describe "with #{state} servers" do
-            let(:not_state) { states[i-1] }
-            let!(:state_dirmon) { RocketJob::Server.create!(state: state) }
-
-            before do
-              RocketJob::Server.create!(state: not_state)
-              get state.to_sym
-            end
-
-            after do
-              RocketJob::Server.delete_all
-            end
-
-            it "succeeds" do
-              expect(response.status).to be(200)
-            end
-
-            it 'renders template' do
-              expect(response).to render_template(state)
-            end
-
-            it "grabs a filtered list of servers" do
-              expect(assigns(:servers)).to match_array([state_dirmon])
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/controllers/workers_controller_spec.rb

@@ -1,125 +0,0 @@
-require 'rails_helper'
-
-module RocketJobMissionControl
-  RSpec.describe ServersController do
-    routes { Engine.routes }
-
-    [:stop, :pause, :resume].each do |server_action|
-      describe "PATCH ##{server_action}" do
-        describe "with a valid server id" do
-          let(:server) { spy(id: 42, to_param: 42) }
-
-          before do
-            allow(RocketJob::Server).to receive(:find).and_return(server)
-            patch server_action, id: server.id
-          end
-
-          it "redirects to servers" do
-            expect(response).to redirect_to(servers_path)
-          end
-
-          it "displays a flash message" do
-            expect(flash[:notice]).to eq(I18n.t(:success, scope: [:server, server_action]))
-          end
-
-          it "#{server_action} the server" do
-            expect(server).to have_received("#{server_action}!".to_sym)
-          end
-        end
-
-        describe "when the server fails to #{server_action}" do
-          before do
-            server = spy("#{server_action}!".to_sym => false)
-            allow(RocketJob::Server).to receive(:find).and_return(server)
-            patch server_action, id: server.id
-          end
-
-          it "redirects to servers" do
-            expect(response).to redirect_to(servers_path)
-          end
-
-          it "displays a flash message" do
-            expect(flash[:alert]).to eq(I18n.t(:failure, scope: [:server, server_action]))
-          end
-        end
-      end
-    end
-
-    describe "PATCH #update_all" do
-      RocketJobMissionControl::ServersController::VALID_STATES.each do |server_action, action_message|
-        context "with '#{server_action}' as the server_action param" do
-          before do
-            allow(RocketJob::Server).to receive(server_action.to_sym)
-            patch :update_all, server_action: server_action
-          end
-
-          it "redirects to servers" do
-            expect(response).to redirect_to(servers_path)
-          end
-          it "displays a success message" do
-            state_message = I18n.t(:success, scope: [:server, :update_all], server_action: action_message)
-            expect(flash[:notice]).to eq(state_message)
-          end
-          it "does not display an error message" do
-            expect(flash[:alert]).to be_nil
-          end
-        end
-      end
-
-      context "with an invalid server_action param" do
-        before do
-          patch :update_all, server_action: :bad_server_action
-        end
-
-        it "redirects to servers" do
-          expect(response).to redirect_to(servers_path)
-        end
-        it "does not display a success message" do
-          expect(flash[:notice]).to be_nil
-        end
-        it "displays an error message" do
-          expect(flash[:alert]).to eq(I18n.t(:invalid, scope: [:server, :update_all]))
-        end
-      end
-    end
-
-    describe "DELETE #destroy" do
-      describe "with a valid server id" do
-        let(:server) { spy(id: 42, to_param: 42) }
-
-        before do
-          allow(RocketJob::Server).to receive(:find).and_return(server)
-          delete :destroy, id: server.id
-        end
-
-        it "redirects to servers" do
-          expect(response).to redirect_to(servers_path)
-        end
-
-        it "displays a flash message" do
-          expect(flash[:notice]).to eq(I18n.t(:success, scope: [:server, :destroy]))
-        end
-
-        it "destroys the server" do
-          expect(server).to have_received(:destroy)
-        end
-      end
-
-      describe "when the server fails to be destroyed" do
-        before do
-          server = spy(destroy: false)
-          allow(RocketJob::Server).to receive(:find).and_return(server)
-          delete :destroy, id: server.id
-        end
-
-        it "redirects to servers" do
-          expect(response).to redirect_to(servers_path)
-        end
-
-        it "displays a flash message" do
-          expect(flash[:alert]).to eq(I18n.t(:failure, scope: [:server, :destroy]))
-        end
-      end
-    end
-  end
-end