foreman-tasks 0.15.1 → 0.15.2

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = '0.15.1'.freeze
+  VERSION = '0.15.2'.freeze
 end

data/package.json

@@ -10,6 +10,8 @@
     "test:current": "node node_modules/.bin/jest --watch",
     "coveralls": "cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js",
     "storybook": "start-storybook -p 6006",
+    "storybook:build": "node --max_old_space_size=2048 ./node_modules/.bin/build-storybook --config-dir .storybook --output-dir .storybook-dist",
+    "storybook:deploy": "surge --project .storybook-dist",
     "create-react-component": "yo react-domain"
   },
   "repository": {
@@ -20,9 +22,9 @@
     "url": "http://projects.theforeman.org/projects/foreman-tasks/issues"
   },
   "devDependencies": {
-    "@storybook/addon-actions": "~3.4.11",
-    "@storybook/addon-knobs": "~3.4.11",
-    "@storybook/react": "~3.4.11",
+    "@storybook/addon-actions": "^5.0.1",
+    "@storybook/addon-knobs": "^5.0.1",
+    "@storybook/react": "^5.0.1",
     "babel-cli": "^6.10.1",
     "babel-core": "^6.26.3",
     "babel-eslint": "^8.2.3",
@@ -44,19 +46,25 @@
     "eslint": "^4.10.0",
     "eslint-import-resolver-babel-module": "^4.0.0",
     "eslint-plugin-patternfly-react": "0.2.0",
+    "identity-obj-proxy": "^3.0.0",
+    "jed": "^1.1.1",
     "jest-cli": "^23.6.0",
     "jest-prop-type-error": "^1.1.0",
-    "patternfly": "^3.59.1",
+    "node-sass": "^4.5.0",
+    "patternfly": "^3.58.0",
     "prettier": "^1.13.5",
     "raf": "^3.4.0",
     "react-redux-test-utils": "^0.1.1",
     "react-remarkable": "^1.1.3",
+    "sass-loader": "^6.0.7",
     "stylelint": "^9.3.0",
-    "stylelint-config-standard": "^18.0.0"
+    "stylelint-config-standard": "^18.0.0",
+    "surge": "^0.20.3"
   },
   "dependencies": {
     "babel-polyfill": "^6.26.0",
     "classnames": "^2.2.5",
+    "lodash": "^4.17.11",
     "patternfly-react": "^2.29.0",
     "prop-types": "^15.6.0",
     "react": "^16.8.1",
@@ -69,10 +77,10 @@
     "redux-thunk": "^2.3.0",
     "reselect": "^3.0.1",
     "seamless-immutable": "^7.1.2",
+    "urijs": "^1.19.1",
     "uuid": "^3.3.2"
   },
   "jest": {
-    "automock": true,
     "verbose": true,
     "testMatch": [
       "**/*.test.js"
@@ -90,11 +98,6 @@
     "coverageReporters": [
       "lcov"
     ],
-    "unmockedModulePathPatterns": [
-      "webpack/",
-      "react",
-      "node_modules/"
-    ],
     "moduleNameMapper": {
       "^.+\\.(png|gif|css|scss)$": "identity-obj-proxy"
     },

data/test/controllers/tasks_controller_test.rb

@@ -24,6 +24,16 @@ module ForemanTasks
         Organization.current = Location.current = nil
       end
 
+      describe 'summary' do
+        it 'works' do
+          FactoryBot.create(:some_task, :action => 'Some action')
+          get(:summary, params: { recent_timeframe: 24 }, session: set_session_user)
+          assert_response :success
+          response = JSON.parse(@response.body)
+          assert response['running']
+        end
+      end
+
       it 'supports csv export' do
         FactoryBot.create(:some_task, :action => 'Some action')
         get(:index, params: { format: :csv }, session: set_session_user)

data/test/foreman_tasks_test_helper.rb

@@ -4,8 +4,10 @@ require_relative './support/dummy_dynflow_action'
 require_relative './support/dummy_recurring_dynflow_action'
 require_relative './support/dummy_proxy_action'
 require_relative './support/dummy_task_group'
+require_relative './support/history_tasks_builder'
 
 require 'dynflow/testing'
+require 'foreman_tasks/test_helpers'
 
 FactoryBot.definition_file_paths = ["#{ForemanTasks::Engine.root}/test/factories"]
 FactoryBot.find_definitions
@@ -13,6 +15,8 @@ FactoryBot.find_definitions
 ForemanTasks.dynflow.require!
 ForemanTasks.dynflow.config.disable_active_record_actions = true
 
+ForemanTasks::TestHelpers.use_in_memory_sqlite!
+
 # waits for the passed block to return non-nil value and reiterates it while getting false
 # (till some reasonable timeout). Useful for forcing the tests for some event to occur
 def wait_for(waiting_message = 'something to happen')

data/test/support/dummy_dynflow_action.rb

@@ -1,4 +1,33 @@
 module Support
   class DummyDynflowAction < Dynflow::Action
   end
+
+  class DummyPauseAction < Actions::EntryAction
+    def plan
+      plan_action(DummyPauseActionWithCustomTroubleshooting)
+      plan_self
+    end
+
+    def run
+      error! "This is an error"
+    end
+  end
+
+  class DummyPauseActionWithCustomTroubleshooting < Actions::EntryAction
+    def run
+      error! "This is an error"
+    end
+
+    def troubleshooting_info
+      ForemanTasks::TroubleshootingHelpGenerator::Info.new.tap do |i|
+        i.add_line _('This task requires special handling.')
+        i.add_link(ForemanTasks::TroubleshootingHelpGenerator::Link.new(
+                     name: :custom_link,
+                     title: _('custom link'),
+                     href: "/additional_troubleshooting_page",
+                     description: _("Investigate %{link} on more details for this custom error.")
+                   ))
+      end
+    end
+  end
 end

data/test/support/history_tasks_builder.rb

@@ -0,0 +1,42 @@
+class HistoryTasksBuilder
+  def distribution
+    { 'running' => { recent: 3, total: 6 },
+      'stopped' => { recent: 3, total: 7,
+                     by_result: {
+                       'success' => { recent: 2, total: 4 },
+                       'warning' => { recent: 1, total: 2 },
+                       'error' => { recent: 0, total: 1 }
+                     } } }
+  end
+
+  # rubocop:disable Performance/TimesMap
+  def build
+    distribution.each do |(state, status_summary)|
+      tasks = status_summary[:total].times.map do
+        ForemanTasks::Task.create(type: ForemanTasks::Task.name,
+                                  label: 'test',
+                                  state: state,
+                                  result: 'pending').tap do |task|
+          task.update(state_updated_at: nil)
+        end
+      end
+      recent_tasks = tasks.take(status_summary[:recent])
+      recent_tasks.each { |t| t.update(state_updated_at: Time.now.utc) }
+
+      untouched_recent_tasks = recent_tasks
+      untouched_old_tasks = tasks - recent_tasks
+      status_summary.fetch(:by_result, {}).each do |(result, result_summary)|
+        result_summary[:recent].times do |_i|
+          task = untouched_recent_tasks.shift
+          task.update(result: result)
+        end
+
+        (result_summary[:total] - result_summary[:recent]).times do |_i|
+          task = untouched_old_tasks.shift
+          task.update(result: result)
+        end
+      end
+    end
+    # rubocop:enable Performance/TimesMap
+  end
+end

data/test/unit/actions/action_with_sub_plans_test.rb

@@ -1,4 +1,5 @@
 require 'foreman_tasks_test_helper'
+require 'foreman_tasks/test_helpers'
 
 module ForemanTasks
   class ActionWithSubPlansTest < ActiveSupport::TestCase
@@ -31,11 +32,13 @@ module ForemanTasks
     end
 
     describe Actions::ActionWithSubPlans do
+      include ForemanTasks::TestHelpers::WithInThreadExecutor
+
       let(:task) do
         user = FactoryBot.create(:user)
         triggered = ForemanTasks.trigger(ParentAction, user)
         raise triggered.error if triggered.respond_to?(:error)
-        triggered.finished.wait(2)
+        triggered.finished.wait(30)
         ForemanTasks::Task.where(:external_id => triggered.id).first
       end
 

data/test/unit/actions/bulk_action_test.rb

@@ -17,6 +17,8 @@ module ForemanTasks
     end
 
     describe Actions::BulkAction do
+      include ForemanTasks::TestHelpers::WithInThreadExecutor
+
       let(:targets) { (1..5).map { |i| Target.new i } }
       let(:task) do
         triggered = ForemanTasks.trigger(ParentAction, ChildAction, targets)

data/test/unit/cleaner_test.rb

@@ -68,6 +68,21 @@ class TasksTest < ActiveSupport::TestCase
       ForemanTasks::Task.where(id: tasks_to_keep).must_equal tasks_to_keep
     end
 
+    it 'matches tasks with compound filters properly' do
+      cleaner = ForemanTasks::Cleaner.new(:filter => 'result = pending or result = error',
+                                          :states => %w[paused planning])
+      tasks_to_delete = [FactoryBot.create(:some_task),
+                         FactoryBot.create(:some_task)]
+      tasks_to_delete[0].update!(:result => 'error', :state => 'paused')
+      tasks_to_delete[1].update!(:result => 'pending', :state => 'planning')
+      task_to_keep = FactoryBot.create(:some_task)
+      task_to_keep.update!(:result => 'pending', :state => 'planned')
+      cleaner.expects(:tasks_to_csv)
+      cleaner.delete
+      ForemanTasks::Task.where(id: tasks_to_delete).must_be_empty
+      ForemanTasks::Task.where(id: task_to_keep).must_equal [task_to_keep]
+    end
+
     it 'backs tasks up before deleting' do
       dir = '/tmp'
       cleaner = ForemanTasks::Cleaner.new(:filter => '', :after => '10d', :backup_dir => dir)

data/test/unit/dashboard_table_filter_test.rb

@@ -0,0 +1,65 @@
+require 'foreman_tasks_test_helper'
+
+class DashboardTableFilterTest < ActiveSupport::TestCase
+  before do
+    ::ForemanTasks::Task.delete_all
+  end
+
+  describe ForemanTasks::DashboardTableFilter do
+    before do
+      @tasks_builder = HistoryTasksBuilder.new
+      @scope = ForemanTasks::Task.all
+      @tasks_builder.build
+    end
+
+    let :subject do
+      ForemanTasks::DashboardTableFilter.new(@scope, params)
+    end
+
+    let :filtered_scope do
+      subject.scope
+    end
+
+    describe 'by result' do
+      let(:params) { { result: 'warning' } }
+
+      it 'filters' do
+        filtered_scope.count.must_equal @tasks_builder.distribution['stopped'][:by_result]['warning'][:total]
+      end
+    end
+
+    describe 'by state' do
+      let(:params) { { state: 'running' } }
+
+      it 'filters' do
+        filtered_scope.count.must_equal @tasks_builder.distribution['running'][:total]
+      end
+    end
+
+    describe 'recent' do
+      let(:params) do
+        { state: 'running',
+          time_horizon: 'H24',
+          time_mode: 'recent' }
+      end
+
+      it 'filters' do
+        filtered_scope.count.must_equal @tasks_builder.distribution['running'][:recent]
+      end
+    end
+
+    describe 'older' do
+      let(:params) do
+        { state: 'running',
+          time_horizon: 'H24',
+          time_mode: 'older' }
+      end
+
+      it 'filters' do
+        old_tasks_count = @tasks_builder.distribution['running'][:total] -
+                          @tasks_builder.distribution['running'][:recent]
+        filtered_scope.count.must_equal old_tasks_count
+      end
+    end
+  end
+end

data/test/unit/summarizer_test.rb

@@ -0,0 +1,39 @@
+require 'foreman_tasks_test_helper'
+
+class SummarizerTest < ActiveSupport::TestCase
+  before do
+    ::ForemanTasks::Task.delete_all
+  end
+
+  describe ForemanTasks::Task::Summarizer do
+    before do
+      @tasks_builder = HistoryTasksBuilder.new
+      @tasks_builder.build
+    end
+
+    let :subject do
+      ForemanTasks::Task::Summarizer.new
+    end
+
+    let :expected do
+      @tasks_builder.distribution
+    end
+
+    it 'is able to group tasks counts by state and result' do
+      summary = subject.summary
+      expected.each do |(state, expected_state_vals)|
+        assert_summary(expected_state_vals, summary[state], "summary[#{state}]")
+        expected_state_vals.fetch(:by_result, {}).each do |result, expected_result_vals|
+          assert_summary expected_result_vals, summary[state][:by_result][result], "summary[#{state}][#{result}]"
+        end
+      end
+    end
+
+    def assert_summary(expected_summary, summary, value_desc)
+      %I[recent total].each do |key|
+        assert_equal expected_summary[key], summary[key],
+                     "#{value_desc}[#{key}] expected to be #{expected_summary[key]}, was #{summary[key]}"
+      end
+    end
+  end
+end

data/test/unit/task_test.rb

@@ -41,6 +41,20 @@ class TasksTest < ActiveSupport::TestCase
     end
   end
 
+  describe 'state_updated_at' do
+    it 'updates the state_updated_at when the state changes' do
+      task = FactoryBot.create(:some_task)
+      assert task.state_updated_at > Time.now.utc - 1.minute, "Newly created task has to have state_updated_at set"
+      task.update(state_updated_at: nil)
+      task.result = 'error'
+      task.save
+      assert_not task.state_updated_at, "Other than state change should not affect 'state_updated_at'"
+      task.state = 'running'
+      task.save
+      assert task.state_updated_at, "State change should set 'state_updated_at'"
+    end
+  end
+
   describe 'authorization filtering' do
     it 'can filter by the task subject' do
       user_role  = FactoryBot.create(:user_user_role)

data/test/unit/troubleshooting_help_generator_test.rb

@@ -0,0 +1,71 @@
+require 'foreman_tasks_test_helper'
+
+module ForemanTasks
+  class TroubleshootingHelpGeneratorTest < ActiveSupport::TestCase
+    include ForemanTasks::TestHelpers::WithInThreadExecutor
+
+    subject do
+      TroubleshootingHelpGenerator.new(@task.main_action)
+    end
+
+    let :sample_troubleshooting_url do
+      'https://theforeman.org/manuals/%{version}/tasks_troubleshooting.html#%{label}'
+    end
+
+    let :expected_troubleshooting_url do
+      "https://theforeman.org/manuals/#{SETTINGS[:version].short}/tasks_troubleshooting.html#Support::DummyPauseAction"
+    end
+
+    let :action_class do
+      Support::DummyPauseAction
+    end
+
+    before do
+      Setting::ForemanTasks.load_defaults
+      ::ForemanTasks::Task.delete_all
+      @task = trigger_task
+      Setting[:foreman_tasks_troubleshooting_url] = sample_troubleshooting_url
+    end
+
+    it 'generates html from the main action troubleshooting_info' do
+      generated_html = subject.generate_html
+      generated_html.must_include "A paused task represents a process that has not finished properly"
+      generated_html.must_include %(See <a href="#{expected_troubleshooting_url}">troubleshooting documentation</a> for more details on how to resolve the issue)
+    end
+
+    it 'exposes link details' do
+      link = subject.links.find do |l|
+        l.name == :troubleshooting && l.title == 'troubleshooting documentation' &&
+          l.href == expected_troubleshooting_url
+      end
+      assert link, "#{subject.links} doesn't contain expected link"
+    end
+
+    describe 'additional troubleshooting info' do
+      let(:action_class) do
+        Support::DummyPauseActionWithCustomTroubleshooting
+      end
+
+      it 'includes additional description in generated html' do
+        generated_html = subject.generate_html
+        generated_html.must_include 'A paused task represents a process that has not finished properly'
+        generated_html.must_match %r{See <a href=".*">troubleshooting documentation</a> for more details on how to resolve the issue}
+        generated_html.must_include 'This task requires special handling'
+        generated_html.must_include 'Investigate <a href="/additional_troubleshooting_page">custom link</a> on more details for this custom error'
+      end
+
+      it 'includes additional links' do
+        link = subject.links.find do |l|
+          l.name == :custom_link && l.title == 'custom link' && l.href == '/additional_troubleshooting_page'
+        end
+        assert link, "#{subject.links} doesn't contain expected link"
+      end
+    end
+
+    def trigger_task
+      t = ForemanTasks.trigger(action_class)
+      t.finished.wait
+      ForemanTasks::Task.find_by(external_id: t.execution_plan_id)
+    end
+  end
+end