foreman-tasks 11.1.1 → 12.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2aac0a5327f2c06d5a88126a179a411ed15b52d8e19e621eb6e6ef60b5c00d3
-  data.tar.gz: 911be05d74f3274945bc5285205f977fdcc9894cb752f0c1aa921659b553b406
+  metadata.gz: faba9c8433d1b6c6faa616d7f6d58bfade42692f3e0afa6de35d67a0f1740bf2
+  data.tar.gz: 912a3a297fde3eddbbef8fca0e3da6e2bec6e6ca5882eb69a37eafe00a443ec9
 SHA512:
-  metadata.gz: bdbdec27c38515a772e9ab1d177b07c5fa9f19d73ad412b1e45c0a4497c4a07539d8aeaceeb69cb75fccd1d05028e77058854a5544ec3f063c69890df965690f
-  data.tar.gz: c99e51b91af6b3b67ce17ee83c58e22d3ffa64314755b0faa2791fc455d83adeb16017d6dee3fb5b1dcd0e4a6d927305443f4973e7a1102476b955807634dc46
+  metadata.gz: bb4842d2685129d098bb05d37a423ce7817294cf523d2dd7f4e867618d80584135564d9df7c24a460bdad68372ac663dde160189d60cdd580bce9b825d3d89f8
+  data.tar.gz: e11dd77bbe8d94f347ed31d5b67dfec2924fba89207007fa370f7053ec5549c46a5d16e1fc34ea4e4f23ad1607abddb40db87aa74413d9b8d51f214aecab9485

data/.github/workflows/ruby_tests.yml

@@ -13,6 +13,7 @@ jobs:
     uses: theforeman/actions/.github/workflows/rubocop.yml@v0
     with:
       command: bundle exec rubocop --parallel --format github
+      ruby: '3.0'
 
   test:
     name: Ruby

data/app/controllers/foreman_tasks/api/tasks_controller.rb

@@ -179,24 +179,12 @@ module ForemanTasks
       param :parent_task_id, :identifier, desc: 'UUID of the task'
       param_group :search_and_pagination, ::Api::V2::BaseController
       def index
-        if params[:sort_by] || params[:sort_order]
-          Foreman::Deprecation.api_deprecation_warning(
-            "The sort params sort_by and sort_order are deprecated.
-            Please use the order param instead as one string 'order=started_at desc'"
-          )
-
-          ordering_params = {
-            sort_by: params[:sort_by] || 'started_at',
-            sort_order: params[:sort_order] || 'DESC',
-          }
-          params[:order] = "#{ordering_params[:sort_by]} #{ordering_params[:sort_order]}"
-        end
         params[:order] ||= 'started_at DESC'
-        @tasks = resource_scope_for_index.order(params[:order].to_s)
+        @tasks = resource_scope_for_index
       end
 
       def search_options
-        [search_query, {}]
+        [search_query, { :order => params[:order] }]
       end
 
       def_param_group :callback_target do
@@ -320,19 +308,16 @@ module ForemanTasks
       end
 
       def find_task
-        @task = resource_scope.with_duration.find(params[:id])
+        @task = resource_scope.select_duration.find(params[:id])
       end
 
       def resource_scope(_options = {})
         scope = ForemanTasks::Task.authorized("#{action_permission}_foreman_tasks")
         scope = scope.where(:parent_task_id => params[:parent_task_id]) if params[:parent_task_id]
+        scope = scope.select_duration if params[:action] == 'index'
         scope
       end
 
-      def resource_scope_for_index(*args)
-        super.with_duration.distinct
-      end
-
       def controller_permission
         'foreman_tasks'
       end

data/app/controllers/foreman_tasks/tasks_controller.rb

@@ -4,7 +4,7 @@ module ForemanTasks
     include Foreman::Controller::CsvResponder
     include ForemanTasks::FindTasksCommon
 
-    before_action :find_dynflow_task, only: [:unlock, :force_unlock, :cancel, :cancel_step, :resume]
+    before_action :find_dynflow_task, only: [:unlock, :force_unlock, :cancel, :abort, :cancel_step, :resume]
 
     def show
       @task = resource_base.find(params[:id])
@@ -51,11 +51,10 @@ module ForemanTasks
 
     def abort
       if @dynflow_task.abort
-        flash[:info] = _('Trying to abort the task')
+        render json: { statusText: 'OK' }
       else
-        flash[:warning] = _('The task cannot be aborted at the moment.')
+        render json: {}, status: :bad_request
       end
-      redirect_back(:fallback_location => foreman_tasks_task_path(@dynflow_task))
     end
 
     def resume
@@ -98,7 +97,7 @@ module ForemanTasks
     private
 
     def respond_with_tasks(scope)
-      @tasks = filter(scope, paginate: false).with_duration
+      @tasks = filter(scope, paginate: false).select_duration
       csv_response(@tasks, [:id, :action, :state, :result, 'started_at.in_time_zone', 'ended_at.in_time_zone', :duration, :username], ['Id', 'Action', 'State', 'Result', 'Started At', 'Ended At', 'Duration', 'User'])
     end
 

data/app/models/foreman_tasks/task.rb

@@ -78,7 +78,7 @@ module ForemanTasks
                                  :"foreman_tasks_links.resource_type" => resource.class.name)
            end)
     scope :for_action_types, (->(action_types) { where('foreman_tasks_tasks.label IN (?)', Array(action_types)) })
-    scope :with_duration, -> { select("foreman_tasks_tasks.*, coalesce(ended_at, current_timestamp) - coalesce(coalesce(started_at, ended_at), current_timestamp) as duration") }
+    virtual_column_scope :select_duration, -> { select("foreman_tasks_tasks.*, coalesce(ended_at, current_timestamp) - coalesce(coalesce(started_at, ended_at), current_timestamp) as duration") }
 
     apipie :class, "A class representing #{model_name.human} object" do
       name 'Task'

data/app/views/foreman_tasks/api/tasks/dependency_summary.json.rabl

@@ -0,0 +1,2 @@
+attributes :id, :action, :state, :result
+node(:humanized, &:to_label)

data/app/views/foreman_tasks/api/tasks/details.json.rabl

@@ -18,3 +18,23 @@ node(:links) do
 end
 node(:username_path) { username_link_task(@task.owner, @task.username) }
 node(:dynflow_enable_console) { Setting['dynflow_enable_console'] }
+node(:depends_on) do
+  if @task.execution_plan
+    dynflow_uuids = ForemanTasks.dynflow.world.persistence.find_execution_plan_dependencies(@task.execution_plan.id)
+    ForemanTasks::Task.where(external_id: dynflow_uuids).map do |task|
+      partial('foreman_tasks/api/tasks/dependency_summary', :object => task)
+    end
+  else
+    []
+  end
+end
+node(:blocks) do
+  if @task.execution_plan
+    dynflow_uuids = ForemanTasks.dynflow.world.persistence.find_blocked_execution_plans(@task.execution_plan.id)
+    ForemanTasks::Task.where(external_id: dynflow_uuids).map do |task|
+      partial('foreman_tasks/api/tasks/dependency_summary', :object => task)
+    end
+  else
+    []
+  end
+end

data/app/views/foreman_tasks/api/tasks/show.json.rabl

@@ -3,6 +3,9 @@ object @task if @task
 extends 'api/v2/layouts/permissions'
 
 attributes :id, :label, :pending, :action
-attributes :username, :started_at, :ended_at, :duration, :state, :result, :progress
+attributes :username, :started_at, :ended_at, :state, :result, :progress
+
+# A workaround for https://github.com/ruby/json/issues/957
+node(:duration) { |t| t.duration&.in_seconds&.to_s if t.respond_to?(:duration) }
 attributes :input, :output, :humanized, :cli_example, :start_at
 node(:available_actions) { |t| { cancellable: t.execution_plan&.cancellable?, resumable: t.resumable? } }

data/config/routes.rb

@@ -34,9 +34,9 @@ Foreman::Application.routes.draw do
     end
     resources :tasks, :only => [:index], constraints: ->(req) { req.format == :csv }
 
-    match '/tasks' => 'react#index', :via => [:get]
-    match '/tasks/:id/sub_tasks' => 'react#index', :via => [:get]
-    match '/ex_tasks/:id' => 'react#index', :via => [:get]
+    match '/tasks', to: '/react#index', via: :get
+    match '/tasks/:id/sub_tasks', to: '/react#index', via: :get
+    match '/ex_tasks/:id', to: '/react#index', via: :get
 
     namespace :api do
       resources :recurring_logics, :only => [:index, :show, :update] do

data/foreman-tasks.gemspec

@@ -23,10 +23,12 @@ same resource. It also optionally provides Dynflow infrastructure for using it f
     file.end_with?("test.rake") || file == '.packit.yaml'
   end
 
+  s.required_ruby_version = '>= 3.0', '< 4'
+
   s.test_files = `git ls-files test`.split("\n")
   s.extra_rdoc_files = Dir['README*', 'LICENSE']
 
-  s.add_dependency "dynflow", '>= 1.9.0'
+  s.add_dependency "dynflow", '>= 2.0.0'
   s.add_dependency 'fugit', '~> 1.8'
   s.add_dependency "get_process_mem" # for memory polling
   s.add_dependency "sinatra" # for Dynflow web console

data/lib/foreman_tasks/engine.rb

@@ -17,8 +17,11 @@ module ForemanTasks
     end
 
     initializer 'foreman_tasks.register_plugin', :before => :finisher_hook do
+      require 'foreman/cron'
+
       Foreman::Plugin.register :"foreman-tasks" do
-        requires_foreman '>= 3.15'
+        requires_foreman '>= 3.19'
+        register_global_js_file 'global'
         divider :top_menu, :parent => :monitor_menu, :last => true, :caption => N_('Foreman Tasks')
         menu :top_menu, :tasks,
              :url_hash => { :controller => 'foreman_tasks/tasks', :action => :index },
@@ -34,7 +37,6 @@ module ForemanTasks
 
         security_block :foreman_tasks do |_map|
           permission :view_foreman_tasks, { :'foreman_tasks/tasks' => [:auto_complete_search, :sub_tasks, :index, :summary, :summary_sub_tasks, :show],
-                                            :'foreman_tasks/react' => [:index],
                                             :'foreman_tasks/api/tasks' => [:bulk_search, :show, :index, :summary, :summary_sub_tasks, :details, :sub_tasks] }, :resource_type => 'ForemanTasks::Task'
           permission :edit_foreman_tasks, { :'foreman_tasks/tasks' => [:resume, :unlock, :force_unlock, :cancel_step, :cancel, :abort],
                                             :'foreman_tasks/api/tasks' => [:bulk_resume, :bulk_cancel, :bulk_stop] }, :resource_type => 'ForemanTasks::Task'
@@ -124,6 +126,9 @@ module ForemanTasks
         widget 'foreman_tasks/tasks/dashboard/latest_tasks_in_error_warning', :sizex => 6, :sizey => 1, :name => N_('Latest Warning/Error Tasks')
 
         register_gettext domain: "foreman_tasks"
+
+        # Register recurring task with Foreman::Cron framework
+        Foreman::Cron.register(:daily, 'foreman_tasks:cleanup')
       end
     end
 

data/lib/foreman_tasks/tasks/export_tasks.rake

@@ -324,7 +324,7 @@ namespace :foreman_tasks do
     format = ENV['TASK_FORMAT'] || 'html'
     export_filename = ENV['TASK_FILE'] || generate_filename(format)
 
-    task_scope = ForemanTasks::Task.search_for(filter).with_duration.order(:started_at => :desc)
+    task_scope = ForemanTasks::Task.search_for(filter).select_duration.order(:started_at => :desc)
     id_scope = task_scope.group(:id, :started_at)
 
     puts _("Exporting all tasks matching filter #{filter}")

data/lib/foreman_tasks/triggers.rb

@@ -25,5 +25,9 @@ module ForemanTasks
     def delay(action, delay_options, *args)
       foreman_tasks.delay(action, delay_options, *args)
     end
+
+    def chain(dependencies, action, *args)
+      foreman_tasks.chain(dependencies, action, *args)
+    end
   end
 end

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = '11.1.1'.freeze
+  VERSION = '12.1.0'.freeze
 end

data/lib/foreman_tasks.rb

@@ -62,6 +62,30 @@ module ForemanTasks
     ForemanTasks::Task::DynflowTask.where(:external_id => result.id).first!
   end
 
+  # Chain a task to wait for dependency task(s) to finish before executing.
+  # The chained task remains 'scheduled' until all dependencies reach 'stopped' state.
+  #
+  # @param dependencies [ForemanTasks::Task, Array<ForemanTasks::Task>, ActiveRecord::Relation]
+  #   Dependency ForemanTasks task object(s) or an ActiveRecord relation of tasks.
+  # @param action [Class] Action class to execute
+  # @param args Arguments to pass to the action
+  # @return [ForemanTasks::Task::DynflowTask] The chained task
+  def self.chain(dependencies, action, *args)
+    plan_uuids =
+      if dependencies.is_a?(ActiveRecord::Relation)
+        dependencies.pluck(:external_id)
+      else
+        Array(dependencies).map(&:external_id)
+      end
+
+    if plan_uuids.any?(&:blank?)
+      raise ArgumentError, 'All dependency tasks must have external_id set'
+    end
+
+    result = dynflow.world.chain(plan_uuids, action, *args)
+    ForemanTasks::Task::DynflowTask.where(:external_id => result.id).first!
+  end
+
   def self.register_scheduled_task(task_class, cronline)
     ForemanTasks::RecurringLogic.transaction(isolation: :serializable) do
       return if ForemanTasks::RecurringLogic.joins(:tasks)

data/test/controllers/api/tasks_controller_test.rb

@@ -37,7 +37,7 @@ module ForemanTasks
         end
 
         it 'supports ordering by duration' do
-          get :index, params: { :sort_by => 'duration' }
+          get :index, params: { :order => 'duration' }
           assert_response :success
           data = JSON.parse(response.body)
           assert_equal 'duration', data.dig('sort', 'by')
@@ -104,7 +104,7 @@ module ForemanTasks
         end
 
         it 'shows duration column' do
-          task = ForemanTasks::Task.with_duration.find(FactoryBot.create(:dynflow_task).id)
+          task = ForemanTasks::Task.select_duration.find(FactoryBot.create(:dynflow_task).id)
           get :show, params: { id: task.id }, session: set_session_user
           assert_response :success
           data = JSON.parse(response.body)
@@ -114,7 +114,7 @@ module ForemanTasks
 
       describe 'GET /api/tasks/index' do
         it 'shows duration column' do
-          task = ForemanTasks::Task.with_duration.find(FactoryBot.create(:dynflow_task).id)
+          task = ForemanTasks::Task.select_duration.find(FactoryBot.create(:dynflow_task).id)
           get :index, session: set_session_user
           assert_response :success
           data = JSON.parse(response.body)
@@ -203,6 +203,32 @@ module ForemanTasks
         end
       end
 
+      describe 'GET /api/tasks/:id/details' do
+        it 'shows task dependencies with correct task names' do
+          # Tests https://projects.theforeman.org/issues/39130
+          dependency_task = FactoryBot.create(:dynflow_task, :user_create_task, label: 'Actions::User::Create')
+          blocking_task = FactoryBot.create(:dynflow_task, :user_create_task, label: 'Actions::User::Create')
+
+          ForemanTasks.dynflow.world.persistence.stubs(:find_execution_plan_dependencies)
+                      .with(dependency_task.execution_plan.id)
+                      .returns([])
+          ForemanTasks.dynflow.world.persistence.stubs(:find_blocked_execution_plans)
+                      .with(dependency_task.execution_plan.id)
+                      .returns([blocking_task.external_id])
+
+          get :details, params: { id: dependency_task.id }
+          assert_response :success
+
+          data = JSON.parse(response.body)
+          assert_kind_of Array, data['blocks']
+          assert_equal 1, data['blocks'].length
+
+          blocking_task_data = data['blocks'].first
+          assert_equal blocking_task.id, blocking_task_data['id']
+          assert_equal blocking_task.to_label, blocking_task_data['humanized']
+        end
+      end
+
       describe 'POST /api/tasks/bulk_stop' do
         it 'requires search or task_ids parameter' do
           post :bulk_stop

data/test/controllers/tasks_controller_test.rb

@@ -93,7 +93,7 @@ module ForemanTasks
 
       describe 'index' do
         it 'shows duration column' do
-          task = ForemanTasks::Task.with_duration.find(FactoryBot.create(:some_task).id)
+          task = ForemanTasks::Task.select_duration.find(FactoryBot.create(:some_task).id)
           get(:index, params: {}, session: set_session_user)
           assert_response :success
           row = CSV.parse(response.body, headers: true).first
@@ -122,7 +122,7 @@ module ForemanTasks
 
         it 'shows duration column' do
           parent = ForemanTasks::Task.find(FactoryBot.create(:some_task).id)
-          child = ForemanTasks::Task.with_duration.find(FactoryBot.create(:some_task).id)
+          child = ForemanTasks::Task.select_duration.find(FactoryBot.create(:some_task).id)
           child.parent_task_id = parent.id
           child.save!
           get(:sub_tasks, params: { id: parent.id }, session: set_session_user)
@@ -168,6 +168,50 @@ module ForemanTasks
           end
         end
       end
+
+      describe 'cancel' do
+        it 'finds the dynflow task and cancels it' do
+          task = FactoryBot.create(:dynflow_task)
+          ForemanTasks::Task::DynflowTask.any_instance.stubs(:cancel).returns(true)
+
+          post(:cancel, params: { id: task.id }, session: set_session_user)
+
+          assert_response :success
+          data = JSON.parse(response.body)
+          assert_equal 'OK', data['statusText']
+        end
+
+        it 'returns bad request when task cannot be cancelled' do
+          task = FactoryBot.create(:dynflow_task)
+          ForemanTasks::Task::DynflowTask.any_instance.stubs(:cancel).returns(false)
+
+          post(:cancel, params: { id: task.id }, session: set_session_user)
+
+          assert_response :bad_request
+        end
+      end
+
+      describe 'abort' do
+        it 'finds the dynflow task and aborts it' do
+          task = FactoryBot.create(:dynflow_task)
+          ForemanTasks::Task::DynflowTask.any_instance.stubs(:abort).returns(true)
+
+          post(:abort, params: { id: task.id }, session: set_session_user)
+
+          assert_response :success
+          data = JSON.parse(response.body)
+          assert_equal 'OK', data['statusText']
+        end
+
+        it 'returns bad request when the task cannot be aborted' do
+          task = FactoryBot.create(:dynflow_task)
+          ForemanTasks::Task::DynflowTask.any_instance.stubs(:abort).returns(false)
+
+          post(:abort, params: { id: task.id }, session: set_session_user)
+
+          assert_response :bad_request
+        end
+      end
     end
   end
 end

data/test/unit/chaining_test.rb

@@ -0,0 +1,62 @@
+require 'foreman_tasks_test_helper'
+
+module ForemanTasks
+  class ChainingTest < ActiveSupport::TestCase
+    include ForemanTasks::TestHelpers::WithInThreadExecutor
+
+    before do
+      User.current = User.where(:login => 'apiadmin').first
+    end
+
+    it 'creates a scheduled task chained to a dependency task' do
+      triggered = ForemanTasks.trigger(Support::DummyDynflowAction)
+      triggered.finished.wait(30)
+      dependency_task = ForemanTasks::Task::DynflowTask.find_by!(:external_id => triggered.id)
+
+      task = ForemanTasks.chain(dependency_task, Support::DummyDynflowAction)
+
+      assert_kind_of ForemanTasks::Task::DynflowTask, task
+      assert_predicate task, :scheduled?
+
+      dependencies = ForemanTasks.dynflow.world.persistence.find_execution_plan_dependencies(task.execution_plan.id)
+      assert_includes dependencies, dependency_task.external_id
+    end
+
+    it 'accepts multiple dependency tasks' do
+      triggered_1 = ForemanTasks.trigger(Support::DummyDynflowAction)
+      triggered_2 = ForemanTasks.trigger(Support::DummyDynflowAction)
+      triggered_1.finished.wait(30)
+      triggered_2.finished.wait(30)
+      dependency_task_1 = ForemanTasks::Task::DynflowTask.find_by!(:external_id => triggered_1.id)
+      dependency_task_2 = ForemanTasks::Task::DynflowTask.find_by!(:external_id => triggered_2.id)
+
+      task = ForemanTasks.chain([dependency_task_1, dependency_task_2], Support::DummyDynflowAction)
+
+      dependencies = ForemanTasks.dynflow.world.persistence.find_execution_plan_dependencies(task.execution_plan.id)
+      assert_includes dependencies, dependency_task_1.external_id
+      assert_includes dependencies, dependency_task_2.external_id
+    end
+
+    it 'accepts dependency task objects' do
+      triggered = ForemanTasks.trigger(Support::DummyDynflowAction)
+      triggered.finished.wait(30)
+      dependency_task = ForemanTasks::Task::DynflowTask.find_by!(:external_id => triggered.id)
+
+      task = ForemanTasks.chain(dependency_task, Support::DummyDynflowAction)
+
+      dependencies = ForemanTasks.dynflow.world.persistence.find_execution_plan_dependencies(task.execution_plan.id)
+      assert_includes dependencies, dependency_task.external_id
+    end
+
+    it 'accepts dependency tasks as a relation' do
+      triggered = ForemanTasks.trigger(Support::DummyDynflowAction)
+      triggered.finished.wait(30)
+      dependency_task = ForemanTasks::Task::DynflowTask.find_by!(:external_id => triggered.id)
+
+      task = ForemanTasks.chain(ForemanTasks::Task::DynflowTask.where(:id => dependency_task.id), Support::DummyDynflowAction)
+
+      dependencies = ForemanTasks.dynflow.world.persistence.find_execution_plan_dependencies(task.execution_plan.id)
+      assert_includes dependencies, dependency_task.external_id
+    end
+  end
+end

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

@@ -12,6 +12,14 @@ jest.mock('foremanReact/components/common/table', () => ({
 }));
 
 jest.mock('foremanReact/redux/API');
+jest.mock('foremanReact/components/ToastsList', () => ({
+  addToast: toast => ({
+    type: 'TOASTS_ADD',
+    payload: {
+      message: toast,
+    },
+  }),
+}));
 
 const task = ['some-id', 'some-name'];
 

data/webpack/ForemanTasks/Components/TaskActions/TaskActionHelpers.js

@@ -1,5 +1,6 @@
 import { translate as __, sprintf } from 'foremanReact/common/I18n';
 import { addToast } from 'foremanReact/components/ToastsList';
+import { getURIQuery } from 'foremanReact/common/helpers';
 import { TASKS_DASHBOARD_JS_QUERY_MODES } from '../TasksDashboard/TasksDashboardConstants';
 import { timeToHoursNumber } from '../TasksDashboard/TasksDashboardHelper';
 import {
@@ -8,7 +9,12 @@ import {
   warningToastData,
 } from '../common/ToastsHelpers';
 
-export const convertDashboardQuery = query => {
+const getTasksQuery = () => {
+  const url = window.location.pathname + window.location.search;
+  return getURIQuery(url);
+};
+
+export const convertDashboardQuery = () => {
   const {
     time_mode: timeMode,
     time_horizon: timeHorizon,
@@ -16,7 +22,7 @@ export const convertDashboardQuery = query => {
     result,
     search,
     ...rest
-  } = query;
+  } = getTasksQuery();
 
   const hours = timeToHoursNumber(timeHorizon);
   const timestamp = new Date(new Date() - hours * 60 * 60 * 1000);

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

@@ -1,14 +1,19 @@
 import { convertDashboardQuery } from './TaskActionHelpers';
-import {
-  TASKS_DASHBOARD_JS_QUERY_MODES,
-  TASKS_DASHBOARD_AVAILABLE_TIMES,
-} from '../TasksDashboard/TasksDashboardConstants';
 
 let realDate;
 
 describe('convertDashboardQuery', () => {
+  const mockLocation = query => {
+    global.window = Object.create(window);
+    Object.defineProperty(window, 'location', {
+      value: {
+        pathname: '/foreman_tasks/tasks',
+        search: query,
+      },
+      writable: true,
+    });
+  };
   it('convertDashboardQuery should work with full query', () => {
-    // Setup
     const currentDate = new Date('2020-05-08T11:01:58.135Z');
     realDate = Date;
     global.Date = class extends Date {
@@ -20,48 +25,35 @@ describe('convertDashboardQuery', () => {
         return currentDate;
       }
     };
-    const query = {
-      time_mode: TASKS_DASHBOARD_JS_QUERY_MODES.RECENT,
-      time_horizon: TASKS_DASHBOARD_AVAILABLE_TIMES.WEEK,
-      state: 'stopped',
-      result: 'error',
-      search: 'action~job',
-    };
-    const expected =
-      '(state=stopped) and (result=error) and (action~job) and (state_updated_at>2020-05-01T11:01:58.135Z or null? state_updated_at)';
+    mockLocation('?state=stopped&result=error&search=action~job');
+    const expected = '(state=stopped) and (result=error) and (action~job)';
 
-    expect(convertDashboardQuery(query)).toEqual({ search: expected });
+    expect(convertDashboardQuery()).toEqual({ search: expected });
 
-    const query2 = {
-      ...query,
-      time_mode: TASKS_DASHBOARD_JS_QUERY_MODES.OLDER,
-    };
-    const expected2 =
-      '(state=stopped) and (result=error) and (action~job) and (state_updated_at<=2020-05-01T11:01:58.135Z)';
-    expect(convertDashboardQuery(query2)).toEqual({ search: expected2 });
-    // Cleanup
+    mockLocation('?state=stopped&result=error&search=action~job');
+    const expected2 = '(state=stopped) and (result=error) and (action~job)';
+    expect(convertDashboardQuery()).toEqual({ search: expected2 });
     global.Date = realDate;
   });
   it('convertDashboardQuery should work with only search query', () => {
-    const query = {
-      search: 'action~job',
-    };
-    expect(convertDashboardQuery(query)).toEqual({ search: '(action~job)' });
+    mockLocation('?search=action~job');
+    expect(convertDashboardQuery()).toEqual({ search: '(action~job)' });
   });
   it('convertDashboardQuery should work with no query', () => {
-    const query = {};
-    expect(convertDashboardQuery(query)).toEqual({});
+    mockLocation('');
+    expect(convertDashboardQuery()).toEqual({});
   });
   it('convertDashboardQuery should not override unknown keys', () => {
-    const query = { weather: 'nice', search: 'okay', number: 7 };
-    expect(convertDashboardQuery(query)).toEqual({
+    const query = { weather: 'nice', search: 'okay', number: '7' };
+    mockLocation('?weather=nice&search=okay&number=7');
+    expect(convertDashboardQuery()).toEqual({
       ...query,
       search: '(okay)',
     });
   });
   it('convertDashboardQuery should expand other result', () => {
-    const query = { result: 'other' };
-    expect(convertDashboardQuery(query)).toEqual({
+    mockLocation('?result=other');
+    expect(convertDashboardQuery()).toEqual({
       search: '(result ^ (pending, cancelled))',
     });
   });