foreman-tasks 0.15.0 → 0.15.1

data/config/routes.rb

@@ -23,6 +23,9 @@ Foreman::Application.routes.draw do
       end
     end
 
+    match '/ex_tasks' => 'react#index', :via => [:get]
+    match '/ex_tasks/:id' => 'react#index', :via => [:get]
+
     namespace :api do
       resources :recurring_logics, :only => [:index, :show, :update] do
         member do

data/db/migrate/20181019135324_add_remote_task_operation.rb

@@ -0,0 +1,5 @@
+class AddRemoteTaskOperation < ActiveRecord::Migration[5.0]
+  def change
+    add_column :foreman_tasks_remote_tasks, :operation, :string
+  end
+end

data/foreman-tasks.gemspec

@@ -29,7 +29,7 @@ same resource. It also optionally provides Dynflow infrastructure for using it f
   s.extra_rdoc_files = Dir['README*', 'LICENSE']
 
   s.add_dependency "foreman-tasks-core"
-  s.add_dependency "dynflow", '>= 1.2.1'
+  s.add_dependency "dynflow", '>= 1.2.2'
   s.add_dependency "sinatra" # for Dynflow web console
   s.add_dependency "parse-cron", '~> 0.1.4'
   s.add_dependency "get_process_mem" # for memory polling

data/lib/foreman_tasks/engine.rb

@@ -57,6 +57,7 @@ module ForemanTasks
 
         security_block :foreman_tasks do |_map|
           permission :view_foreman_tasks, { :'foreman_tasks/tasks' => [:auto_complete_search, :sub_tasks, :index, :show],
+                                            :'foreman_tasks/react' => [:index],
                                             :'foreman_tasks/api/tasks' => [:bulk_search, :show, :index, :summary] }, :resource_type => ForemanTasks::Task.name
           permission :edit_foreman_tasks, { :'foreman_tasks/tasks' => [:resume, :unlock, :force_unlock, :cancel_step, :cancel, :abort],
                                             :'foreman_tasks/api/tasks' => [:bulk_resume] }, :resource_type => ForemanTasks::Task.name

data/lib/foreman_tasks/version.rb

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

data/lib/foreman_tasks.rb

@@ -12,7 +12,11 @@ module ForemanTasks
   extend Algebrick::Matching
 
   def self.dynflow
-    @dynflow ||= ForemanTasks::Dynflow.new(nil, ForemanTasks::Dynflow::Configuration.new)
+    @dynflow ||= begin
+                   world = ForemanTasks::Dynflow.new(nil, ForemanTasks::Dynflow::Configuration.new)
+                   ForemanTasksCore.dynflow_setup(world) if defined?(ForemanTasksCore)
+                   world
+                 end
   end
 
   def self.trigger(action, *args, &block)

data/package.json

@@ -0,0 +1,117 @@
+{
+  "name": "foreman-tasks",
+  "version": "1.0.0",
+  "description": "Foreman Tasks =============",
+  "main": "index.js",
+  "scripts": {
+    "lint": "./node_modules/.bin/eslint -c .eslintrc webpack/",
+    "test": "node node_modules/.bin/jest --no-cache",
+    "test:watch": "node node_modules/.bin/jest --watchAll",
+    "test:current": "node node_modules/.bin/jest --watch",
+    "coveralls": "cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js",
+    "storybook": "start-storybook -p 6006",
+    "create-react-component": "yo react-domain"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theforeman/foreman-tasks.git"
+  },
+  "bugs": {
+    "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",
+    "babel-cli": "^6.10.1",
+    "babel-core": "^6.26.3",
+    "babel-eslint": "^8.2.3",
+    "babel-jest": "^23.6.0",
+    "babel-loader": "^7.1.1",
+    "babel-plugin-dynamic-import-node": "^2.0.0",
+    "babel-plugin-lodash": "^3.3.4",
+    "babel-plugin-module-resolver": "^3.2.0",
+    "babel-plugin-syntax-dynamic-import": "^6.18.0",
+    "babel-plugin-transform-class-properties": "^6.24.1",
+    "babel-plugin-transform-object-assign": "^6.8.0",
+    "babel-plugin-transform-object-rest-spread": "^6.8.0",
+    "babel-preset-env": "^1.7.0",
+    "babel-preset-react": "^6.5.0",
+    "coveralls": "^3.0.0",
+    "enzyme": "^3.4.0",
+    "enzyme-adapter-react-16": "^1.4.0",
+    "enzyme-to-json": "^3.2.1",
+    "eslint": "^4.10.0",
+    "eslint-import-resolver-babel-module": "^4.0.0",
+    "eslint-plugin-patternfly-react": "0.2.0",
+    "jest-cli": "^23.6.0",
+    "jest-prop-type-error": "^1.1.0",
+    "patternfly": "^3.59.1",
+    "prettier": "^1.13.5",
+    "raf": "^3.4.0",
+    "react-redux-test-utils": "^0.1.1",
+    "react-remarkable": "^1.1.3",
+    "stylelint": "^9.3.0",
+    "stylelint-config-standard": "^18.0.0"
+  },
+  "dependencies": {
+    "babel-polyfill": "^6.26.0",
+    "classnames": "^2.2.5",
+    "patternfly-react": "^2.29.0",
+    "prop-types": "^15.6.0",
+    "react": "^16.8.1",
+    "react-dom": "^16.8.1",
+    "react-redux": "^5.0.6",
+    "react-router": "^4.3.1",
+    "react-router-bootstrap": "^0.24.4",
+    "react-router-dom": "^4.3.1",
+    "redux": "^3.6.0",
+    "redux-thunk": "^2.3.0",
+    "reselect": "^3.0.1",
+    "seamless-immutable": "^7.1.2",
+    "uuid": "^3.3.2"
+  },
+  "jest": {
+    "automock": true,
+    "verbose": true,
+    "testMatch": [
+      "**/*.test.js"
+    ],
+    "testURL": "http://localhost/",
+    "collectCoverage": true,
+    "collectCoverageFrom": [
+      "webpack/**/*.js",
+      "!webpack/index.js",
+      "!webpack/test_setup.js",
+      "!webpack/**/bundle*",
+      "!webpack/stories/**",
+      "!webpack/**/*stories.js"
+    ],
+    "coverageReporters": [
+      "lcov"
+    ],
+    "unmockedModulePathPatterns": [
+      "webpack/",
+      "react",
+      "node_modules/"
+    ],
+    "moduleNameMapper": {
+      "^.+\\.(png|gif|css|scss)$": "identity-obj-proxy"
+    },
+    "globals": {
+      "__testing__": true
+    },
+    "transform": {
+      "^.+\\.js$": "babel-jest"
+    },
+    "moduleDirectories": [
+      "node_modules",
+      "webpack"
+    ],
+    "setupFiles": [
+      "raf/polyfill",
+      "jest-prop-type-error",
+      "./webpack/test_setup.js"
+    ]
+  }
+}

data/script/travis_run_js_tests.sh

@@ -0,0 +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
+  npm run test;
+  npm run coveralls;
+  npm run lint;
+fi

data/test/controllers/api/tasks_controller_test.rb

@@ -65,6 +65,9 @@ module ForemanTasks
       describe 'POST /tasks/callback' do
         it 'passes the data to the corresponding action' do
           Support::DummyProxyAction.reset
+          ForemanTasks::RemoteTask.any_instance
+                                  .expects(:proxy)
+                                  .returns(Support::DummyProxyAction.proxy)
 
           triggered = ForemanTasks.trigger(Support::DummyProxyAction,
                                            Support::DummyProxyAction.proxy,

data/test/core/unit/dispatcher_test.rb

@@ -0,0 +1,43 @@
+require 'foreman_tasks_core_test_helper'
+require 'foreman_tasks/test_helpers'
+require 'foreman_tasks_core/runner'
+
+module ForemanTasksCore
+  module Runner
+    describe Dispatcher::RunnerActor do
+      include ForemanTasks::TestHelpers::WithInThreadExecutor
+
+      let(:dispatcher) { Dispatcher.instance }
+      let(:suspended_action) { mock }
+      let(:runner) { mock.tap { |r| r.stubs(:id) } }
+      let(:clock) { ForemanTasks.dynflow.world.clock }
+      let(:logger) { mock.tap { |l| l.stubs(:debug) } }
+      let(:actor) do
+        Dispatcher::RunnerActor.new dispatcher, suspended_action, runner, clock, logger
+      end
+
+      it 'delivers all updates to actions' do
+        targets = (0..2).map { mock }.each_with_index { |mock, index| mock.expects(:<<).with(index) }
+        updates = targets.each_with_index.reduce({}) { |acc, (cur, index)| acc.merge(cur => index) }
+        runner.expects(:run_refresh).returns(updates)
+        actor.expects(:plan_next_refresh)
+        actor.refresh_runner
+      end
+
+      it 'plans next refresh' do
+        runner.expects(:run_refresh).returns({})
+        actor.expects(:plan_next_refresh)
+        actor.refresh_runner
+      end
+
+      it 'does not plan next resfresh if done' do
+        update = Update.new(nil, 0)
+        suspended_action.expects(:<<).with(update)
+        runner.expects(:run_refresh).returns(suspended_action => update)
+        dispatcher.expects(:finish)
+        dispatcher.ticker.expects(:tell).never
+        actor.refresh_runner
+      end
+    end
+  end
+end

data/test/core/unit/runner_test.rb

@@ -0,0 +1,129 @@
+require 'foreman_tasks_core_test_helper'
+require 'foreman_tasks/test_helpers'
+require 'foreman_tasks_core/runner'
+require 'ostruct'
+
+module ForemanTasksCore
+  module Runner
+    class RunnerTest < ActiveSupport::TestCase
+      include ForemanTasks::TestHelpers::WithInThreadExecutor
+
+      describe Base do
+        let(:suspended_action) { Class.new }
+        let(:runner) { Base.new suspended_action: suspended_action }
+
+        describe '#generate_updates' do
+          it 'returns empty hash when there are no outputs' do
+            runner.generate_updates.must_be :empty?
+          end
+
+          it 'returns a hash with outputs' do
+            message = 'a message'
+            type = 'stdout'
+            runner.publish_data(message, type)
+            updates = runner.generate_updates
+            updates.keys.must_equal [suspended_action]
+            update = updates.values.first
+            update.exit_status.must_be :nil?
+            update.continuous_output.raw_outputs.count.must_equal 1
+          end
+
+          it 'works in compatibility mode' do
+            runner = Base.new
+            message = 'a message'
+            type = 'stdout'
+            runner.publish_data(message, type)
+            updates = runner.generate_updates
+            updates.keys.must_equal [nil]
+            update = updates.values.first
+            update.exit_status.must_be :nil?
+            update.continuous_output.raw_outputs.count.must_equal 1
+          end
+        end
+      end
+
+      describe Parent do
+        let(:suspended_action) { ::Dynflow::Action::Suspended.allocate }
+        let(:runner) { Parent.new targets, suspended_action: suspended_action }
+        let(:targets) do
+          { 'foo' => { 'execution_plan_id' => '123', 'run_step_id' => 2 },
+            'bar' => { 'execution_plan_id' => '456', 'run_step_id' => 2 } }
+        end
+
+        describe '#initialize_continuous_outputs' do
+          it 'initializes outputs for targets and parent' do
+            outputs = runner.initialize_continuous_outputs
+            outputs.keys.count.must_equal 3
+            outputs.values.each { |output| output.must_be_instance_of ContinuousOutput }
+          end
+        end
+
+        describe '#generate_updates' do
+          it 'returns only updates for hosts with pending outputs' do
+            runner.generate_updates.must_equal({})
+            runner.publish_data_for('foo', 'something', 'something')
+            updates = runner.generate_updates
+            updates.keys.count.must_equal 1
+          end
+
+          it 'works in compatibility mode' do
+            runner = Parent.new targets
+            runner.generate_updates.must_equal({})
+            runner.broadcast_data('something', 'stdout')
+            updates = runner.generate_updates
+            updates.keys.count.must_equal 3
+            # One of the keys is nil in compatibility mode
+            updates.keys.compact.count.must_equal 2
+            updates.keys.compact.each do |key|
+              key.must_be_instance_of ::Dynflow::Action::Suspended
+            end
+          end
+
+          it 'works without compatibility mode' do
+            runner.broadcast_data('something', 'stdout')
+            updates = runner.generate_updates
+            updates.keys.count.must_equal 3
+            updates.keys.each do |key|
+              key.must_be_instance_of ::Dynflow::Action::Suspended
+            end
+          end
+        end
+
+        describe '#publish_data_for' do
+          it 'publishes data for a single host' do
+            runner.publish_data_for('foo', 'message', 'stdout')
+            runner.generate_updates.keys.count.must_equal 1
+          end
+        end
+
+        describe '#broadcast_data' do
+          it 'publishes data for all hosts' do
+            runner.broadcast_data('message', 'stdout')
+            runner.generate_updates.keys.count.must_equal 3
+          end
+        end
+
+        describe '#publish_exception' do
+          let(:exception) do
+            exception = RuntimeError.new
+            exception.stubs(:backtrace).returns([])
+            exception
+          end
+
+          before { runner.logger.stubs(:error) }
+
+          it 'broadcasts the exception to all targets' do
+            runner.expects(:publish_exit_status).never
+            runner.publish_exception('general failure', exception, false)
+            runner.generate_updates.keys.count.must_equal 3
+          end
+
+          it 'publishes exit status if fatal' do
+            runner.expects(:publish_exit_status)
+            runner.publish_exception('general failure', exception, true)
+          end
+        end
+      end
+    end
+  end
+end

data/test/core/unit/task_launcher_test.rb

@@ -0,0 +1,56 @@
+require 'foreman_tasks_core_test_helper'
+require 'foreman_tasks/test_helpers'
+
+module ForemanTasksCore
+  module TaskLauncher
+    class TaskLauncherTest < ActiveSupport::TestCase
+      include ForemanTasks::TestHelpers::WithInThreadExecutor
+
+      describe ForemanTasksCore::TaskLauncher do
+        let(:launcher) { launcher_class.new ForemanTasks.dynflow.world, {} }
+        let(:launcher_input) { { 'action_class' => Support::DummyDynflowAction.to_s, 'action_input' => input } }
+        let(:input) { { :do => :something } }
+        let(:expected_result) { input.merge(:callback_host => {}) }
+
+        describe ForemanTasksCore::TaskLauncher::Single do
+          let(:launcher_class) { Single }
+
+          it 'triggers an action' do
+            Support::DummyDynflowAction.any_instance.expects(:plan).with do |arg|
+              arg.must_equal(expected_result)
+            end
+            launcher.launch!(launcher_input)
+          end
+
+          it 'provides results' do
+            plan = launcher.launch!(launcher_input).finished.value!
+            launcher.results[:result].must_equal 'success'
+            plan.result.must_equal :success
+          end
+        end
+
+        describe ForemanTasksCore::TaskLauncher::Batch do
+          let(:launcher_class) { Batch }
+
+          it 'triggers the actions' do
+            Support::DummyDynflowAction.any_instance.expects(:plan).with { |arg| arg == expected_result }.twice
+            parent = launcher.launch!('foo' => launcher_input, 'bar' => launcher_input)
+            plan = parent.finished.value!
+            plan.result.must_equal :success
+            plan.sub_plans.count.must_equal 2
+          end
+
+          it 'provides results' do
+            launcher.launch!('foo' => launcher_input, 'bar' => launcher_input)
+            launcher.results.keys.must_equal %w[foo bar]
+            launcher.results.values.each do |result|
+              plan = ForemanTasks.dynflow.world.persistence.load_execution_plan(result[:task_id])
+              result[:result].must_equal 'success'
+              plan.result.must_equal :success
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/foreman_tasks_core_test_helper.rb

@@ -0,0 +1,4 @@
+require 'foreman_tasks_test_helper'
+require 'foreman_tasks_core'
+
+ForemanTasksCore.dynflow_setup ForemanTasks.dynflow.world

data/test/support/dummy_proxy_action.rb

@@ -2,6 +2,14 @@ require 'securerandom'
 
 module Support
   class DummyProxyAction < Actions::ProxyAction
+    class DummyProxyVersion
+      attr_reader :version
+
+      def initialize(version)
+        @version = { 'version' => version }
+      end
+    end
+
     class DummyProxy
       attr_reader :log, :task_triggered, :uuid
 
@@ -14,7 +22,7 @@ module Support
       def trigger_task(*args)
         @log[:trigger_task] << args
         @task_triggered.fulfill(true)
-        { 'task_id' => @uuid }
+        { 'task_id' => @uuid, 'result' => 'success' }
       end
 
       def cancel_task(*args)
@@ -24,6 +32,10 @@ module Support
       def url
         'proxy.example.com'
       end
+
+      def statuses
+        { version: DummyProxyVersion.new('1.21.0') }
+      end
     end
 
     class ProxySelector < ::ForemanTasks::ProxySelector
@@ -32,6 +44,10 @@ module Support
       end
     end
 
+    def proxy_operation_name
+      'support'
+    end
+
     def proxy
       self.class.proxy
     end

data/test/unit/actions/proxy_action_test.rb

@@ -8,14 +8,18 @@ module ForemanTasks
       let(:secrets) do
         { 'logins' => { 'admin' => 'changeme', 'root' => 'toor' } }
       end
+      let(:batch_triggering) { false }
 
       before do
+        Support::DummyProxyAction.any_instance.stubs(:with_batch_triggering?).returns(batch_triggering)
         Support::DummyProxyAction.reset
+        RemoteTask.any_instance.stubs(:proxy).returns(Support::DummyProxyAction.proxy)
         @action = create_and_plan_action(Support::DummyProxyAction,
                                          Support::DummyProxyAction.proxy,
                                          'Proxy::DummyAction',
                                          'foo' => 'bar',
-                                         'secrets' => secrets)
+                                         'secrets' => secrets,
+                                         'use_batch_triggering' => batch_triggering)
         @action = run_action(@action)
       end
 
@@ -26,12 +30,26 @@ module ForemanTasks
                            { 'foo' => 'bar',
                              'secrets' => secrets,
                              'connection_options' =>
-                                 { 'retry_interval' => 15, 'retry_count' => 4 },
+                               { 'retry_interval' => 15, 'retry_count' => 4,
+                                 'proxy_batch_triggering' => batch_triggering },
+                             'use_batch_triggering' => batch_triggering,
                              'proxy_url' => 'proxy.example.com',
                              'proxy_action_name' => 'Proxy::DummyAction',
+                             "proxy_version" => { "major" => 1, "minor" => 21, "patch" => 0 },
                              'callback' => { 'task_id' => Support::DummyProxyAction.proxy.uuid, 'step_id' => @action.run_step_id } }]
           proxy_call.must_equal(expected_call)
         end
+
+        describe 'with batch triggering' do
+          let(:batch_triggering) { true }
+          it 'create remote tasks for batch triggering' do
+            task = RemoteTask.first
+            task.state.must_equal 'new'
+            task.execution_plan_id.must_equal @action.execution_plan_id
+            task.operation.must_equal 'support'
+            task.remote_task_id.must_be :nil?
+          end
+        end
       end
 
       describe 'resumed run' do

data/test/unit/actions/recurring_action_test.rb

@@ -55,7 +55,7 @@ module ForemanTasks
 
       specify 'it triggers the repeat when the task goes into planned state' do
         delay_options = recurring_logic.generate_delay_options
-        task = ForemanTasks.delay HookedAction, delay_options, args
+        task = ForemanTasks.delay HookedAction, delay_options, *args
         recurring_logic.tasks.count.must_equal 1
 
         # Perform planning of the delayed plan

data/test/unit/remote_task_test.rb

@@ -0,0 +1,41 @@
+require 'foreman_tasks_test_helper'
+
+module ForemanTasks
+  class RemoteTaskTest < ActiveSupport::TestCase
+    describe 'batch triggering' do
+      let(:remote_tasks) do
+        (1..5).map do |i|
+          task = RemoteTask.new :execution_plan_id => i, :step_id => 1, :proxy_url => "something"
+          task.expects(:proxy_input).returns({})
+          task.expects(:proxy_action_name).returns('MyProxyAction')
+          task.save!
+          task
+        end
+      end
+
+      it 'triggers in batches' do
+        results = remote_tasks.reduce({}) do |acc, cur|
+          acc.merge(cur.execution_plan_id.to_s => { 'task_id' => cur.id + 5, 'result' => 'success' })
+        end
+
+        fake_proxy = mock
+        fake_proxy.expects(:launch_tasks).returns(results)
+        remote_tasks.first.expects(:proxy).returns(fake_proxy)
+        RemoteTask.batch_trigger('a_operation', remote_tasks)
+        remote_tasks.each do |remote_task|
+          remote_task.reload
+          remote_task.state.must_equal 'triggered'
+          remote_task.remote_task_id.must_equal((remote_task.id + 5).to_s)
+        end
+      end
+
+      it 'fallbacks to old way when batch trigger gets 404' do
+        fake_proxy = mock
+        fake_proxy.expects(:launch_tasks).raises(RestClient::NotFound.new)
+        remote_tasks.first.expects(:proxy).returns(fake_proxy)
+        remote_tasks.each { |task| task.expects(:trigger) }
+        RemoteTask.batch_trigger('a_operation', remote_tasks)
+      end
+    end
+  end
+end

data/test/unit/task_test.rb

@@ -84,9 +84,11 @@ class TasksTest < ActiveSupport::TestCase
   end
 
   describe 'task without valid execution plan' do
+    let(:missing_task_uuid) { '11111111-2222-3333-4444-555555555555' }
+
     let(:task) do
       task = FactoryBot.create(:dynflow_task).tap do |task|
-        task.external_id = 'missing-task'
+        task.external_id = missing_task_uuid
         task.save
       end
       ForemanTasks::Task.find(task.id)

data/webpack/ForemanTasks/ForemanTasks.js

@@ -0,0 +1,27 @@
+import React from 'react';
+import { BrowserRouter } from 'react-router-dom';
+import { LinkContainer } from 'react-router-bootstrap';
+import { ButtonGroup, Button } from 'patternfly-react';
+
+import routes from './Routes/ForemanTasksRoutes';
+import ForemanTasksRouter from './Routes/ForemanTasksRouter';
+
+const ForemanTasks = () => (
+  <BrowserRouter>
+    <div>
+      <div style={{ paddingTop: '10px', paddingBottom: '10px' }}>
+        <ButtonGroup bsSize="large">
+          <LinkContainer to={routes.indexTasks.path}>
+            <Button bsStyle="link">index-tasks-page</Button>
+          </LinkContainer>
+          <LinkContainer to={routes.showTask.path.replace(':id', 'some-id')}>
+            <Button bsStyle="link">show-task-page</Button>
+          </LinkContainer>
+        </ButtonGroup>
+      </div>
+      <ForemanTasksRouter />
+    </div>
+  </BrowserRouter>
+);
+
+export default ForemanTasks;

data/webpack/ForemanTasks/ForemanTasks.test.js

@@ -0,0 +1,10 @@
+import { testComponentSnapshotsWithFixtures } from 'react-redux-test-utils';
+
+import ForemanTasks from './ForemanTasks';
+
+const fixtures = {
+  'render without Props': {},
+};
+
+describe('ForemanTasks', () =>
+  testComponentSnapshotsWithFixtures(ForemanTasks, fixtures));

data/webpack/ForemanTasks/Routes/ForemanTasksRouter.js

@@ -0,0 +1,14 @@
+import React from 'react';
+import { Switch, Route } from 'react-router-dom';
+
+import routes from './ForemanTasksRoutes';
+
+const ForemanTasksRouter = () => (
+  <Switch>
+    {Object.entries(routes).map(([key, props]) => (
+      <Route key={key} {...props} />
+    ))}
+  </Switch>
+);
+
+export default ForemanTasksRouter;

data/webpack/ForemanTasks/Routes/ForemanTasksRouter.test.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import { testComponentSnapshotsWithFixtures } from 'react-redux-test-utils';
+
+import ForemanTasksRouter from './ForemanTasksRouter';
+
+jest.mock('./ForemanTasksRoutes', () => ({
+  someRoute: {
+    path: '/some-route',
+    render: props => <span {...props}>some-route</span>,
+  },
+  someOtherRoute: {
+    path: '/some-other-route',
+    render: props => <span {...props}>some-other-route</span>,
+  },
+}));
+
+const fixtures = {
+  'render without Props': {},
+};
+
+describe('ForemanTasksRouter', () =>
+  testComponentSnapshotsWithFixtures(ForemanTasksRouter, fixtures));