foreman-tasks 4.1.6 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 113adfd7bfb8197852703d6bb8ca03e724b355a55723b8a0146c016607bb0024
-  data.tar.gz: 9117207fc628934e82528eb2238f0bcb010e3f92654b621675485ca4f1a59f9e
+  metadata.gz: 3e48966ae6049eb85b3051151b7d15d48beb91a55b3580525fe114a3e045ad0f
+  data.tar.gz: 93da446f348f1a27600a79223ba4daab0e5e83417db711919392cfab2eedf57a
 SHA512:
-  metadata.gz: 0b8228f8d1ea657cf35106884d1d1b537f0ac910af82c1d74f43a2eb28d2337c6a76cd4f89d927a7731af222453acd6439110b92281a9acbadf1696d1dd55ff4
-  data.tar.gz: 365c53bf9ce1c3e3e15a9632828f867a83d74ecad2fdd7c1c7ce1b3ecd4d6d6f6775adef6f1e02fb6eff79cf6a6c437663e0a4c8e1cd773c9dded48445138cee
+  metadata.gz: 740ff700f75e43154068d3838611dc7c7306d7f5da91e3d2d41a6fce5ea0ccde84bd5f027545f24874b8fb112d9848505ae2a535386ee2f356852695dacd61a2
+  data.tar.gz: 8f61c3c868af4b7c3d3173b728858537c72ccf695e60b63971ec19f8a675a6ad9c19ecdd3dedb2549e2eb27b7cde62a2be67ead4d737bb43b774301abb303228

data/.github/workflows/ruby_tests.yml

@@ -72,5 +72,4 @@ jobs:
       - name: Run plugin tests
         run: |
           bundle exec rake test:foreman_tasks
-          bundle exec rake test:foreman_tasks_core
           bundle exec rake test TEST="test/unit/foreman/access_permissions_test.rb"

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

@@ -192,7 +192,7 @@ module ForemanTasks
           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 = DashboardTableFilter.new(resource_scope_for_index, params).scope.order(params[:order].to_s)
       end
 
       def search_options
@@ -260,7 +260,7 @@ module ForemanTasks
             raise BadRequest,
                   _('Resource search_params requires resource_type and resource_id to be specified')
           end
-          scope.joins(:links).where(foreman_tasks_links:
+          scope.joins(:locks).where(foreman_tasks_locks:
                                         { resource_type: search_params[:resource_type],
                                           resource_id:   search_params[:resource_id] })
         when 'task'

data/app/controllers/foreman_tasks/tasks_controller.rb

@@ -72,15 +72,17 @@ module ForemanTasks
     def unlock
       task = find_dynflow_task
       if task.paused?
-        force_unlock(task)
+        task.state = :stopped
+        task.save!
+        render json: { statusText: 'OK' }
       else
         render json: {}, status: :bad_request
       end
     end
 
-    def force_unlock(task = find_dynflow_task)
+    def force_unlock
+      task       = find_dynflow_task
       task.state = :stopped
-      task.locks.destroy_all
       task.save!
       render json: { statusText: 'OK' }
     end
@@ -125,9 +127,8 @@ module ForemanTasks
     end
 
     def filter(scope, paginate: true)
-      search = current_taxonomy_search
-      search = [search, params[:search]].select(&:present?).join(' AND ')
-      scope = scope.search_for(search, order: params[:order])
+      scope = DashboardTableFilter.new(scope, params).scope
+      scope = scope.search_for(search_query, order: params[:order])
       scope = scope.paginate(page: params[:page], per_page: params[:per_page]) if paginate
       scope.distinct
     end

data/app/graphql/types/recurring_logic.rb

@@ -0,0 +1,18 @@
+module Types
+  class RecurringLogic < Types::BaseObject
+    description 'A Recurring Logic'
+    model_class ::ForemanTasks::RecurringLogic
+
+    global_id_field :id
+    field :cron_line, String
+    field :end_time, GraphQL::Types::ISO8601DateTime
+    field :max_iteration, Integer
+    field :iteration, Integer
+    field :state, String
+    belongs_to :triggering, Types::Triggering
+
+    def self.graphql_definition
+      super.tap { |type| type.instance_variable_set(:@name, 'ForemanTasks::RecurringLogic') }
+    end
+  end
+end

data/app/graphql/types/task.rb

@@ -0,0 +1,25 @@
+module Types
+  class Task < Types::BaseObject
+    description 'A Task'
+    model_class ::ForemanTasks::Task
+
+    global_id_field :id
+    field :type, String
+    field :label, String
+    field :started_at, GraphQL::Types::ISO8601DateTime
+    field :ended_at, GraphQL::Types::ISO8601DateTime
+    field :state, String
+    field :result, String
+    field :external_id, String
+    field :parent_task_id, String
+    field :start_at, GraphQL::Types::ISO8601DateTime
+    field :start_before, GraphQL::Types::ISO8601DateTime
+    field :action, String
+    field :user_id, Integer
+    field :state_updated_at, GraphQL::Types::ISO8601DateTime
+
+    def self.graphql_definition
+      super.tap { |type| type.instance_variable_set(:@name, 'ForemanTasks::Task') }
+    end
+  end
+end

data/app/graphql/types/triggering.rb

@@ -0,0 +1,16 @@
+module Types
+  class Triggering < Types::BaseObject
+    description 'A Task Triggering'
+    model_class ::ForemanTasks::Triggering
+
+    global_id_field :id
+    field :mode, String
+    field :start_at, GraphQL::Types::ISO8601DateTime
+    field :start_before, GraphQL::Types::ISO8601DateTime
+    field :recurring_logic, Types::RecurringLogic
+
+    def self.graphql_definition
+      super.tap { |type| type.instance_variable_set(:@name, 'ForemanTasks::Triggering') }
+    end
+  end
+end

data/app/lib/actions/helpers/with_continuous_output.rb

@@ -8,7 +8,7 @@ module Actions
       end
 
       def continuous_output
-        continuous_output = ::ForemanTasksCore::ContinuousOutput.new
+        continuous_output = ::ForemanTasks::ContinuousOutput.new
         continuous_output_providers.each do |continous_output_provider|
           continous_output_provider.fill_continuous_output(continuous_output)
         end

data/app/lib/actions/middleware/watch_delegated_proxy_sub_tasks.rb

@@ -20,7 +20,9 @@ module Actions
       private
 
       def set_clock
-        action.plan_event(CheckOnProxyActions, POLL_INTERVAL, optional: true)
+        action.world.clock.ping action.send(:suspended_action),
+                                POLL_INTERVAL,
+                                CheckOnProxyActions
       end
 
       def check_triggered
@@ -42,7 +44,9 @@ module Actions
 
       def notify(event, tasks)
         tasks.each do |task|
-          action.plan_event(event, execution_plan_id: task.execution_plan_id, step_id: task.step_id)
+          action.world.event task.execution_plan_id,
+                             task.step_id,
+                             event
         end
       end
 

data/app/models/foreman_tasks/recurring_logic.rb

@@ -4,6 +4,8 @@ module ForemanTasks
   class RecurringLogic < ApplicationRecord
     include Authorizable
 
+    graphql_type '::Types::RecurringLogic'
+
     belongs_to :task_group
     belongs_to :triggering
 

data/app/models/foreman_tasks/task/dynflow_task.rb

@@ -140,17 +140,12 @@ module ForemanTasks
 
     def main_action
       return @main_action if defined?(@main_action)
-
-      @main_action = execution_plan && execution_plan.root_plan_step.try(:action, execution_plan)
       if active_job?
         job_data = active_job_data
-        begin
-          @main_action = active_job_action(job_data['job_class'], job_data['arguments'])
-        rescue => e
-          Foreman::Logging.exception("Failed to load ActiveJob for task #{id}", e, :logger => 'foreman-tasks')
-        end
+        @main_action = active_job_action(job_data['job_class'], job_data['arguments'])
+      else
+        @main_action = execution_plan && execution_plan.root_plan_step.try(:action, execution_plan)
       end
-      @main_action
     end
 
     # The class for ActiveJob jobs in Dynflow, JobWrapper is not expected to

data/app/models/foreman_tasks/task.rb

@@ -5,6 +5,8 @@ module ForemanTasks
     include Authorizable
     extend Search
 
+    graphql_type '::Types::Task'
+
     def check_permissions_after_save
       # there's no create_tasks permission, tasks are created as a result of internal actions, in such case we
       # don't do authorization, that should have been performed on wrapping action level
@@ -255,6 +257,32 @@ module ForemanTasks
       main_action.continuous_output.raw_outputs
     end
 
+    def self.latest_tasks_by_resource_ids(label, resource_type, resource_ids)
+      tasks = arel_table
+      links = ForemanTasks::Link.arel_table
+      started_at = tasks[:started_at]
+      resource_id = links[:resource_id]
+
+      base_combined_table = tasks
+                            .join(links).on(tasks[:id].eq(links[:task_id]))
+                            .where(tasks[:label].eq(label)
+                                                .and(links[:resource_type].eq(resource_type))
+                                                .and(links[:resource_id].in(resource_ids)))
+
+      grouped = base_combined_table.project(
+        started_at.maximum.as('started_at_max'),
+        resource_id
+      ).group(resource_id).order(resource_id).as('grouped')
+
+      max_per_resource_id = tasks
+                            .join(links).on(tasks[:id].eq(links[:task_id]))
+                            .join(grouped).on(grouped[:started_at_max].eq(started_at).and(grouped[:resource_id].eq(resource_id)))
+                            .distinct
+                            .project(tasks[Arel.star], grouped[:resource_id])
+
+      find_by_sql(max_per_resource_id.to_sql).index_by(&:resource_id)
+    end
+
     protected
 
     def generate_id

data/app/models/foreman_tasks/triggering.rb

@@ -5,6 +5,8 @@ module ForemanTasks
               :end_time].freeze
     attr_accessor(*PARAMS)
 
+    graphql_type '::Types::Triggering'
+
     before_save do
       if future?
         parse_start_at!

data/app/services/foreman_tasks/dashboard_table_filter.rb

@@ -0,0 +1,56 @@
+module ForemanTasks
+  # narrows the scope for the tasks table based on params coming from tasks dashboard
+  #
+  # Supported filters:
+  #
+  #  * :result
+  #  * :state
+  #  * :time_horizon - expected format of Hxy, where the xy is the time horizon in hours we're interested in
+  #      :time_mode can be set to 'recent' to filter the recent tasks, or 'older' (default) to filter earlier ones
+  class DashboardTableFilter
+    def initialize(scope, params)
+      @scope = scope
+      @params = params
+    end
+
+    def scope
+      @new_scope = @scope
+      scope_by(:result)
+      scope_by(:state)
+      scope_by_time
+      @new_scope
+    end
+
+    private
+
+    def scope_by(field)
+      if (field == :result) && (@params[field] == 'other')
+        @new_scope = @new_scope.where(:result => ['cancelled', 'pending'])
+      elsif @params[field].present?
+        @new_scope = @new_scope.where(field => @params[field])
+      end
+    end
+
+    def scope_by_time
+      return if @params[:time_horizon].blank?
+      hours = if @params[:time_horizon].casecmp('week') == 0
+                24 * 7
+              else
+                @params[:time_horizon][/\AH(\d{1,2})$/i, 1]
+              end
+
+      unless hours
+        raise Foreman::Exception, 'Unexpected format of time: should be in form of "H24" or equal to "week"'
+      end
+      timestamp = Time.now.utc - hours.to_i.hours
+      case @params[:time_mode]
+      when 'recent'
+        operator = '>'
+      else
+        operator = '<'
+        search_suffix = 'OR state_updated_at IS NULL'
+      end
+      @new_scope = @new_scope.where("state_updated_at #{operator} ? #{search_suffix}", timestamp)
+    end
+  end
+end

data/foreman-tasks.gemspec

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

data/lib/foreman_tasks/continuous_output.rb

@@ -0,0 +1,50 @@
+module ForemanTasks
+  class ContinuousOutput
+    attr_accessor :raw_outputs
+
+    def initialize(raw_outputs = [])
+      @raw_outputs = []
+      raw_outputs.each { |raw_output| add_raw_output(raw_output) }
+    end
+
+    def add_raw_output(raw_output)
+      missing_args = %w[output_type output timestamp] - raw_output.keys
+      unless missing_args.empty?
+        raise ArgumentError, "Missing args for raw output: #{missing_args.inspect}"
+      end
+      @raw_outputs << raw_output
+    end
+
+    def empty?
+      @raw_outputs.empty?
+    end
+
+    def last_timestamp
+      return if @raw_outputs.empty?
+      @raw_outputs.last.fetch('timestamp')
+    end
+
+    def sort!
+      @raw_outputs.sort_by! { |record| record['timestamp'].to_f }
+    end
+
+    def humanize
+      sort!
+      raw_outputs.map { |output| output['output'] }.join("\n")
+    end
+
+    def add_exception(context, exception, timestamp = Time.now.getlocal)
+      add_output(context + ": #{exception.class} - #{exception.message}", 'debug', timestamp)
+    end
+
+    def add_output(*args)
+      add_raw_output(self.class.format_output(*args))
+    end
+
+    def self.format_output(message, type = 'debug', timestamp = Time.now.getlocal)
+      { 'output_type' => type,
+        'output' => message,
+        'timestamp' => timestamp.to_f }
+    end
+  end
+end

data/lib/foreman_tasks/engine.rb

@@ -1,4 +1,3 @@
-require 'foreman_tasks_core'
 require 'fast_gettext'
 require 'gettext_i18n_rails'
 
@@ -34,7 +33,7 @@ module ForemanTasks
 
     initializer 'foreman_tasks.register_plugin', :before => :finisher_hook do |_app|
       Foreman::Plugin.register :"foreman-tasks" do
-        requires_foreman '>= 2.4.0'
+        requires_foreman '>= 2.6.0'
         divider :top_menu, :parent => :monitor_menu, :last => true, :caption => N_('Foreman Tasks')
         menu :top_menu, :tasks,
              :url_hash => { :controller => 'foreman_tasks/tasks', :action => :index },
@@ -66,6 +65,11 @@ module ForemanTasks
 
         add_all_permissions_to_default_roles
 
+        register_graphql_query_field :task, '::Types::Task', :record_field
+        register_graphql_query_field :tasks, '::Types::Task', :collection_field
+        register_graphql_query_field :recurring_logic, '::Types::RecurringLogic', :record_field
+        register_graphql_query_field :recurring_logics, '::Types::RecurringLogic', :collection_field
+
         logger :dynflow, :enabled => true
         logger :action, :enabled => true
 
@@ -116,19 +120,6 @@ module ForemanTasks
         world.middleware.use Actions::Middleware::KeepCurrentRequestID
         world.middleware.use ::Actions::Middleware::LoadSettingValues if Gem::Version.new(::SETTINGS[:version]) >= Gem::Version.new('2.5')
       end
-
-      ::ForemanTasks.dynflow.config.on_init do |world|
-        ForemanTasksCore.dynflow_setup(world)
-      end
-    end
-
-    initializer 'foreman_tasks.set_core_settings' do
-      ForemanTasksCore::SettingsLoader.settings_registry.each_key do |settings_keys|
-        settings = settings_keys.inject({}) do |h, settings_key|
-          h.merge(SETTINGS[settings_key] || {})
-        end
-        ForemanTasksCore::SettingsLoader.setup_settings(settings_keys.first, settings)
-      end
     end
 
     # to enable async Foreman operations using Dynflow

data/lib/foreman_tasks/tasks/export_tasks.rake

@@ -12,7 +12,7 @@ namespace :foreman_tasks do
 
       * TASK_SEARCH     : scoped search filter (example: 'label = "Actions::Foreman::Host::ImportFacts"')
       * TASK_FILE       : file to export to
-      * TASK_FORMAT     : format to use for the export (either html, html-dir or csv)
+      * TASK_FORMAT     : format to use for the export (either html or csv)
       * TASK_DAYS       : number of days to go back
 
     If TASK_SEARCH is not defined, it defaults to all tasks in the past 7 days and
@@ -185,27 +185,23 @@ namespace :foreman_tasks do
     end
 
     class PageHelper
-      def self.pagify(io, template = nil)
-        io.write <<~HTML
-          <html>
-            <head>
-              <title>Dynflow Console</title>
-              <script src="jquery.js"></script>
-              <link rel="stylesheet" type="text/css" href="bootstrap.css">
-              <link rel="stylesheet" type="text/css" href="application.css">
-              <script src="bootstrap.js"></script>
-              <script src="run_prettify.js"></script>
-              <script src="application.js"></script>
-            </head>
-          <body>
+      def self.pagify(template)
+        pre = <<-HTML
+       <html>
+       <head>
+       <title>Dynflow Console</title>
+       <script src="jquery.js"></script>
+       <link rel="stylesheet" type="text/css" href="bootstrap.css">
+       <link rel="stylesheet" type="text/css" href="application.css">
+       <script src="bootstrap.js"></script>
+       <script src="run_prettify.js"></script>
+       <script src="application.js"></script>
+       </head>
+       <body>
+          #{template}
+       <body>
+       </html>
         HTML
-        if block_given?
-          yield io
-        else
-          io.write template
-        end
-      ensure
-        io.write '</body></html>'
       end
 
       def self.copy_assets(tmp_dir)
@@ -220,64 +216,13 @@ namespace :foreman_tasks do
         end
       end
 
-      def self.generate_with_index(io)
-        io.write '<div><table class="table">'
-        yield io
-      ensure
-        io.write '</table></div>'
-      end
-
-      def self.generate_index_entry(io, task)
-        io << <<~HTML
-          <tr>
-            <td><a href=\"#{task.id}.html\">#{task.label}</a></td>
-            <td>#{task.started_at}</td>
-            <td>#{task.state}</td>
-            <td>#{task.result}</td>
-          </tr>
-        HTML
-      end
-    end
-
-    def csv_export(export_filename, tasks)
-      CSV.open(export_filename, 'wb') do |csv|
-        csv << %w[id state type label result parent_task_id started_at ended_at]
-        tasks.find_each do |task|
-          csv << [task.id, task.state, task.type, task.label, task.result,
-                  task.parent_task_id, task.started_at, task.ended_at]
+      def self.generate_index(tasks)
+        html = '<div><table class="table">'
+        tasks.order('started_at desc').all.each do |task|
+          html << "<tr><td><a href=\"#{task.id}.html\">#{task.label}</a></td><td>#{task.started_at}</td>\
+                   <td>#{task.state}</td><td>#{task.result}</td></tr>"
         end
-      end
-    end
-
-    def html_export(workdir, tasks)
-      PageHelper.copy_assets(workdir)
-
-      renderer = TaskRender.new
-      total = tasks.count
-      index = File.open(File.join(workdir, 'index.html'), 'w')
-
-      File.open(File.join(workdir, 'index.html'), 'w') do |index|
-        PageHelper.pagify(index) do |io|
-          PageHelper.generate_with_index(io) do |index|
-            tasks.find_each.each_with_index do |task, count|
-              File.open(File.join(workdir, "#{task.id}.html"), 'w') { |file| PageHelper.pagify(file, renderer.render_task(task)) }
-              PageHelper.generate_index_entry(index, task)
-              puts "#{count + 1}/#{total}"
-            end
-          end
-        end
-      end
-    end
-
-    def generate_filename(format)
-      base = "/tmp/task-export-#{Time.now.to_i}"
-      case format
-      when 'html'
-        base + '.tar.gz'
-      when 'csv'
-        base + '.csv'
-      when 'html-dir'
-        base
+        html << '</table></div>'
       end
     end
 
@@ -294,25 +239,36 @@ namespace :foreman_tasks do
     end
 
     format = ENV['TASK_FORMAT'] || 'html'
-    export_filename = ENV['TASK_FILE'] || generate_filename(format)
+    export_filename = ENV['TASK_FILE'] || "/tmp/task-export-#{Time.now.to_i}.#{format == 'csv' ? 'csv' : 'tar.gz'}"
 
-    tasks = ForemanTasks::Task.search_for(filter).order(:started_at => :desc)
+    tasks = ForemanTasks::Task.search_for(filter)
 
     puts _("Exporting all tasks matching filter #{filter}")
     puts _("Gathering #{tasks.count} tasks.")
-    case format
-    when 'html'
+    if format == 'html'
       Dir.mktmpdir('task-export') do |tmp_dir|
-        html_export(tmp_dir, tasks)
+        PageHelper.copy_assets(tmp_dir)
+
+        renderer = TaskRender.new
+        total = tasks.count
+
+        tasks.find_each.with_index do |task, count|
+          File.open(File.join(tmp_dir, "#{task.id}.html"), 'w') { |file| file.write(PageHelper.pagify(renderer.render_task(task))) }
+          puts "#{count + 1}/#{total}"
+        end
+
+        File.open(File.join(tmp_dir, 'index.html'), 'w') { |file| file.write(PageHelper.pagify(PageHelper.generate_index(tasks))) }
+
         system("tar", "czf", export_filename, tmp_dir)
       end
-    when 'html-dir'
-      FileUtils.mkdir_p(export_filename)
-      html_export(export_filename, tasks)
-    when 'csv'
-      csv_export(export_filename, tasks)
-    else
-      raise "Unkonwn export format '#{format}'"
+    elsif format == 'csv'
+      CSV.open(export_filename, 'wb') do |csv|
+        csv << %w[id state type label result parent_task_id started_at ended_at]
+        tasks.find_each do |task|
+          csv << [task.id, task.state, task.type, task.label, task.result,
+                  task.parent_task_id, task.started_at, task.ended_at]
+        end
+      end
     end
 
     puts "Created #{export_filename}"

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = '4.1.6'.freeze
+  VERSION = '5.0.0'.freeze
 end

data/lib/foreman_tasks.rb

@@ -6,17 +6,14 @@ require 'foreman_tasks/dynflow/configuration'
 require 'foreman_tasks/triggers'
 require 'foreman_tasks/authorizer_ext'
 require 'foreman_tasks/cleaner'
+require 'foreman_tasks/continuous_output'
 
 module ForemanTasks
   extend Algebrick::TypeCheck
   extend Algebrick::Matching
 
   def self.dynflow
-    @dynflow ||= begin
-                   world = ForemanTasks::Dynflow.new(nil, ForemanTasks::Dynflow::Configuration.new)
-                   ForemanTasksCore.dynflow_setup(world) if defined?(ForemanTasksCore)
-                   world
-                 end
+    @dynflow ||= ForemanTasks::Dynflow.new(nil, ForemanTasks::Dynflow::Configuration.new)
   end
 
   def self.trigger(action, *args, &block)

data/test/controllers/api/tasks_controller_test.rb

@@ -68,17 +68,6 @@ module ForemanTasks
           data = JSON.parse(response.body)
           _(data[0]['results'][0]['id']).must_equal task.id
         end
-
-        it 'can search for a specific resource' do
-          org = FactoryBot.create(:organization)
-          task = FactoryBot.create(:task_with_links, resource_id: org.id, resource_type: 'Organization')
-
-          post :bulk_search, params: { :searches => [{ :type => 'resource', :resource_id => org.id, :resource_type => 'Organization' }] }
-
-          assert_response :success
-          data = JSON.parse(response.body)
-          _(data[0]['results'][0]['id']).must_equal task.id
-        end
       end
 
       describe 'GET /api/tasks/show' do

data/test/graphql/queries/recurring_logic_test.rb

@@ -0,0 +1,28 @@
+require 'foreman_tasks_test_helper'
+
+module Queries
+  class RecurringLogicTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query($id: String!) {
+        recurringLogic(id: $id) {
+          id
+          cronLine
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:cron_line) { '5 4 3 2 1' }
+    let(:recurring_logic) { FactoryBot.create(:recurring_logic, :cron_line => cron_line) }
+    let(:global_id) { Foreman::GlobalId.for(recurring_logic) }
+    let(:variables) { { id: global_id } }
+    let(:data) { result['data']['recurringLogic'] }
+
+    test "should fetch recurring logic" do
+      assert_empty result['errors']
+      assert_equal global_id, data['id']
+      assert_equal cron_line, data['cronLine']
+    end
+  end
+end