rocketjob_mission_control 1.1.0 → 1.2.0

data/spec/controllers/dirmon_entries_controller_spec.rb

@@ -0,0 +1,451 @@
+require 'rails_helper'
+
+class FakeButGoodJob < RocketJob::Job
+
+  def perform(id)
+    id
+  end
+end
+
+module RocketJobMissionControl
+  RSpec.describe DirmonEntriesController do
+    routes { Engine.routes }
+
+    let(:dirmon_list) { spy(sort: []) }
+
+    before do
+      allow(RocketJob::DirmonEntry).to receive(:limit).and_return(dirmon_list)
+    end
+
+    describe 'PATCH #enable' do
+      before do
+        patch :enable, id: existing_dirmon.id
+      end
+
+      let(:existing_dirmon) do
+        RocketJob::DirmonEntry.create!(
+          name:      'Test',
+          job_class_name:  'FakeButGoodJob',
+          pattern:      'the_path',
+          arguments: [ 42 ].to_json,
+          state: starting_state,
+        )
+      end
+
+      context 'when transition is allowed' do
+        let(:starting_state) { 'pending' }
+
+        it { expect(response).to redirect_to(dirmon_entry_path(existing_dirmon.id)) }
+
+        it 'changes the state to enabled' do
+          expect(existing_dirmon.reload.state).to eq(:enabled)
+        end
+      end
+
+      context 'when transition is not allowed' do
+        let(:starting_state) { 'enabled' }
+
+        it { expect(response).to render_template(:show) }
+
+        it 'alerts the user' do
+          expect(flash[:alert]).to eq(I18n.t(:failure, scope: [:dirmon_entry, :enable]))
+        end
+      end
+    end
+
+    describe 'PATCH #disable' do
+      let(:existing_dirmon) do
+        RocketJob::DirmonEntry.create!(
+          name:      'Test',
+          job_class_name:  'FakeButGoodJob',
+          pattern:      'the_path',
+          arguments: [ 42 ].to_json,
+          state: starting_state,
+        )
+      end
+
+      before do
+        patch :disable, id: existing_dirmon.id
+      end
+
+      context 'when transition is allowed' do
+        let(:starting_state) { :enabled }
+
+        it { expect(response).to redirect_to(dirmon_entry_path(existing_dirmon.id)) }
+
+        it "changes the state to disabled" do
+          expect(existing_dirmon.reload.state).to eq(:disabled)
+        end
+      end
+
+      context 'when transition is not allowed' do
+        let(:starting_state) { :disabled }
+
+        it { expect(response).to render_template(:show) }
+
+        it 'alerts the user' do
+          expect(flash[:alert]).to eq(I18n.t(:failure, scope: [:dirmon_entry, :disable]))
+        end
+      end
+    end
+
+    describe 'GET #new' do
+      before do
+        get :new
+      end
+
+      it { expect(response.status).to eq(200) }
+
+      it 'assigns a new entry' do
+        expect(assigns(:dirmon_entry)).to be_present
+        expect(assigns(:dirmon_entry)).to_not be_persisted
+      end
+    end
+
+    describe 'PATCH #update' do
+      let(:existing_dirmon) do
+        RocketJob::DirmonEntry.create!(
+          name:      'Test',
+          job_class_name:  'FakeButGoodJob',
+          pattern:      'the_path',
+          arguments: [ 42 ].to_json
+        )
+      end
+
+      before do
+        patch :update, id: existing_dirmon.id, rocket_job_dirmon_entry: dirmon_params
+      end
+
+      context 'with valid parameters' do
+        let(:dirmon_params) do
+          {
+            pattern: 'the_path2',
+            job_class_name:  'FakeButGoodJob',
+            arguments: [ 42 ].to_json
+          }
+        end
+
+        it 'redirects to the updated entry' do
+          expect(response).to redirect_to(dirmon_entry_path(existing_dirmon))
+        end
+
+        it 'updates the entry' do
+          expect(existing_dirmon.reload.pattern).to eq('the_path2')
+        end
+
+        it 'displays a success message' do
+          expect(flash[:success]).to eq(I18n.t(:success, scope: [:dirmon_entry, :update]))
+        end
+      end
+
+      context 'with invalid parameters' do
+        let(:dirmon_params) do
+          {
+            job_class_name: 'FakeAndBadJob',
+          }
+        end
+
+        it 'renders the edit template' do
+          expect(response.status).to eq(200)
+          expect(response).to render_template(:edit)
+        end
+
+        it 'has errors on the entry' do
+          expect(assigns(:dirmon_entry)).to_not be_valid
+        end
+
+        it 'loads the other entries' do
+          expect(dirmon_list).to have_received(:sort)
+        end
+
+        context 'with invalid arguments json' do
+          let(:dirmon_params) do
+            {
+              name: 'Test',
+              job_class_name: 'FakeButGoodJob',
+              arguments: "['42']",
+            }
+          end
+
+          it 'renders the new template' do
+            expect(response.status).to eq(200)
+            expect(response).to render_template(:edit)
+          end
+
+          it 'has errors on arguments' do
+            expect(assigns(:dirmon_entry).errors[:arguments]).to be_present
+          end
+
+          it 'loads the other entries' do
+            expect(dirmon_list).to have_received(:sort)
+          end
+        end
+      end
+    end
+
+    describe 'POST #create' do
+      context 'with valid parameters' do
+        let(:dirmon_params) do
+          {
+            name: 'Test',
+            pattern: '/files/',
+            job_class_name: 'FakeButGoodJob',
+            arguments: [ 42 ].to_json,
+            properties: { description: '', priority: 42 },
+          }
+        end
+
+        before do
+          post :create, rocket_job_dirmon_entry: dirmon_params
+        end
+
+        it 'creates the entry' do
+          expect(assigns(:dirmon_entry)).to be_persisted
+        end
+
+        it 'has no errors' do
+          expect(assigns(:dirmon_entry).errors.messages).to be_empty
+        end
+
+        it 'redirects to created entry' do
+          expect(response).to redirect_to(dirmon_entry_path(assigns(:dirmon_entry)))
+        end
+
+        it 'does not load all entries' do
+          expect(dirmon_list).to_not have_received(:sort)
+        end
+
+        it 'does not save blank properties' do
+          expect(assigns(:dirmon_entry).properties[:description]).to eq(nil)
+        end
+
+        it 'saves properties' do
+          expect(assigns(:dirmon_entry).properties[:priority]).to eq('42')
+        end
+
+        [:name, :pattern, :job_class_name].each do |attribute|
+          it "assigns the correct value for #{attribute}" do
+            expect(assigns(:dirmon_entry)[attribute]).to eq(dirmon_params[attribute])
+          end
+        end
+
+        it 'persists arguments correctly' do
+          expect(assigns(:dirmon_entry).arguments).to eq([42])
+        end
+      end
+
+      context 'with invalid parameters' do
+        let(:dirmon_params) do
+          {
+            name: 'Test',
+            job_class_name: 'FakeAndBadJob',
+            arguments: [ 42 ].to_json,
+          }
+        end
+
+        before do
+          post :create, rocket_job_dirmon_entry: dirmon_params
+        end
+
+        context 'on model attributes' do
+          it 'renders the new template' do
+            expect(response.status).to eq(200)
+            expect(response).to render_template(:new)
+          end
+
+          it 'has errors on the entry' do
+            expect(assigns(:dirmon_entry)).to_not be_valid
+          end
+
+          it 'loads the other entries' do
+            expect(dirmon_list).to have_received(:sort)
+          end
+        end
+
+        context 'with invalid arguments json' do
+          let(:dirmon_params) do
+            {
+              name: 'Test',
+              job_class_name: 'FakeButGoodJob',
+              arguments: "['42']",
+            }
+          end
+
+          it 'renders the new template' do
+            expect(response.status).to eq(200)
+            expect(response).to render_template(:new)
+          end
+
+          it 'has errors on arguments' do
+            expect(assigns(:dirmon_entry).errors[:arguments]).to be_present
+          end
+
+          it 'loads the other entries' do
+            expect(dirmon_list).to have_received(:sort)
+          end
+        end
+      end
+    end
+
+    describe 'GET #edit' do
+      before do
+        @entry = RocketJob::DirmonEntry.create(
+            name: 'Test',
+            pattern: '/files/',
+            job_class_name: 'FakeButGoodJob',
+            arguments: [ 42 ]
+        )
+        get :edit, id: @entry.id
+      end
+
+      it { expect(response.status).to eq(200) }
+
+      it 'assigns the entry' do
+        expect(assigns(:dirmon_entry)).to be_present
+        expect(assigns(:dirmon_entry)).to eq(@entry)
+      end
+    end
+
+    describe 'GET #show' do
+      describe "with an invalid id" do
+        before do
+          allow(RocketJob::DirmonEntry).to receive(:find).and_return(nil)
+          get :show, id: 42
+        end
+
+        it "redirects" do
+          expect(response).to redirect_to(dirmon_entries_path)
+        end
+
+        it "adds a flash alert message" do
+          expect(flash[:alert]).to eq(I18n.t(:failure, scope: [:dirmon_entry, :find], id: 42))
+        end
+      end
+
+      describe "with a valid id" do
+        before do
+          allow(RocketJob::DirmonEntry).to receive(:find).and_return('entry')
+          get :show, id: 42
+        end
+
+        it "succeeds" do
+          expect(response.status).to be(200)
+        end
+
+        it "assigns the entry" do
+          expect(assigns(:dirmon_entry)).to be_present
+        end
+
+        it "assigns the entries" do
+          expect(assigns(:dirmons)).to eq([])
+        end
+
+        it "grabs a sorted list" do
+          expect(dirmon_list).to have_received(:sort).with(created_at: :desc)
+        end
+      end
+    end
+
+    describe 'DELETE #destroy' do
+      let(:existing_dirmon) do
+        RocketJob::DirmonEntry.create!(
+          name:      'Test',
+          job_class_name:  'FakeButGoodJob',
+          pattern:   'the_path',
+          arguments: [ 42 ].to_json
+        )
+      end
+
+      describe 'with a valid id' do
+        before { delete :destroy, id: existing_dirmon.id }
+
+        it 'redirects to index' do
+          expect(response).to redirect_to(dirmon_entries_path)
+        end
+
+        it 'displays a success message' do
+          expect(flash[:success]).to eq(I18n.t(:success, scope: [:dirmon_entry, :destroy]))
+        end
+
+        it 'deletes the entry' do
+          expect(RocketJob::DirmonEntry.find(existing_dirmon.id)).to eq(nil)
+        end
+      end
+    end
+
+    describe 'GET #index' do
+      describe "with no entries" do
+        before do
+          get :index
+        end
+
+        it "succeeds" do
+          expect(response.status).to be(200)
+        end
+
+        it "grabs a sorted list of entries" do
+          expect(dirmon_list).to have_received(:sort).with(created_at: :desc)
+        end
+
+        it "returns no entries" do
+          expect(assigns(:dirmons)).to eq([])
+        end
+      end
+
+      describe "with jobs" do
+        let(:dirmon_list) { spy(sort: dirmons) }
+        let(:dirmons) { ['fake_dirmon1', 'fake_dirmon2'] }
+
+        describe "with no parameters" do
+          before { get :index }
+
+          it "succeeds" do
+            expect(response.status).to be(200)
+          end
+
+          it "grabs a sorted list of entries" do
+            expect(dirmon_list).to have_received(:sort).with(created_at: :desc)
+          end
+
+          it "returns the entries" do
+            expect(assigns(:dirmons)).to match_array(dirmons)
+          end
+        end
+
+        describe "with a state filter" do
+          before { get :index, states: states}
+
+          context "that is empty" do
+            let(:states) { [] }
+
+            it { expect(response.status).to be(200) }
+
+            it "grabs a sorted list" do
+              expect(dirmon_list).to have_received(:sort).with(created_at: :desc)
+            end
+
+            it "returns the entries" do
+              expect(assigns(:dirmons)).to match_array(dirmons)
+            end
+          end
+
+          context "with a state" do
+            let(:query_spy) { spy(where: dirmons) }
+            let(:dirmon_list) { spy(sort: query_spy) }
+            let(:states) { ['enabled'] }
+
+            it { expect(response.status).to be(200) }
+
+            it "grabs a filtered list" do
+              expect(query_spy).to have_received(:where).with(state: ['enabled'])
+            end
+
+            it "returns the entries" do
+              expect(assigns(:dirmons)).to match_array(dirmons)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/controllers/jobs/failures_controller_spec.rb

@@ -0,0 +1,60 @@
+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
+
+        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
+
+      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/dummy/config/environments/test.rb

@@ -13,7 +13,7 @@ Rails.application.configure do
   config.eager_load = false
 
   # Configure static asset server for tests with Cache-Control for performance.
-  config.serve_static_assets  = true
+  config.serve_static_files   = true
   config.static_cache_control = 'public, max-age=3600'
 
   # Show full error reports and disable caching.

data/spec/dummy/config/mongo.yml

@@ -0,0 +1,15 @@
+default_options: &default_options
+  :w:                           1
+  :pool_size:                   5
+  :pool_timeout:                5
+  :connect_timeout:             5
+  :reconnect_attempts:          53
+  :reconnect_retry_seconds:     0.1
+  :reconnect_retry_multiplier:  2
+  :reconnect_max_retry_seconds: 5
+  :read:                        :nearest
+
+test:
+  uri: mongodb://localhost:27017/rocket_job_mission_control
+  options:
+    <<: *default_options

data/spec/dummy/log/development.log

@@ -0,0 +1,2 @@
+MONGODB [DEBUG] Logging level is currently :debug which could negatively impact client-side performance. You should set your logging level no lower than :info in production.
+MONGODB (0.5ms) admin['$cmd'].find({:isMaster=>1}).limit(-1)