rocketjob_mission_control 3.0.0.rc1 → 3.0.0

data/app/views/rocket_job_mission_control/servers/index_filters/running.html.haml

@@ -1,37 +0,0 @@
-#servers
-  .server-list
-    .list
-      .row
-        .col-md-6
-          %h2 Running Servers
-        .col-md-6
-          .col-sm-10
-            .server-collection-actions
-              - if @servers.present?
-                %ol.pull-right
-                  .btn-group
-                    - [:stop_all, :pause_all, :resume_all, :destroy_zombies].each do |action|
-                      = link_to("#{action.to_s.humanize.capitalize}",
-                        rocket_job_mission_control.update_all_servers_path(server_action: action),
-                        method: :patch,
-                        data: { confirm: t(:confirm, scope: [:server, :update_all], action: action.to_s.singularize.humanize.downcase) },
-                        class: 'btn btn-default')
-          .col-sm-2.pull-right
-            .btn.btn-default.pull-right.dt-reload{ data: { behavior: 'reload' } }
-              %i.fa.fa-refresh
-      %table.table.datatable.servers-datatable{ style: "width: 100%", data: { source: "#{running_servers_url(format: 'json')}" } }
-        %thead
-          %tr
-            %th Hostname : PID
-            %th Workers (Current/Max)
-            %th Started
-            %th Heartbeat
-            %th Actions
-        %tbody
-
-:javascript
-  jQuery(function() {
-    new RjmcDatatable(
-      $('.servers-datatable'),
-      [{data: '0'}, {data: '1', orderable: false}, {data: '2'}, {data: '3'}, {data: '4', orderable: false}]);
-  });

data/app/views/rocket_job_mission_control/servers/index_filters/starting.html.haml

@@ -1,37 +0,0 @@
-#servers
-  .server-list
-    .list
-      .row
-        .col-md-6
-          %h2 Starting Servers
-        .col-md-6
-          .col-sm-10
-            .server-collection-actions
-              - if @servers.present?
-                %ol.pull-right
-                  .btn-group
-                    - [:stop_all, :pause_all, :resume_all, :destroy_zombies].each do |action|
-                      = link_to("#{action.to_s.humanize.capitalize}",
-                        rocket_job_mission_control.update_all_servers_path(server_action: action),
-                        method: :patch,
-                        data: { confirm: t(:confirm, scope: [:server, :update_all], action: action.to_s.singularize.humanize.downcase) },
-                        class: 'btn btn-default')
-          .col-sm-2.pull-right
-            .btn.btn-default.pull-right.dt-reload{ data: { behavior: 'reload' } }
-              %i.fa.fa-refresh
-      %table.table.datatable.servers-datatable{ style: "width: 100%", data: { source: "#{starting_servers_url(format: 'json')}" } }
-        %thead
-          %tr
-            %th Hostname : PID
-            %th Workers (Current/Max)
-            %th Started
-            %th Heartbeat
-            %th Actions
-        %tbody
-
-:javascript
-  jQuery(function() {
-    new RjmcDatatable(
-      $('.servers-datatable'),
-      [{data: '0'}, {data: '1', orderable: false}, {data: '2'}, {data: '3'}, {data: '4', orderable: false}]);
-  });

data/app/views/rocket_job_mission_control/servers/index_filters/stopping.html.haml

@@ -1,37 +0,0 @@
-#servers
-  .server-list
-    .list
-      .row
-        .col-md-6
-          %h2 Stopping Servers
-        .col-md-6
-          .col-sm-10
-            .server-collection-actions
-              - if @servers.present?
-                %ol.pull-right
-                  .btn-group
-                    - [:pause_all, :resume_all, :destroy_zombies].each do |action|
-                      = link_to("#{action.to_s.humanize.capitalize}",
-                        rocket_job_mission_control.update_all_servers_path(server_action: action),
-                        method: :patch,
-                        data: { confirm: t(:confirm, scope: [:server, :update_all], action: action.to_s.singularize.humanize.downcase) },
-                        class: 'btn btn-default')
-          .col-sm-2.pull-right
-            .btn.btn-default.pull-right.dt-reload{ data: { behavior: 'reload' } }
-              %i.fa.fa-refresh
-      %table.table.datatable.servers-datatable{ style: "width: 100%", data: { source: "#{stopping_servers_url(format: 'json')}" } }
-        %thead
-          %tr
-            %th Hostname : PID
-            %th Workers (Current/Max)
-            %th Started
-            %th Heartbeat
-            %th Actions
-        %tbody
-
-:javascript
-  jQuery(function() {
-    new RjmcDatatable(
-      $('.servers-datatable'),
-      [{data: '0'}, {data: '1', orderable: false}, {data: '2'}, {data: '3'}, {data: '4', orderable: false}]);
-  });

data/spec/controllers/application_controller_spec.rb

@@ -1,47 +0,0 @@
-require 'rails_helper'
-
-module RocketJobMissionControl
-  RSpec.describe ApplicationController, type: :controller do
-    controller do
-      def index
-        @time_zone = Time.zone
-
-        render text: 'Time Zoned'
-      end
-    end
-
-    describe "#with_time_zone" do
-      let(:session_params) { {} }
-      let(:expected_time_zone) { 'UTC' }
-
-      before do
-        get :index, {}, session_params
-      end
-
-      context "with a session present" do
-        context "that contains a time zone" do
-          let(:expected_time_zone) { 'America/Los_Angeles' }
-          let(:session_params) { {'time_zone' => expected_time_zone} }
-
-          it "sets the time zone correctly" do
-            expect(assigns(:time_zone).name).to eq(expected_time_zone)
-          end
-        end
-
-        context 'that does not contain a time zone' do
-          let(:session_params) { {'user_id' => '42'} }
-
-          it 'sets the time zone correctly' do
-            expect(assigns(:time_zone).name).to eq(expected_time_zone)
-          end
-        end
-      end
-
-      context "with no session present" do
-        it "sets the time zone correctly" do
-          expect(assigns(:time_zone).name).to eq(expected_time_zone)
-        end
-      end
-    end
-  end
-end

data/spec/controllers/dirmon_entries/index_filters_controller_spec.rb

@@ -1,77 +0,0 @@
-require 'rails_helper'
-
-class AJob < RocketJob::Job
-  def perform
-    23
-  end
-end
-
-module RocketJobMissionControl
-  module DirmonEntries
-    RSpec.describe IndexFiltersController do
-      routes { Engine.routes }
-
-      states = %w(pending enabled failed disabled)
-
-      states.each_with_index do |state, i|
-        describe "GET ##{state}" do
-          describe "with no #{state} dirmons" 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(:dirmons).count).to eq(0)
-            end
-          end
-
-          describe "with #{state} dirmons" do
-            let(:not_state) { states[i-1] }
-            let!(:state_dirmon) {
-              RocketJob::DirmonEntry.create!(
-                state:          state,
-                pattern:        '21',
-                job_class_name: 'AJob'
-              )
-            }
-
-            before do
-              RocketJob::DirmonEntry.create!(
-                name:           'Test',
-                state:          not_state,
-                pattern:        '21',
-                job_class_name: 'AJob'
-              )
-              get state.to_sym
-            end
-
-            after do
-              RocketJob::DirmonEntry.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 dirmons" do
-              expect(assigns(:dirmons)).to match_array([state_dirmon])
-
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/controllers/dirmon_entries_controller_spec.rb

@@ -1,383 +0,0 @@
-require_relative '../rails_helper'
-
-class NoParamsJob < RocketJob::Job
-  def perform
-    100_000
-  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: 'NoParamsJob',
-          pattern:        'the_path',
-          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: 'NoParamsJob',
-          pattern:        'the_path',
-          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
-      let(:entry_params) { {} }
-
-      before do
-        get :new, entry_params
-      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
-
-      context 'with form params' do
-        let(:entry_params) { {rocket_job_dirmon_entry: {name: 'new entry'}} }
-
-        it { expect(response.status).to eq(200) }
-
-        it 'assigns the params to new entry' do
-          expect(assigns(:dirmon_entry)).to be_present
-          expect(assigns(:dirmon_entry).name).to eq('new entry')
-        end
-
-        context 'with a valid job_class_name' do
-          let(:entry_params) { {rocket_job_dirmon_entry: {job_class_name: 'NoParamsJob'}} }
-
-          it { expect(response.status).to eq(200) }
-
-          it 'assigns the job class' do
-            expect(assigns(:dirmon_entry)).to be_present
-            expect(assigns(:dirmon_entry).job_class).to eq(NoParamsJob)
-          end
-        end
-
-        context 'with an invalid job_class_name' do
-          let(:entry_params) { {rocket_job_dirmon_entry: {job_class_name: 'BadJob'}} }
-
-          it { expect(response.status).to eq(200) }
-
-          it 'adds an error' do
-            expect(assigns(:dirmon_entry)).to be_present
-            expect(assigns(:dirmon_entry).errors[:job_class_name]).to be_present
-          end
-        end
-      end
-
-    end
-
-    describe 'PATCH #update' do
-      let(:existing_dirmon) do
-        RocketJob::DirmonEntry.create!(
-          name:           'Test',
-          job_class_name: 'NoParamsJob',
-          pattern:        'the_path',
-        )
-      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: 'NoParamsJob',
-          }
-        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
-
-      end
-    end
-
-    describe 'POST #create' do
-      context 'with valid parameters' do
-
-        [
-          {job_class_name: 'NoParamsJob', expected_value: []}
-        ].each do |arguments|
-          context "and arguments are '#{arguments}'" do
-            let(:dirmon_params) do
-              {
-                name:           'Test',
-                pattern:        '/files/*',
-                job_class_name: arguments[:job_class_name],
-                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
-          end
-        end
-      end
-
-      context 'with invalid parameters' do
-        let(:dirmon_params) do
-          {
-            name:           'Test',
-            job_class_name: 'FakeAndBadJob'
-          }
-        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
-        end
-      end
-    end
-
-    describe 'GET #edit' do
-      before do
-        @entry = RocketJob::DirmonEntry.create(
-          name:           'Test',
-          pattern:        '/files/',
-          job_class_name: 'NoParamsJob'
-        )
-        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
-      end
-    end
-
-    describe 'DELETE #destroy' do
-      let(:existing_dirmon) do
-        RocketJob::DirmonEntry.create!(
-          name:           'Test',
-          job_class_name: 'NoParamsJob',
-          pattern:        'the_path'
-        )
-      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.where(id: existing_dirmon.id).exists?).to eq(false)
-        end
-      end
-    end
-
-    describe 'GET #index' do
-      describe 'with no entries' do
-        before do
-          RocketJob::DirmonEntry.destroy_all
-          get :index
-        end
-
-        it 'succeeds' do
-          expect(response.status).to be(200)
-        end
-
-        it 'returns no entries' do
-          expect(assigns(:dirmons).count).to eq(0)
-        end
-      end
-
-      describe 'with jobs' do
-        let(:dirmons) { ['fake_dirmon1', 'fake_dirmon2'] }
-
-        before do
-          allow(RocketJob::DirmonEntry).to receive(:all).and_return(dirmons)
-          get :index
-        end
-
-        it 'succeeds' do
-          expect(response.status).to be(200)
-        end
-
-        it 'grabs all dirmons with empty where' do
-          expect(RocketJob::DirmonEntry).to have_received(:all)
-        end
-
-        it 'returns the entries' do
-          expect(assigns(:dirmons)).to eq(dirmons)
-        end
-      end
-    end
-  end
-end