foreman-tasks 1.0.1 → 2.0.1

data/package.json

@@ -27,6 +27,7 @@
   "dependencies": {
     "c3": "^0.4.11",
     "humanize-duration": "^3.20.1",
+    "react-html-parser": "^2.0.2",
     "react-intl": "^2.8.0"
   },
   "devDependencies": {
@@ -38,10 +39,8 @@
     "@theforeman/vendor-dev": "^4.0.2",
     "babel-eslint": "^10.0.3",
     "eslint": "^6.7.2",
-    "identity-obj-proxy": "^3.0.0",
     "jed": "^1.1.1",
     "prettier": "^1.13.5",
-    "react-remarkable": "^1.1.3",
     "stylelint": "^9.3.0",
     "stylelint-config-standard": "^18.0.0",
     "surge": "^0.20.3"

data/script/rails

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
 # This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
 
-ENGINE_ROOT = File.expand_path('../..', __FILE__)
-ENGINE_PATH = File.expand_path('../../lib/foreman_tasks/engine', __FILE__)
+ENGINE_ROOT = File.expand_path('..', __dir__)
+ENGINE_PATH = File.expand_path('../lib/foreman_tasks/engine', __dir__)
 
 require 'rails/all'
 require 'rails/engine/commands'

data/script/travis_run_js_tests.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 set -ev
-if [[ $( git diff --name-only HEAD~1..HEAD webpack/ .travis.yml .babelrc .eslintrc package.json | wc -l ) -ne 0 ]]; then
+if [[ $( git diff --name-only HEAD~1..HEAD webpack/ .travis.yml babel.config.js .eslintrc package.json | wc -l ) -ne 0 ]]; then
   npm run test;
-  npm run coveralls;
+  npm run publish-coverage;
   npm run lint;
 fi

data/test/factories/task_factory.rb

@@ -22,7 +22,7 @@ FactoryBot.define do
         execution_plan = ForemanTasks.dynflow.world.plan(Support::DummyDynflowAction)
         # remove the task created automatically by the persistence
         ForemanTasks::Task.where(:external_id => execution_plan.id).delete_all
-        task.update_attributes!(:external_id => execution_plan.id)
+        task.update!(:external_id => execution_plan.id)
         if evaluator.sync_with_dynflow
           task.update_from_dynflow(execution_plan.to_hash)
         end
@@ -38,9 +38,41 @@ FactoryBot.define do
 
       trait :inconsistent_dynflow_task do
         after(:build) do |task|
-          task.update_attributes!(:state => 'running')
+          task.update!(:state => 'running')
+        end
+      end
+
+      factory :task_with_locks do
+        # posts_count is declared as a transient attribute and available in
+        # attributes on the factory, as well as the callback via the evaluator
+        transient do
+          locks_count { 3 }
+          resource_id { 1 }
+          resource_type { 'type1' }
+        end
+
+        # the after(:create) yields two values; the user instance itself and the
+        # evaluator, which stores all values from the factory, including transient
+        # attributes; `create_list`'s second argument is the number of records
+        # to create and we make sure the user is associated properly to the post
+        after(:create) do |task, evaluator|
+          create_list(
+            :lock,
+            evaluator.locks_count,
+            task: task,
+            resource_type: evaluator.resource_type,
+            resource_id: evaluator.resource_id
+          )
         end
       end
     end
   end
+
+  factory :lock, :class => ForemanTasks::Lock do
+    name { 'read' }
+    resource_type { 'Katello::Repository' }
+    resource_id { 1 }
+    exclusive { true }
+    association :task, factory: :task_with_locks
+  end
 end

data/test/foreman_tasks_test_helper.rb

@@ -27,3 +27,7 @@ def wait_for(waiting_message = 'something to happen')
   end
   raise "waiting for #{waiting_message} was not successful"
 end
+
+def on_postgresql?
+  ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+end

data/test/lib/concerns/polling_action_extensions_test.rb

@@ -0,0 +1,34 @@
+require 'foreman_tasks_test_helper'
+
+module ForemanTasks
+  module Concerns
+    class PollingActionExtensionsTest < ::ActiveSupport::TestCase
+      class Action < ::Dynflow::Action
+        include ::Dynflow::Action::Polling
+      end
+
+      describe 'polling interval tuning' do
+        let(:default_intervals) { [0.5, 1, 2, 4, 8, 16] }
+
+        it 'is extends the polling action module' do
+          _(::Dynflow::Action::Polling.ancestors.first).must_equal ForemanTasks::Concerns::PollingActionExtensions
+        end
+
+        it 'does not modify polling intervals by default' do
+          _(Action.allocate.poll_intervals).must_equal default_intervals
+        end
+
+        it 'cannot make intervals shorter than 0.5 seconds' do
+          Setting.expects(:[]).with(:foreman_tasks_polling_multiplier).returns 0
+          _(Action.allocate.poll_intervals).must_equal(default_intervals.map { 0.5 })
+        end
+
+        it 'can be used to make the intervals longer' do
+          value = 5
+          Setting.expects(:[]).with(:foreman_tasks_polling_multiplier).returns value
+          _(Action.allocate.poll_intervals).must_equal(default_intervals.map { |i| i * value })
+        end
+      end
+    end
+  end
+end

data/test/unit/actions/action_with_sub_plans_test.rb

@@ -8,7 +8,7 @@ module ForemanTasks
     end
 
     # to be able to use the locking
-    ::User.send(:include, ForemanTasks::Concerns::ActionSubject)
+    ::User.include ForemanTasks::Concerns::ActionSubject
 
     class ParentAction < Actions::ActionWithSubPlans
       def plan(user)

data/test/unit/task_test.rb

@@ -1,97 +1,133 @@
 require 'foreman_tasks_test_helper'
 
 class TasksTest < ActiveSupport::TestCase
-  describe 'filtering by current user' do
-    before do
-      @original_current_user = User.current
-      @user_one = FactoryBot.create(:user)
-      @user_two = FactoryBot.create(:user)
+  describe 'search' do
+    describe 'by current user' do
+      before do
+        @original_current_user = User.current
+        @user_one = FactoryBot.create(:user)
+        @user_two = FactoryBot.create(:user)
 
-      @task_one = FactoryBot.create(:some_task, :user => @user_one)
-      FactoryBot.create(:some_task, :user => @user_two)
+        @task_one = FactoryBot.create(:some_task, :user => @user_one)
+        FactoryBot.create(:some_task, :user => @user_two)
 
-      User.current = @user_one
-    end
-    after { User.current = @original_current_user }
+        User.current = @user_one
+      end
+      after { User.current = @original_current_user }
 
-    test 'can search the tasks by current_user' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for('owner.id = current_user')
-    end
+      test 'can search the tasks by current_user' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for('owner.id = current_user')
+      end
 
-    test 'can search by implicit search' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for(@task_one.label)
-    end
+      test 'can search by implicit search' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for(@task_one.label)
+      end
 
-    test 'can search the tasks by current_user in combination with implicit search' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id = current_user AND #{@task_one.label}")
-    end
+      test 'can search the tasks by current_user in combination with implicit search' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id = current_user AND #{@task_one.label}")
+      end
 
-    test 'can search the tasks by user' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user = #{@user_one.login}")
-    end
+      test 'can search the tasks by user' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user = #{@user_one.login}")
+      end
 
-    test 'cannot search by arbitrary key' do
-      proc { ForemanTasks::Task.search_for('user.my_key ~ 5') }.must_raise(ScopedSearch::QueryNotSupported)
-      proc { ForemanTasks::Task.search_for('user. = 5') }.must_raise(ScopedSearch::QueryNotSupported)
-    end
+      test 'cannot search by arbitrary key' do
+        proc { ForemanTasks::Task.search_for('user.my_key ~ 5') }.must_raise(ScopedSearch::QueryNotSupported)
+        proc { ForemanTasks::Task.search_for('user. = 5') }.must_raise(ScopedSearch::QueryNotSupported)
+      end
 
-    test 'can search the tasks by negated user' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user != #{@user_two.login}")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user <> #{@user_two.login}")
-      SecureRandom.stubs(:hex).returns('abc')
-      assert_equal ForemanTasks::Task.search_for("user != #{@user_two.login}").to_sql,
-                   ForemanTasks::Task.search_for("user <> #{@user_two.login}").to_sql
-    end
+      test 'can search the tasks by negated user' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user != #{@user_two.login}")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user <> #{@user_two.login}")
+        SecureRandom.stubs(:hex).returns('abc')
+        assert_equal ForemanTasks::Task.search_for("user != #{@user_two.login}").to_sql,
+                     ForemanTasks::Task.search_for("user <> #{@user_two.login}").to_sql
+      end
 
-    test 'can search the tasks by user\'s id' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user.id = #{@user_one.id}")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id = #{@user_one.id}")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user.id != #{@user_two.id}")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id != #{@user_two.id}")
-    end
+      test 'can search the tasks by user\'s id' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user.id = #{@user_one.id}")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id = #{@user_one.id}")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user.id != #{@user_two.id}")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id != #{@user_two.id}")
+      end
 
-    test 'can search by array of user ids' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user.id ^ (#{@user_one.id})")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id ^ (#{@user_one.id})")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user.id !^ (#{@user_two.id})")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id !^ (#{@user_two.id})")
-    end
+      test 'can search by array of user ids' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user.id ^ (#{@user_one.id})")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id ^ (#{@user_one.id})")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user.id !^ (#{@user_two.id})")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id !^ (#{@user_two.id})")
+      end
 
-    test 'cannot glob on user\'s id' do
-      proc { ForemanTasks::Task.search_for("user.id ~ something") }.must_raise(ScopedSearch::QueryNotSupported)
-      proc { ForemanTasks::Task.search_for("user.id ~ 5") }.must_raise(ScopedSearch::QueryNotSupported)
-    end
+      test 'cannot glob on user\'s id' do
+        proc { ForemanTasks::Task.search_for("user.id ~ something") }.must_raise(ScopedSearch::QueryNotSupported)
+        proc { ForemanTasks::Task.search_for("user.id ~ 5") }.must_raise(ScopedSearch::QueryNotSupported)
+      end
 
-    test 'can search the tasks by user with wildcards' do
-      part = @user_one.login[1..-1] # search for '*ser1' if login is 'user1'
-      # The following two should be equivalent
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user ~ #{part}")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user ~ *#{part}*")
-      SecureRandom.stubs(:hex).returns('abc')
-      assert_equal ForemanTasks::Task.search_for("user ~ #{part}").to_sql,
-                   ForemanTasks::Task.search_for("user ~ *#{part}*").to_sql
-    end
+      test 'can search the tasks by user with wildcards' do
+        part = @user_one.login[1..-1] # search for '*ser1' if login is 'user1'
+        # The following two should be equivalent
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user ~ #{part}")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user ~ *#{part}*")
+        SecureRandom.stubs(:hex).returns('abc')
+        assert_equal ForemanTasks::Task.search_for("user ~ #{part}").to_sql,
+                     ForemanTasks::Task.search_for("user ~ *#{part}*").to_sql
+      end
 
-    test 'can search the tasks by user with negated wildcards' do
-      part = @user_two.login[1..-1] # search for '*ser1' if login is 'user1'
-      # The following two should be equivalent
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user !~ #{part}")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user !~ *#{part}*")
-      SecureRandom.stubs(:hex).returns('abc')
-      assert_equal ForemanTasks::Task.search_for("user !~ #{part}").to_sql,
-                   ForemanTasks::Task.search_for("user !~ *#{part}*").to_sql
-    end
+      test 'can search the tasks by user with negated wildcards' do
+        part = @user_two.login[1..-1] # search for '*ser1' if login is 'user1'
+        # The following two should be equivalent
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user !~ #{part}")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user !~ *#{part}*")
+        SecureRandom.stubs(:hex).returns('abc')
+        assert_equal ForemanTasks::Task.search_for("user !~ #{part}").to_sql,
+                     ForemanTasks::Task.search_for("user !~ *#{part}*").to_sql
+      end
 
-    test 'can search the tasks by array' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user ^ (this_user, #{@user_one.login}, that_user)")
-    end
+      test 'can search the tasks by array' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user ^ (this_user, #{@user_one.login}, that_user)")
+      end
+
+      test 'can search the tasks by negated array' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user !^ (this_user, #{@user_two.login}, that_user)")
+      end
 
-    test 'can search the tasks by negated array' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user !^ (this_user, #{@user_two.login}, that_user)")
+      test 'properly returns username' do
+        assert_equal @task_one.username, @user_one.login
+      end
     end
 
-    test 'properly returns username' do
-      assert_equal @task_one.username, @user_one.login
+    describe 'by duration' do
+      before do
+        @task_one, @task_two = FactoryBot.create_list(:dynflow_task, 2).sort_by(&:id)
+      end
+
+      let(:scope) { ForemanTasks::Task.order(:id) }
+
+      it 'can search by seconds ' do
+        skip unless on_postgresql?
+        _(scope.search_for('duration < 2')).must_be :empty?
+        _(scope.search_for('duration = 2')).must_equal [@task_one, @task_two]
+        _(scope.search_for('duration < "2 seconds"')).must_be :empty?
+        _(scope.search_for('duration > "2 seconds"')).must_be :empty?
+        _(scope.search_for('duration = "2 seconds"')).must_equal [@task_one, @task_two]
+        _(scope.search_for('duration <= "2 seconds"')).must_equal [@task_one, @task_two]
+        _(scope.search_for('duration >= "2 seconds"')).must_equal [@task_one, @task_two]
+      end
+
+      it 'can search by other time intervals' do
+        skip unless on_postgresql?
+        %w[minutes hours days months years].each do |interval|
+          _(scope.search_for("duration < \"2 #{interval}\"")).must_equal [@task_one, @task_two]
+          _(scope.search_for("duration > \"2 #{interval}\"")).must_be :empty?
+          _(scope.search_for("duration = \"2 #{interval}\"")).must_be :empty?
+          _(scope.search_for("duration <= \"2 #{interval}\"")).must_equal [@task_one, @task_two]
+          _(scope.search_for("duration >= \"2 #{interval}\"")).must_be :empty?
+        end
+      end
+
+      it 'raises an exception if duration is unknown' do
+        proc { ForemanTasks::Task.search_for('duration = "25 potatoes"') }.must_raise ScopedSearch::QueryNotSupported
+      end
     end
   end
 
@@ -248,4 +284,54 @@ class TasksTest < ActiveSupport::TestCase
       task.execution_type.must_equal 'Delayed'
     end
   end
+
+  describe 'search for resource_ids' do
+    it 'finds tasks' do
+      label = 'label1'
+      resource_ids = [1, 2]
+      resource_type = 'restype1'
+
+      task1_old = FactoryBot.create(
+        :task_with_locks,
+        started_at: '2019-10-01 11:15:55',
+        ended_at: '2019-10-01 11:15:57',
+        resource_id: 1,
+        label: label,
+        resource_type: resource_type
+      )
+      task1_new = FactoryBot.create(
+        :task_with_locks,
+        started_at: '2019-10-02 11:15:55',
+        ended_at: '2019-10-02 11:15:57',
+        resource_id: 1,
+        label: label,
+        resource_type: resource_type
+      )
+      task2 = FactoryBot.create(
+        :task_with_locks,
+        started_at: '2019-10-03 11:15:55',
+        ended_at: '2019-10-03 11:15:57',
+        resource_id: 2,
+        label: label,
+        resource_type: resource_type
+      )
+      task3 = FactoryBot.create(
+        :task_with_locks,
+        started_at: '2019-10-03 11:15:55',
+        ended_at: '2019-10-03 11:15:57',
+        resource_id: 3,
+        label: label,
+        resource_type: 'another_type'
+      )
+
+      result = ForemanTasks::Task.search_for(
+        "resource_id ^ (#{resource_ids.join(',')}) and resource_type = #{resource_type}"
+      ).distinct
+      assert_equal 3, result.length
+      assert_includes result, task1_old
+      assert_includes result, task1_new
+      assert_includes result, task2
+      assert_not_includes result, task3
+    end
+  end
 end

data/webpack/ForemanTasks/Components/TaskActions/TaskAction.test.js

@@ -0,0 +1,60 @@
+import { testActionSnapshotWithFixtures } from '@theforeman/test';
+import { API } from 'foremanReact/redux/API';
+import {
+  cancelTaskRequest,
+  resumeTaskRequest,
+  forceCancelTaskRequest,
+  unlockTaskRequest,
+} from './';
+
+jest.mock('foremanReact/components/common/table', () => ({
+  getTableItemsAction: jest.fn(controller => controller),
+}));
+
+jest.mock('foremanReact/redux/API');
+
+const task = ['some-id', 'some-name'];
+
+const fixtures = {
+  'should cancelTaskRequest and succeed': () => cancelTaskRequest(...task),
+  'should cancelTaskRequest and fail': () => {
+    API.post.mockImplementation(() =>
+      Promise.reject(new Error('Network Error'))
+    );
+    return cancelTaskRequest(...task);
+  },
+
+  'should resumeTaskRequest and succeed': () => {
+    API.post.mockImplementation(() => ({ data: 'some-data' }));
+    return resumeTaskRequest(...task);
+  },
+  'should resumeTaskRequest and fail': () => {
+    API.post.mockImplementation(() =>
+      Promise.reject(new Error('Network Error'))
+    );
+    return resumeTaskRequest(...task);
+  },
+  'should forceCancelTaskRequest and succeed': () => {
+    API.post.mockImplementation(() => ({ data: 'some-data' }));
+    return forceCancelTaskRequest(...task);
+  },
+  'should forceCancelTaskRequest and fail': () => {
+    API.post.mockImplementation(() =>
+      Promise.reject(new Error('Network Error'))
+    );
+    return forceCancelTaskRequest(...task);
+  },
+  'should unlockTaskRequest and succeed': () => {
+    API.post.mockImplementation(() => ({ data: 'some-data' }));
+    return unlockTaskRequest(...task);
+  },
+  'should unlockTaskRequest and fail': () => {
+    API.post.mockImplementation(() =>
+      Promise.reject(new Error('Network Error'))
+    );
+    return forceCancelTaskRequest(...task);
+  },
+};
+describe('Tasks actions', () => {
+  testActionSnapshotWithFixtures(fixtures);
+});