checkoff 0.233.0 → 0.237.0

data/rbi/checkoff.rbi

@@ -57,7 +57,7 @@ module Overcommit
 end
 
 module Checkoff
-  VERSION = '0.233.0'
+  VERSION = '0.237.0'
 
   class Attachments
     include Logging
@@ -1885,6 +1885,11 @@ module Checkoff
           def convert; end
         end
 
+        class AllTagsIds < SimpleParam
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
         class Sort < SimpleParam
           sig { returns(T.untyped) }
           def convert; end
@@ -1899,6 +1904,11 @@ module Checkoff
           sig { returns(T.untyped) }
           def convert; end
         end
+
+        class LocatedIn < SimpleParam
+          sig { returns(T.untyped) }
+          def convert; end
+        end
       end
 
       class SimpleParamConverter
@@ -1909,10 +1919,12 @@ module Checkoff
           'completion' => SimpleParam::Completion,
           'not_tags.ids' => SimpleParam::NotTagsIds,
           'any_tags.ids' => SimpleParam::AnyTagsIds,
+          'all_tags.ids' => SimpleParam::AllTagsIds,
           'subtask' => SimpleParam::Subtask,
           'sort' => SimpleParam::Sort,
           'milestone' => SimpleParam::Milestone,
           'searched_type' => SimpleParam::SearchedType,
+          'locatedIn' => SimpleParam::LocatedIn,
         }.freeze
 
         sig { params(simple_url_params: T.untyped).void }
@@ -2397,7 +2409,7 @@ end
 # typed: ignore
 # Command-line and gem client for Asana (unofficial)
 module Checkoff
-  VERSION = T.let('0.233.0', T.untyped)
+  VERSION = T.let('0.237.0', T.untyped)
 
   # Move tasks from one place to another
   class MvSubcommand
@@ -2563,12 +2575,16 @@ module Checkoff
     sig { params(project_name: String).returns(T.any(String, Symbol)) }
     def validate_and_assign_project_name(project_name); end
 
+    # @sg-ignore
+    # 
     # _@param_ `workspace`
     # 
     # _@param_ `project`
     sig { params(workspace: T.any(String, Symbol), project: T.any(String, Symbol)).returns(String) }
     def run_on_project(workspace, project); end
 
+    # @sg-ignore
+    # 
     # _@param_ `workspace`
     # 
     # _@param_ `project`
@@ -2577,6 +2593,8 @@ module Checkoff
     sig { params(workspace: T.any(String, Symbol), project: T.any(String, Symbol), section: T.nilable(T.any(String, Symbol))).returns(String) }
     def run_on_section(workspace, project, section); end
 
+    # @sg-ignore
+    # 
     # _@param_ `workspace`
     # 
     # _@param_ `project`
@@ -4164,8 +4182,6 @@ module Checkoff
     def portfolio_or_raise(workspace_name, portfolio_name); end
 
     # sord warn - Asana::Resources::Portfolio wasn't able to be resolved to a constant in this project
-    # @sg-ignore
-    # 
     # _@param_ `workspace_name`
     # 
     # _@param_ `portfolio_name`
@@ -5393,6 +5409,12 @@ module Checkoff
           def convert; end
         end
 
+        # Handle 'all_tags.ids' search url param
+        class AllTagsIds < Checkoff::Internal::SearchUrl::SimpleParam::SimpleParam
+          sig { returns(T::Array[String]) }
+          def convert; end
+        end
+
         # Handle 'sort' search url param
         class Sort < Checkoff::Internal::SearchUrl::SimpleParam::SimpleParam
           sig { returns(T::Array[String]) }
@@ -5410,6 +5432,12 @@ module Checkoff
           sig { returns(T::Array[String]) }
           def convert; end
         end
+
+        # Handle 'locatedIn' search url param
+        class LocatedIn < Checkoff::Internal::SearchUrl::SimpleParam::SimpleParam
+          sig { returns(T::Array[String]) }
+          def convert; end
+        end
       end
 
       # Convert simple parameters - ones where the param name itself
@@ -5422,10 +5450,12 @@ module Checkoff
   'completion' => SimpleParam::Completion,
   'not_tags.ids' => SimpleParam::NotTagsIds,
   'any_tags.ids' => SimpleParam::AnyTagsIds,
+  'all_tags.ids' => SimpleParam::AllTagsIds,
   'subtask' => SimpleParam::Subtask,
   'sort' => SimpleParam::Sort,
   'milestone' => SimpleParam::Milestone,
   'searched_type' => SimpleParam::SearchedType,
+  'locatedIn' => SimpleParam::LocatedIn,
 }.freeze, T.untyped)
 
         # _@param_ `simple_url_params` — the simple params
@@ -6734,3 +6764,2342 @@ module Asana
     end
   end
 end
+
+# :nocov:
+# Module which adds helpers to run tests as if it was a specific date.
+module TestDate
+  TIME_BY_PERIOD = T.let({
+  two_am: '02:00:20',
+  morning_during_breakfast: '07:30:20',
+  morning: '07:33:20',
+  eight_thirty_am: '8:30:00',
+  ten_am: '10:00:20',
+  mid_morning: '10:33:20',
+  eleven_thirty_am: '11:30:00',
+  afternoon: '14:33:20',
+  three_forty_five_pm: '15:45:20',
+  four_fifteen_pm: '16:15:20',
+  four_forty_five_pm: '16:45:20',
+  five_forty_five_pm: '17:45:20',
+  six_fifteen_pm: '18:15:00',
+  six_forty_five_pm: '18:45:00',
+  night: '19:00:20',
+  evening: '19:01:20',
+  late_evening: '21:33:20',
+  late_late_evening: '22:33:20',
+}.freeze, T.untyped)
+
+  sig { returns(T.untyped) }
+  def mock_date; end
+
+  sig { params(zone: T.untyped).returns(T.untyped) }
+  def time_by_period(zone); end
+
+  sig { params(zone: T.untyped).returns(T.untyped) }
+  def mock_now_with_zone(zone); end
+
+  sig { returns(T.untyped) }
+  def mock_now; end
+
+  sig { returns(T.untyped) }
+  attr_accessor :time_period
+
+  sig { returns(T.untyped) }
+  attr_accessor :mock_date_str
+end
+
+class TestTags < ClassTest
+  extend Forwardable
+
+  sig { returns(T.untyped) }
+  def test_tag_or_raise_raises; end
+
+  sig { returns(T.untyped) }
+  def test_tag_or_raise; end
+
+  sig { returns(T.untyped) }
+  def expect_workspace_pulled; end
+
+  sig { returns(T.untyped) }
+  def allow_tags_named; end
+
+  sig { params(tag_arr: T.untyped).returns(T.untyped) }
+  def expect_tags_pulled(tag_arr); end
+
+  sig { returns(T.untyped) }
+  def test_tag; end
+
+  sig { params(only_uncompleted: T.untyped).returns(T.untyped) }
+  def mock_tasks(only_uncompleted: true); end
+
+  sig { params(only_uncompleted: T.untyped).returns(T.untyped) }
+  def build_task_params(only_uncompleted); end
+
+  sig { returns(T.untyped) }
+  def build_response_body; end
+
+  sig { params(task_endpoint: T.untyped, task_params: T.untyped, merged_task_options: T.untyped).returns(T.untyped) }
+  def setup_client_expects(task_endpoint, task_params, merged_task_options); end
+
+  sig { params(response_body: T.untyped).returns(T.untyped) }
+  def setup_response_expects(response_body); end
+
+  sig { returns(T.untyped) }
+  def setup_collection_expects; end
+
+  sig { returns(T.untyped) }
+  def generate_task_options; end
+
+  sig { returns(T.untyped) }
+  def generate_merged_task_options; end
+
+  sig { returns(T.untyped) }
+  def generate_task_endpoint; end
+
+  sig { returns(T.untyped) }
+  def projects; end
+
+  sig { returns(T.untyped) }
+  def test_tasks; end
+
+  sig { returns(T.untyped) }
+  def test_tasks_with_completed; end
+
+  sig { returns(T.untyped) }
+  def respond_like_instance_of; end
+
+  sig { returns(T.untyped) }
+  def respond_like; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+end
+
+# Unit test Asana-related classes
+class BaseAsana < ClassTest
+  include TestDate
+
+  sig { params(extra_fields: T.untyped).returns(T.untyped) }
+  def task_options(extra_fields: []); end
+
+  sig { returns(T.untyped) }
+  def task_options_with_completed; end
+
+  sig { returns(T.untyped) }
+  def mock_date; end
+
+  sig { params(zone: T.untyped).returns(T.untyped) }
+  def time_by_period(zone); end
+
+  sig { params(zone: T.untyped).returns(T.untyped) }
+  def mock_now_with_zone(zone); end
+
+  sig { returns(T.untyped) }
+  def mock_now; end
+end
+
+# Test a class that uses initializer mocks.
+class ClassTest < Minitest::Test
+  # Implement 'class_under_test' returning the class name to be
+  # initialized with keyword mocks
+  # 
+  # obj = get_test_object do
+  #    # Go ahead and use concrete value for constructor arg
+  #    @mocks[:some_constructor_arg] = 123
+  # end
+  sig { params(clazz: T.untyped, twiddle_mocks: T.untyped).returns(T.untyped) }
+  def get_test_object(clazz = class_under_test, &twiddle_mocks); end
+
+  # default to telling get_initailizer_mocks not to validate this.
+  # things going forward using create-test.sh should default to
+  # setting this to non-nil values, which are validated and require
+  # setting a full hash of values
+  sig { returns(T.untyped) }
+  def respond_like_instance_of; end
+
+  sig { returns(T.untyped) }
+  def respond_like; end
+
+  sig { params(clazz: T.untyped).returns(T.untyped) }
+  def create_object(clazz = class_under_test); end
+end
+
+# Test the Checkoff::Tasks class
+class TestTasks < BaseAsana
+  extend Forwardable
+  TIME_BY_PERIOD = T.let({
+  two_am: '02:00:20',
+  morning_during_breakfast: '07:30:20',
+  morning: '07:33:20',
+  eight_thirty_am: '8:30:00',
+  ten_am: '10:00:20',
+  mid_morning: '10:33:20',
+  eleven_thirty_am: '11:30:00',
+  afternoon: '14:33:20',
+  three_forty_five_pm: '15:45:20',
+  four_fifteen_pm: '16:15:20',
+  four_forty_five_pm: '16:45:20',
+  five_forty_five_pm: '17:45:20',
+  six_fifteen_pm: '18:15:00',
+  six_forty_five_pm: '18:45:00',
+  night: '19:00:20',
+  evening: '19:01:20',
+  late_evening: '21:33:20',
+  late_late_evening: '22:33:20',
+}.freeze, T.untyped)
+
+  sig { returns(T.untyped) }
+  def expect_now_pulled; end
+
+  sig { params(less_than_now: T.untyped).returns(T.untyped) }
+  def expect_due_on_parsed(less_than_now:); end
+
+  sig { params(less_than_now: T.untyped).returns(T.untyped) }
+  def expect_start_on_parsed(less_than_now:); end
+
+  sig { params(less_than_now: T.untyped).returns(T.untyped) }
+  def expect_start_at_parsed(less_than_now:); end
+
+  sig { returns(T.untyped) }
+  def mock_task_ready_false_due_in_future_on_date; end
+
+  sig { returns(T.untyped) }
+  def test_task_ready_false_due_in_future_on_date; end
+
+  sig { returns(T.untyped) }
+  def mock_task_ready_true_start_in_past; end
+
+  sig { returns(T.untyped) }
+  def test_task_ready_true_start_in_past; end
+
+  sig { returns(T.untyped) }
+  def mock_task_ready_true_start_in_past_time; end
+
+  sig { returns(T.untyped) }
+  def test_task_ready_true_start_in_past_time; end
+
+  sig { params(less_than_now: T.untyped).returns(T.untyped) }
+  def expect_due_at_parsed(less_than_now:); end
+
+  sig { returns(T.untyped) }
+  def mock_task_ready_false_due_in_future_at_time; end
+
+  sig { returns(T.untyped) }
+  def test_task_ready_false_due_in_future_at_time; end
+
+  sig { params(task: T.untyped, dependency_gids: T.untyped).returns(T.untyped) }
+  def expect_dependency_gids_pulled(task, dependency_gids); end
+
+  sig { returns(T.untyped) }
+  def test_task_ready_true_no_due_anything; end
+
+  sig { returns(T.untyped) }
+  def expect_asana_tasks_client_pulled; end
+
+  sig { returns(T.untyped) }
+  def default_fields; end
+
+  sig { params(extra_fields: T.untyped).returns(T.untyped) }
+  def fields_including(extra_fields); end
+
+  sig { params(dependency_gid: T.untyped, dependency_full_task: T.untyped, completed: T.untyped).returns(T.untyped) }
+  def expect_dependency_completion_pulled(dependency_gid, dependency_full_task, completed); end
+
+  sig { returns(T.untyped) }
+  def mock_task_ready_false_dependency; end
+
+  sig { returns(T.untyped) }
+  def test_task_ready_false_dependency; end
+
+  sig { returns(T.untyped) }
+  def test_task_ready_false_dependency_cached; end
+
+  sig do
+    params(
+      start_on: T.untyped,
+      start_at: T.untyped,
+      due_on: T.untyped,
+      due_at: T.untyped
+    ).returns(T.untyped)
+  end
+  def allow_task_due(start_on: nil, start_at: nil, due_on: nil, due_at: nil); end
+
+  sig { params(task: T.untyped, start_at: T.untyped).returns(T.untyped) }
+  def allow_start_at_pulled(task, start_at); end
+
+  sig { params(task: T.untyped, start_on: T.untyped).returns(T.untyped) }
+  def allow_start_on_pulled(task, start_on); end
+
+  sig { params(task: T.untyped, due_at: T.untyped).returns(T.untyped) }
+  def allow_due_at_pulled(task, due_at); end
+
+  sig { params(task: T.untyped, due_on: T.untyped).returns(T.untyped) }
+  def allow_due_on_pulled(task, due_on); end
+
+  sig { returns(T.untyped) }
+  def test_url_of_task; end
+
+  sig { returns(T.untyped) }
+  def expect_task_created; end
+
+  sig { returns(T.untyped) }
+  def mock_add_task; end
+
+  sig { returns(T.untyped) }
+  def test_add_task; end
+
+  sig { returns(T.untyped) }
+  def expect_tasks_from_project_pulled; end
+
+  sig { returns(T.untyped) }
+  def expect_project_pulled; end
+
+  sig { params(extra_fields: T.untyped).returns(T.untyped) }
+  def expect_task_by_gid_pulled(extra_fields: []); end
+
+  sig { returns(T.untyped) }
+  def expect_tasks_from_section_pulled; end
+
+  sig { returns(T.untyped) }
+  def projects; end
+
+  sig { returns(T.untyped) }
+  def expect_task_options_pulled; end
+
+  sig { returns(T.untyped) }
+  def mock_task_with_section; end
+
+  sig { returns(T.untyped) }
+  def test_task_with_section; end
+
+  sig { returns(T.untyped) }
+  def mock_task; end
+
+  sig { returns(T.untyped) }
+  def test_task; end
+
+  sig { returns(T.untyped) }
+  def test_in_portfolio_more_than_once; end
+
+  sig { returns(T.untyped) }
+  def test_task_to_h_delegates; end
+
+  sig { returns(T.untyped) }
+  def expect_default_workspace_name_pulled; end
+
+  sig { returns(T.untyped) }
+  def mock_in_portfolio_named_false_no_projects_no_memberships; end
+
+  sig { returns(T.untyped) }
+  def test_in_portfolio_named_false_no_projects_no_memberships; end
+
+  sig { returns(T.untyped) }
+  def mock_in_portfolio_named_false_no_projects_but_memberships; end
+
+  sig { returns(T.untyped) }
+  def test_in_portfolio_named_false_no_projects_but_memberships; end
+
+  sig { returns(T.untyped) }
+  def mock_in_portfolio_named_false_projects_wrong_memberships; end
+
+  sig { returns(T.untyped) }
+  def test_in_portfolio_named_false_projects_wrong_memberships; end
+
+  sig { returns(T.untyped) }
+  def test_date_or_time_field_by_name; end
+
+  sig { returns(T.untyped) }
+  def test_h_to_task; end
+
+  sig { returns(T.untyped) }
+  def test_all_dependent_tasks_empty; end
+
+  sig { returns(T.untyped) }
+  def test_all_dependent_tasks_one; end
+
+  sig { returns(T.untyped) }
+  def test_as_cache_key; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+end
+
+# Test the Checkoff::CLI class with mv subcommand
+class TestCLIMv < Minitest::Test
+  sig { returns(T.untyped) }
+  def expect_workspaces_created; end
+
+  sig { returns(T.untyped) }
+  def expect_config_loaded; end
+
+  sig { returns(T.untyped) }
+  def expect_sections_created; end
+
+  sig { returns(T.untyped) }
+  def expect_tasks_created; end
+
+  sig { returns(T.untyped) }
+  def set_mocks; end
+
+  sig { params(_twiddle_mocks: T.untyped).returns(T.untyped) }
+  def get_test_object(&_twiddle_mocks); end
+
+  sig { returns(T.untyped) }
+  def mock_mv_original_use_case; end
+
+  sig { returns(T.untyped) }
+  def test_mv_original_use_case; end
+end
+
+class TestEvents < ClassTest
+  extend Forwardable
+
+  sig { returns(T.untyped) }
+  def mock_filter_asana_events_true; end
+
+  sig { returns(T.untyped) }
+  def test_filter_asana_events_true; end
+
+  sig { returns(T.untyped) }
+  def test_filter_asana_events_false; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+
+  sig { returns(T.untyped) }
+  def respond_like_instance_of; end
+
+  sig { returns(T.untyped) }
+  def respond_like; end
+end
+
+# No security (symbold denial of servie) issue; not building
+# OpenStruct from untrusted user data.
+# 
+# rubocop:disable Style/OpenStructUse
+class MyOpenStruct < OpenStruct
+  sig { params(sym: T.untyped).returns(T.untyped) }
+  def delete(sym); end
+
+  sig { params(hash: T.untyped).returns(T.untyped) }
+  def merge!(hash); end
+end
+
+module Mocha
+  class Mock
+    sig { params(expected: T.untyped).returns(T::Boolean) }
+    def is_a?(expected); end
+  end
+end
+
+class TestTiming < ClassTest
+  extend Forwardable
+
+  sig { returns(T.untyped) }
+  def test_in_period_this_week_date_true; end
+
+  sig { returns(T.untyped) }
+  def test_in_period_this_week_nil_true; end
+
+  sig { returns(T.untyped) }
+  def test_in_period_day_of_week_nil_false; end
+
+  sig { returns(T.untyped) }
+  def test_in_period_day_of_week_saturday_false; end
+
+  sig { returns(T.untyped) }
+  def test_in_period_indefinite_true; end
+
+  sig { returns(T.untyped) }
+  def test_in_period_bad_period; end
+
+  sig { returns(T.untyped) }
+  def test_in_period_bad_compound_period; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+
+  sig { returns(T.untyped) }
+  def respond_like_instance_of; end
+
+  sig { returns(T.untyped) }
+  def respond_like; end
+end
+
+class TestClients < ClassTest
+  extend Forwardable
+
+  sig { returns(T.untyped) }
+  def expect_client_created; end
+
+  sig { returns(T.untyped) }
+  def mock_client; end
+
+  sig { returns(T.untyped) }
+  def test_client; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+end
+
+# Test the Checkoff::CLI class with the help option
+class TestCLIHelp < Minitest::Test
+  sig { returns(T.untyped) }
+  def expect_workspaces_created; end
+
+  sig { returns(T.untyped) }
+  def expect_config_loaded; end
+
+  sig { returns(T.untyped) }
+  def expect_sections_created; end
+
+  sig { returns(T.untyped) }
+  def expect_tasks_created; end
+
+  sig { returns(T.untyped) }
+  def set_mocks; end
+
+  sig { params(twiddle_mocks: T.untyped).returns(T.untyped) }
+  def get_test_object(&twiddle_mocks); end
+
+  sig { returns(T.untyped) }
+  def test_run_with_help_arg; end
+end
+
+# Test the Checkoff::CLI class with view subcommand
+class TestCLIView < Minitest::Test
+  sig { returns(T.untyped) }
+  def expected_json_no_section_specified; end
+
+  sig { returns(T.untyped) }
+  def section_name_str; end
+
+  sig { returns(T.untyped) }
+  def project_name; end
+
+  sig { returns(T.untyped) }
+  def task_name; end
+
+  sig { returns(T.untyped) }
+  def expect_tasks_by_section_pulled; end
+
+  sig { returns(T.untyped) }
+  def expect_client_pulled; end
+
+  sig { params(due_on: T.untyped, due_at: T.untyped).returns(T.untyped) }
+  def mock_run_with_no_section_specified_normal_project(due_on:, due_at:); end
+
+  sig { params(task: T.untyped, task_name: T.untyped).returns(T.untyped) }
+  def expect_task_named(task, task_name); end
+
+  sig { params(task: T.untyped, due_on: T.untyped).returns(T.untyped) }
+  def expect_task_due_on(task, due_on); end
+
+  sig { params(task: T.untyped, due_at: T.untyped).returns(T.untyped) }
+  def expect_task_due_at(task, due_at); end
+
+  sig { returns(T.untyped) }
+  def three_tasks; end
+
+  sig do
+    params(
+      task: T.untyped,
+      task_name: T.untyped,
+      due_on: T.untyped,
+      due_at: T.untyped
+    ).returns(T.untyped)
+  end
+  def expect_task_queried(task, task_name, due_on, due_at); end
+
+  sig { params(due_on: T.untyped, due_at: T.untyped).returns(T.untyped) }
+  def expect_three_tasks_queried(due_on:, due_at:); end
+
+  sig { returns(T.untyped) }
+  def workspace_name; end
+
+  sig { returns(T.untyped) }
+  def allow_workspaces_created; end
+
+  sig { returns(T.untyped) }
+  def allow_config_loaded; end
+
+  sig { returns(T.untyped) }
+  def allow_sections_created; end
+
+  sig { returns(T.untyped) }
+  def allow_tasks_created; end
+
+  sig { returns(T.untyped) }
+  def allow_clients_created; end
+
+  sig { returns(T.untyped) }
+  def set_mocks; end
+
+  sig { params(_twiddle_mocks: T.untyped).returns(T.untyped) }
+  def get_test_object(&_twiddle_mocks); end
+
+  sig { returns(T.untyped) }
+  def test_run_with_no_section_specified_normal_project; end
+
+  sig do
+    params(
+      project_name: T.untyped,
+      section_name: T.untyped,
+      due_on: T.untyped,
+      due_at: T.untyped
+    ).returns(T.untyped)
+  end
+  def expect_three_tasks_pulled_and_queried(project_name:, section_name:, due_on:, due_at:); end
+
+  sig do
+    params(
+      project_name: T.untyped,
+      section_name: T.untyped,
+      due_at: T.untyped,
+      due_on: T.untyped
+    ).returns(T.untyped)
+  end
+  def mock_view(project_name:, section_name:, due_at:, due_on:); end
+
+  sig { params(section_name: T.untyped).returns(T.untyped) }
+  def mock_view_specific_task(section_name:); end
+
+  sig { returns(T.untyped) }
+  def test_view_specific_task_nil_section; end
+
+  sig { returns(T.untyped) }
+  def test_view_specific_task; end
+
+  sig { returns(T.untyped) }
+  def expected_json_section_specified; end
+
+  sig { returns(T.untyped) }
+  def mock_view_run_with_section_specified_empty_section; end
+
+  sig { returns(T.untyped) }
+  def test_view_run_with_section_specified_empty_section; end
+
+  sig { returns(T.untyped) }
+  def mock_view_run_with_section_specified_normal_project_colon_project; end
+
+  sig { returns(T.untyped) }
+  def test_view_run_with_section_specified_normal_project_colon_project; end
+
+  sig { returns(T.untyped) }
+  def mock_view_run_with_section_specified_normal_project; end
+
+  sig { returns(T.untyped) }
+  def test_view_run_with_section_specified_normal_project; end
+
+  sig { returns(T.untyped) }
+  def mock_run_with_no_project_specified; end
+
+  sig { returns(T.untyped) }
+  def test_run_with_no_project_specified; end
+
+  sig { returns(T.untyped) }
+  def expected_json_view_not_due; end
+
+  sig { returns(T.untyped) }
+  def test_view_not_due; end
+
+  sig { returns(T.untyped) }
+  def expected_json_view_due_at; end
+
+  sig { returns(T.untyped) }
+  def test_view_due_at; end
+end
+
+# Test the Checkoff::Projects class
+class TestProjects < BaseAsana
+  extend Forwardable
+  TIME_BY_PERIOD = T.let({
+  two_am: '02:00:20',
+  morning_during_breakfast: '07:30:20',
+  morning: '07:33:20',
+  eight_thirty_am: '8:30:00',
+  ten_am: '10:00:20',
+  mid_morning: '10:33:20',
+  eleven_thirty_am: '11:30:00',
+  afternoon: '14:33:20',
+  three_forty_five_pm: '15:45:20',
+  four_fifteen_pm: '16:15:20',
+  four_forty_five_pm: '16:45:20',
+  five_forty_five_pm: '17:45:20',
+  six_fifteen_pm: '18:15:00',
+  six_forty_five_pm: '18:45:00',
+  night: '19:00:20',
+  evening: '19:01:20',
+  late_evening: '21:33:20',
+  late_late_evening: '22:33:20',
+}.freeze, T.untyped)
+
+  sig { returns(T.untyped) }
+  def setup_config; end
+
+  sig { returns(T.untyped) }
+  def setup_projects_pulled; end
+
+  sig { returns(T.untyped) }
+  def sample_projects; end
+
+  sig { params(workspace_gid: T.untyped).returns(T.untyped) }
+  def setup_projects_queried(workspace_gid: my_workspace_gid); end
+
+  sig { params(options: T.untyped).returns(T.untyped) }
+  def expect_tasks_found(options:); end
+
+  sig { params(options: T.untyped).returns(T.untyped) }
+  def mock_tasks_from_project(options:); end
+
+  sig { returns(T.untyped) }
+  def test_tasks_from_project_not_only_uncompleted; end
+
+  sig { returns(T.untyped) }
+  def test_tasks_from_project; end
+
+  sig { returns(T.untyped) }
+  def test_active_tasks; end
+
+  sig { returns(T.untyped) }
+  def setup_workspace_pulled; end
+
+  sig { returns(T.untyped) }
+  def setup_user_task_list_pulled; end
+
+  sig { returns(T.untyped) }
+  def mock_project_or_raise_unknown; end
+
+  sig { returns(T.untyped) }
+  def test_project_or_raise_unknown; end
+
+  sig { returns(T.untyped) }
+  def test_project_by_gid; end
+
+  sig { returns(T.untyped) }
+  def test_project_or_raise_my_tasks; end
+
+  sig { returns(T.untyped) }
+  def mock_project_my_tasks; end
+
+  sig { returns(T.untyped) }
+  def test_project_my_tasks; end
+
+  sig { returns(T.untyped) }
+  def test_project_to_h; end
+
+  sig { returns(T.untyped) }
+  def mock_test_in_period; end
+
+  sig { returns(T.untyped) }
+  def test_in_period; end
+
+  sig { returns(T.untyped) }
+  def mock_project_ready; end
+
+  sig { returns(T.untyped) }
+  def test_project_ready; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+end
+
+# Test the Checkoff::Sections class
+class TestSections < BaseAsana
+  extend Forwardable
+  TIME_BY_PERIOD = T.let({
+  two_am: '02:00:20',
+  morning_during_breakfast: '07:30:20',
+  morning: '07:33:20',
+  eight_thirty_am: '8:30:00',
+  ten_am: '10:00:20',
+  mid_morning: '10:33:20',
+  eleven_thirty_am: '11:30:00',
+  afternoon: '14:33:20',
+  three_forty_five_pm: '15:45:20',
+  four_fifteen_pm: '16:15:20',
+  four_forty_five_pm: '16:45:20',
+  five_forty_five_pm: '17:45:20',
+  six_fifteen_pm: '18:15:00',
+  six_forty_five_pm: '18:45:00',
+  night: '19:00:20',
+  evening: '19:01:20',
+  late_evening: '21:33:20',
+  late_late_evening: '22:33:20',
+}.freeze, T.untyped)
+
+  sig { returns(T.untyped) }
+  def test_section_task_names_no_tasks; end
+
+  sig { returns(T.untyped) }
+  def projects; end
+
+  sig { returns(T.untyped) }
+  def test_section_task_names; end
+
+  sig { returns(T.untyped) }
+  def mock_sections_or_raise; end
+
+  sig { returns(T.untyped) }
+  def test_sections_or_raise; end
+
+  sig { returns(T.untyped) }
+  def test_sections_or_raise_nil_project_name; end
+
+  sig { params(project: T.untyped, tasks_arr: T.untyped, active_tasks_arr: T.untyped).returns(T.untyped) }
+  def expect_my_tasks_pulled(project, tasks_arr, active_tasks_arr); end
+
+  sig { params(section: T.untyped, name: T.untyped).returns(T.untyped) }
+  def expect_section_named(section, name); end
+
+  sig { params(task: T.untyped, section: T.untyped).returns(T.untyped) }
+  def expect_assignee_section_pulled(task, section); end
+
+  sig { returns(T.untyped) }
+  def expect_my_tasks_sections_pulled; end
+
+  sig { returns(T.untyped) }
+  def expect_my_tasks_tasks_pulled; end
+
+  sig { returns(T.untyped) }
+  def mock_tasks_by_section_my_tasks; end
+
+  sig { returns(T.untyped) }
+  def test_tasks_by_section_my_tasks; end
+
+  sig { returns(T.untyped) }
+  def test_tasks_by_section_nil_workspace_name; end
+
+  sig { returns(T.untyped) }
+  def test_tasks_by_section_nil_project_name; end
+
+  sig { returns(T.untyped) }
+  def test_tasks_by_section_some_in_empty_section; end
+
+  sig { returns(T.untyped) }
+  def expect_project_a_tasks_pulled; end
+
+  sig { returns(T.untyped) }
+  def test_tasks_by_section; end
+
+  sig { params(task: T.untyped, name: T.untyped).returns(T.untyped) }
+  def expect_named(task, name); end
+
+  sig { params(project: T.untyped, tasks_arr: T.untyped, active_tasks_arr: T.untyped).returns(T.untyped) }
+  def expect_tasks_pulled(project, tasks_arr, active_tasks_arr); end
+
+  sig { params(workspace: T.untyped, project: T.untyped, project_name: T.untyped).returns(T.untyped) }
+  def expect_project_pulled(workspace, project, project_name); end
+
+  sig { returns(T.untyped) }
+  def expect_task_project_memberships_queried; end
+
+  sig { params(section_name: T.untyped).returns(T.untyped) }
+  def expect_task_section_memberships_queried(section_name); end
+
+  sig { params(section_name: T.untyped).returns(T.untyped) }
+  def expect_task_memberships_queried(section_name); end
+
+  sig do
+    params(
+      workspace: T.untyped,
+      project: T.untyped,
+      project_name: T.untyped,
+      section_name: T.untyped
+    ).returns(T.untyped)
+  end
+  def expect_tasks_and_sections_pulled(workspace, project, project_name, section_name); end
+
+  sig { params(project: T.untyped, gid: T.untyped).returns(T.untyped) }
+  def expect_project_gid_pulled(project, gid); end
+
+  sig { returns(T.untyped) }
+  def expect_sections_client_pulled; end
+
+  sig { params(project_gid: T.untyped, sections_array: T.untyped).returns(T.untyped) }
+  def expect_project_sections_pulled(project_gid, sections_array); end
+
+  sig { returns(T.untyped) }
+  def original_task_options; end
+
+  sig { params(only_uncompleted: T.untyped).returns(T.untyped) }
+  def fixed_task_options(only_uncompleted:); end
+
+  sig { params(section_gid: T.untyped, task_list: T.untyped, only_uncompleted: T.untyped).returns(T.untyped) }
+  def expect_tasks_api_called_for_section(section_gid, task_list, only_uncompleted:); end
+
+  sig { returns(T.untyped) }
+  def expect_section_1_gid_pulled; end
+
+  sig { returns(T.untyped) }
+  def expect_section_2_gid_pulled; end
+
+  sig { returns(T.untyped) }
+  def expect_client_tasks_api_pulled; end
+
+  sig do
+    params(
+      section: T.untyped,
+      section_gid: T.untyped,
+      task_list: T.untyped,
+      only_uncompleted: T.untyped
+    ).returns(T.untyped)
+  end
+  def expect_section_tasks_pulled(section, section_gid, task_list, only_uncompleted:); end
+
+  sig { returns(T.untyped) }
+  def test_tasks_not_only_uncompleted; end
+
+  sig { returns(T.untyped) }
+  def allow_section_1_name_pulled; end
+
+  sig { returns(T.untyped) }
+  def allow_section_2_name_pulled; end
+
+  sig { returns(T.untyped) }
+  def allow_empty_section_name_pulled; end
+
+  sig { params(only_uncompleted: T.untyped).returns(T.untyped) }
+  def mock_tasks_normal_project(only_uncompleted:); end
+
+  sig { returns(T.untyped) }
+  def test_tasks_normal_project; end
+
+  sig { returns(T.untyped) }
+  def test_tasks_by_section_gid; end
+
+  sig { returns(T.untyped) }
+  def test_tasks_by_section_also_completed; end
+
+  sig { returns(T.untyped) }
+  def mock_tasks_inbox; end
+
+  sig { returns(T.untyped) }
+  def test_tasks_inbox; end
+
+  sig { returns(T.untyped) }
+  def test_tasks_section_not_found; end
+
+  sig { returns(T.untyped) }
+  def test_tasks_project_not_found; end
+
+  sig { returns(T.untyped) }
+  def test_previous_section; end
+
+  sig { returns(T.untyped) }
+  def test_previous_section_on_inbox_returns_nil; end
+
+  sig { returns(T.untyped) }
+  def test_section_by_gid; end
+
+  sig { returns(T.untyped) }
+  def test_section_by_gid_bad_server_data; end
+
+  sig { returns(T.untyped) }
+  def respond_like_instance_of; end
+
+  sig { returns(T.untyped) }
+  def respond_like; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+end
+
+class TestSubtasks < ClassTest
+  extend Forwardable
+
+  sig { returns(T.untyped) }
+  def task_options; end
+
+  sig { returns(T.untyped) }
+  def subtask_options; end
+
+  # refute(subtasks.all_subtasks_completed?(task))
+  # end
+  sig { params(active_subtasks: T.untyped).returns(T.untyped) }
+  def expect_active_subtasks_pulled(active_subtasks); end
+
+  sig { returns(T.untyped) }
+  def allow_all_section_status_queried; end
+
+  # assert(subtasks.all_subtasks_completed?(task))
+  # end
+  sig { params(subtask: T.untyped, result: T.untyped).returns(T.untyped) }
+  def allow_subtask_section_status_queried(subtask, result); end
+
+  # assert_equal(subtasks.subtask_section?(subtask), is_rendered_as_separator)
+  # end
+  sig { returns(T.untyped) }
+  def allow_subtask_section_1_named; end
+
+  sig { returns(T.untyped) }
+  def allow_subtask_section_2_named; end
+
+  sig { returns(T.untyped) }
+  def allow_subtask_section_3_named; end
+
+  sig { returns(T.untyped) }
+  def allow_subtask_names_queried; end
+
+  sig { returns(T.untyped) }
+  def mock_by_section; end
+
+  # assert_equal('More than one section named 1:', e.message)
+  # end
+  sig { returns(T.untyped) }
+  def expect_raw_subtasks_pulled; end
+
+  # refute_nil subtasks
+  # end
+  sig { returns(T.untyped) }
+  def class_under_test; end
+
+  sig { returns(T.untyped) }
+  def respond_like_instance_of; end
+
+  sig { returns(T.untyped) }
+  def respond_like; end
+end
+
+class TestTimelines < ClassTest
+  extend Forwardable
+
+  sig { returns(T.untyped) }
+  def test_task_dependent_on_previous_section_last_milestone_no_memberships; end
+
+  sig { returns(T.untyped) }
+  def mock_task_dependent_on_previous_section_last_milestone_false_no_dependencies; end
+
+  sig { returns(T.untyped) }
+  def test_task_dependent_on_previous_section_last_milestone_false_no_dependencies_; end
+
+  sig { params(task: T.untyped, task_data: T.untyped).returns(T.untyped) }
+  def expect_task_data_created(task, task_data); end
+
+  sig { returns(T.untyped) }
+  def expect_section_2_pulled; end
+
+  sig { returns(T.untyped) }
+  def expect_section_2_previous_section_called; end
+
+  sig { returns(T.untyped) }
+  def expect_section_1_gid_pulled; end
+
+  sig { returns(T.untyped) }
+  def expect_no_section_1_tasks; end
+
+  sig { returns(T.untyped) }
+  def mock_task_dependent_on_previous_section_last_milestone_true_no_tasks; end
+
+  sig { returns(T.untyped) }
+  def test_task_dependent_on_previous_section_last_milestone_true_no_tasks; end
+
+  sig { returns(T.untyped) }
+  def expect_section_1_tasks_pulled; end
+
+  sig { returns(T.untyped) }
+  def expect_milestone_queried; end
+
+  sig { returns(T.untyped) }
+  def mock_task_dependent_on_previous_section_last_milestone_true; end
+
+  sig { returns(T.untyped) }
+  def test_task_dependent_on_previous_section_last_milestone_true; end
+
+  sig { returns(T.untyped) }
+  def mock_task_dependent_on_previous_section_last_milestone_false_no_previous_section; end
+
+  sig { returns(T.untyped) }
+  def test_task_dependent_on_previous_section_last_milestone_false_no_previous_section; end
+
+  sig { returns(T.untyped) }
+  def test_last_task_milestone_depends_on_this_task_no_memberships; end
+
+  sig { params(task: T.untyped, dependents: T.untyped).returns(T.untyped) }
+  def expect_all_dependent_tasks_pulled(task, dependents); end
+
+  sig { params(task: T.untyped, memberships: T.untyped).returns(T.untyped) }
+  def expect_memberships_pulled(task, memberships); end
+
+  sig { params(tasks: T.untyped).returns(T.untyped) }
+  def expect_tasks_by_section_gid_pulled(tasks); end
+
+  sig { returns(T.untyped) }
+  def expect_milestone_details_pulled; end
+
+  sig { returns(T.untyped) }
+  def expect_task_gid_pulled; end
+
+  sig { returns(T.untyped) }
+  def test_last_task_milestone_depends_on_this_task_false; end
+
+  sig { returns(T.untyped) }
+  def test_last_task_milestone_depends_on_this_task_no_milestone; end
+
+  sig { returns(T.untyped) }
+  def test_last_task_milestone_depends_on_this_task_is_last_milestone; end
+
+  sig { params(projects: T.untyped).returns(T.untyped) }
+  def export_portfolio_projects_pulled(projects); end
+
+  sig { returns(T.untyped) }
+  def test_last_task_milestone_depends_on_this_task_is_last_milestone_limited_to_portfolio_no_projects; end
+
+  sig { returns(T.untyped) }
+  def mock_last_task_milestone_depends_on_this_task_is_last_milestone_limited_to_portfolio; end
+
+  sig { returns(T.untyped) }
+  def test_last_task_milestone_depends_on_this_task_is_last_milestone_limited_to_portfolio; end
+
+  sig { returns(T.untyped) }
+  def test_init; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+
+  sig { returns(T.untyped) }
+  def respond_like_instance_of; end
+
+  sig { returns(T.untyped) }
+  def respond_like; end
+end
+
+class TestPortfolios < ClassTest
+  extend Forwardable
+
+  sig { returns(T.untyped) }
+  def test_portfolio_or_raise_raises; end
+
+  sig { returns(T.untyped) }
+  def test_portfolio_or_raise; end
+
+  sig { returns(T.untyped) }
+  def expect_workspace_pulled; end
+
+  sig { returns(T.untyped) }
+  def allow_portfolios_named; end
+
+  sig { returns(T.untyped) }
+  def expect_portfolios_api_pulled; end
+
+  sig { returns(T.untyped) }
+  def expect_me_gid_pulled; end
+
+  sig { params(portfolio_arr: T.untyped).returns(T.untyped) }
+  def expect_portfolios_pulled(portfolio_arr); end
+
+  sig { returns(T.untyped) }
+  def test_portfolio; end
+
+  sig { returns(T.untyped) }
+  def test_portfolio_by_gid; end
+
+  sig { returns(T.untyped) }
+  def test_projects_in_portfolios; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+
+  sig { returns(T.untyped) }
+  def respond_like_instance_of; end
+
+  sig { returns(T.untyped) }
+  def respond_like; end
+end
+
+# Test the Checkoff::Workspaces class
+class TestWorkspaces < BaseAsana
+  extend Forwardable
+  TIME_BY_PERIOD = T.let({
+  two_am: '02:00:20',
+  morning_during_breakfast: '07:30:20',
+  morning: '07:33:20',
+  eight_thirty_am: '8:30:00',
+  ten_am: '10:00:20',
+  mid_morning: '10:33:20',
+  eleven_thirty_am: '11:30:00',
+  afternoon: '14:33:20',
+  three_forty_five_pm: '15:45:20',
+  four_fifteen_pm: '16:15:20',
+  four_forty_five_pm: '16:45:20',
+  five_forty_five_pm: '17:45:20',
+  six_fifteen_pm: '18:15:00',
+  six_forty_five_pm: '18:45:00',
+  night: '19:00:20',
+  evening: '19:01:20',
+  late_evening: '21:33:20',
+  late_late_evening: '22:33:20',
+}.freeze, T.untyped)
+
+  sig { returns(T.untyped) }
+  def mock_workspace_or_raise_nil; end
+
+  sig { returns(T.untyped) }
+  def test_workspace_or_raise_nil; end
+
+  sig { returns(T.untyped) }
+  def mock_workspace_or_raise; end
+
+  sig { returns(T.untyped) }
+  def test_workspace_or_raise; end
+
+  sig { returns(T.untyped) }
+  def expect_default_workspace_gid_config_fetched; end
+
+  sig { returns(T.untyped) }
+  def test_default_workspace_gid; end
+
+  sig { returns(T.untyped) }
+  def test_default_workspace; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+end
+
+class TestAttachments < ClassTest
+  extend Forwardable
+
+  sig { params(url: T.untyped).returns(T.untyped) }
+  def mock_create_attachment_from_url(url); end
+
+  sig { returns(T.untyped) }
+  def test_create_attachment_from_url; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+
+  sig { returns(T.untyped) }
+  def respond_like_instance_of; end
+
+  sig { returns(T.untyped) }
+  def respond_like; end
+end
+
+# double to inject cache_method, pretending to be cache_method gem
+class Class
+  sig { params(method_id: T.untyped, _ttl: T.untyped).returns(T.untyped) }
+  def cache_method(method_id, _ttl = nil); end
+end
+
+# double to inject cache_method_clear, pretending to be cache_method gem
+module Kernel
+  sig { params(_method_id: T.untyped).returns(T.untyped) }
+  def cache_method_clear(_method_id); end
+end
+
+# Test the Checkoff::CLI class with quickadd subcommand
+class TestCLIQuickadd < Minitest::Test
+  sig { returns(T.untyped) }
+  def workspace_name; end
+
+  sig { returns(T.untyped) }
+  def expect_workspaces_created; end
+
+  sig { returns(T.untyped) }
+  def expect_config_loaded; end
+
+  sig { returns(T.untyped) }
+  def expect_sections_created; end
+
+  sig { returns(T.untyped) }
+  def expect_tasks_created; end
+
+  sig { returns(T.untyped) }
+  def set_mocks; end
+
+  sig { params(_twiddle_mocks: T.untyped).returns(T.untyped) }
+  def get_test_object(&_twiddle_mocks); end
+
+  sig { returns(T.untyped) }
+  def mock_quickadd; end
+
+  sig { returns(T.untyped) }
+  def test_quickadd; end
+end
+
+class TestCustomFields < ClassTest
+  extend Forwardable
+
+  sig { returns(T.untyped) }
+  def test_custom_field_or_raise_raises; end
+
+  sig { returns(T.untyped) }
+  def test_custom_field_or_raise; end
+
+  sig { returns(T.untyped) }
+  def expect_workspace_pulled; end
+
+  sig { returns(T.untyped) }
+  def allow_custom_fields_named; end
+
+  sig { params(custom_field_arr: T.untyped).returns(T.untyped) }
+  def expect_custom_fields_pulled(custom_field_arr); end
+
+  sig { returns(T.untyped) }
+  def test_custom_field; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+end
+
+# Test the Checkoff::MvSubcommand class used in CLI processing
+class TestMvSubcommand < ClassTest
+  extend Forwardable
+
+  sig { params(arg: T.untyped).returns(T.untyped) }
+  def argument_to_name(arg); end
+
+  sig { params(workspace_name: T.untyped, project_name: T.untyped, project: T.untyped).returns(T.untyped) }
+  def expect_project_pulled(workspace_name, project_name, project); end
+
+  sig do
+    params(
+      workspace_name: T.untyped,
+      project_name: T.untyped,
+      section_name: T.untyped,
+      section: T.untyped
+    ).returns(T.untyped)
+  end
+  def expect_section_pulled(workspace_name, project_name, section_name, section); end
+
+  sig do
+    params(
+      workspace_name: T.untyped,
+      project_name: T.untyped,
+      section_name: T.untyped,
+      tasks: T.untyped
+    ).returns(T.untyped)
+  end
+  def expect_tasks_pulled(workspace_name, project_name, section_name, tasks); end
+
+  sig { params(task: T.untyped, task_name: T.untyped).returns(T.untyped) }
+  def expect_task_named(task, task_name); end
+
+  sig { params(section: T.untyped, section_name: T.untyped).returns(T.untyped) }
+  def expect_section_named(section, section_name); end
+
+  sig { params(project: T.untyped, project_gid: T.untyped).returns(T.untyped) }
+  def expect_project_gid_pulled(project, project_gid); end
+
+  sig { params(section: T.untyped, section_gid: T.untyped).returns(T.untyped) }
+  def expect_section_gid_pulled(section, section_gid); end
+
+  sig { params(task: T.untyped, project_gid: T.untyped, section_gid: T.untyped).returns(T.untyped) }
+  def expect_task_added_to_project(task, project_gid, section_gid); end
+
+  sig { returns(T.untyped) }
+  def allow_logger_used; end
+
+  sig { returns(T.untyped) }
+  def set_initializer_arguments; end
+
+  sig { params(from_workspace_arg: T.untyped, to_workspace_arg: T.untyped).returns(T.untyped) }
+  def determine_to_workspace_name(from_workspace_arg, to_workspace_arg); end
+
+  sig { params(from_project_name: T.untyped, to_project_arg: T.untyped).returns(T.untyped) }
+  def determine_to_project_name(from_project_name, to_project_arg); end
+
+  sig { params(from_section_name: T.untyped, to_section_arg: T.untyped).returns(T.untyped) }
+  def determine_to_section_name(from_section_name, to_section_arg); end
+
+  sig { params(task: T.untyped, task_name: T.untyped).returns(T.untyped) }
+  def expect_task_added_to_section(task, task_name); end
+
+  sig { returns(T.untyped) }
+  def set_names; end
+
+  sig { returns(T.untyped) }
+  def expect_to_objects_pulled; end
+
+  sig { returns(T.untyped) }
+  def expect_run; end
+
+  sig { returns(T.untyped) }
+  def mock_run_to_different_workspace; end
+
+  sig { returns(T.untyped) }
+  def test_run_to_different_workspace; end
+
+  sig { returns(T.untyped) }
+  def mock_run_from_all_sections; end
+
+  sig { returns(T.untyped) }
+  def test_run_from_all_sections; end
+
+  sig { returns(T.untyped) }
+  def mock_run_from_regular_project; end
+
+  sig { returns(T.untyped) }
+  def test_run_from_regular_project; end
+
+  sig { returns(T.untyped) }
+  def mock_run_to_same_section_different_project; end
+
+  sig { returns(T.untyped) }
+  def test_run_to_same_section_different_project; end
+
+  sig { returns(T.untyped) }
+  def mock_run_with_explicit_to_project; end
+
+  sig { returns(T.untyped) }
+  def test_run_with_explicit_to_project; end
+
+  sig { returns(T.untyped) }
+  def mock_run_from_my_tasks; end
+
+  sig { returns(T.untyped) }
+  def test_run_from_my_tasks; end
+
+  sig { returns(T.untyped) }
+  def mock_init_default_workspace_not_implemented; end
+
+  sig { returns(T.untyped) }
+  def test_init_default_workspace_not_implemented; end
+
+  sig { returns(T.untyped) }
+  def test_init; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+
+  # Returns the value of attribute from_workspace_arg.
+  sig { returns(T.untyped) }
+  attr_reader :from_workspace_arg
+
+  # Returns the value of attribute from_project_arg.
+  sig { returns(T.untyped) }
+  attr_reader :from_project_arg
+
+  # Returns the value of attribute from_section_arg.
+  sig { returns(T.untyped) }
+  attr_reader :from_section_arg
+
+  # Returns the value of attribute to_workspace_arg.
+  sig { returns(T.untyped) }
+  attr_reader :to_workspace_arg
+
+  # Returns the value of attribute to_project_arg.
+  sig { returns(T.untyped) }
+  attr_reader :to_project_arg
+
+  # Returns the value of attribute to_section_arg.
+  sig { returns(T.untyped) }
+  attr_reader :to_section_arg
+
+  # Returns the value of attribute from_workspace_name.
+  sig { returns(T.untyped) }
+  attr_reader :from_workspace_name
+
+  # Returns the value of attribute from_project_name.
+  sig { returns(T.untyped) }
+  attr_reader :from_project_name
+
+  # Returns the value of attribute from_section_name.
+  sig { returns(T.untyped) }
+  attr_reader :from_section_name
+
+  # Returns the value of attribute to_workspace_name.
+  sig { returns(T.untyped) }
+  attr_reader :to_workspace_name
+
+  # Returns the value of attribute to_project_name.
+  sig { returns(T.untyped) }
+  attr_reader :to_project_name
+
+  # Returns the value of attribute to_section_name.
+  sig { returns(T.untyped) }
+  attr_reader :to_section_name
+end
+
+class TestTaskSearches < ClassTest
+  extend Forwardable
+
+  sig { returns(T.untyped) }
+  def expect_workspace_pulled; end
+
+  sig { returns(T.untyped) }
+  def expect_workspace_gid_pulled; end
+
+  sig { returns(T.untyped) }
+  def expect_convert_params_called; end
+
+  sig { returns(T.untyped) }
+  def default_fields; end
+
+  sig { returns(T.untyped) }
+  def expect_client_get_called; end
+
+  sig { returns(T.untyped) }
+  def expect_search_response_queried; end
+
+  sig { params(response_array: T.untyped).returns(T.untyped) }
+  def expect_response_wrapped(response_array); end
+
+  sig { returns(T.untyped) }
+  def expect_tasks_filtered; end
+
+  sig { returns(T.untyped) }
+  def expect_task_selector_queried; end
+
+  sig { returns(T.untyped) }
+  def mock_task_search; end
+
+  sig { returns(T.untyped) }
+  def projects; end
+
+  sig { returns(T.untyped) }
+  def test_task_search; end
+
+  sig { returns(T.untyped) }
+  def mock_task_search_overloaded; end
+
+  sig { returns(T.untyped) }
+  def test_as_cache_key; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+
+  sig { returns(T.untyped) }
+  def respond_like_instance_of; end
+
+  sig { returns(T.untyped) }
+  def respond_like; end
+end
+
+# rubocop:disable Metrics/ClassLength
+class TestTaskSelectors < ClassTest
+  extend Forwardable
+
+  sig { returns(Checkoff::TaskSelectors) }
+  def get_test_object; end
+
+  sig { returns(Mocha::Mock) }
+  def task; end
+
+  sig { void }
+  def test_filter_via_custom_field_gid_values_gids_no_enum_value; end
+
+  sig { void }
+  def test_filter_via_custom_field_gid_values_gids_no_enum_value_multi_enum; end
+
+  sig { void }
+  def test_filter_via_custom_field_gid_values_gids_no_enum_value_new_type; end
+
+  # not sure why this would be the case, so set an alarm so I can understand
+  sig { void }
+  def test_filter_via_custom_field_custom_field_not_enabled; end
+
+  sig { void }
+  def test_filter_via_custom_field_none_matched; end
+
+  sig { void }
+  def test_filter_via_custom_field_gid_values_gids_custom_field_not_provided; end
+
+  sig { void }
+  def test_filter_via_custom_field_gid_values_gids; end
+
+  sig { void }
+  def test_filter_via_invalid_syntax; end
+
+  sig { void }
+  def test_filter_via_custom_field_value_nil_false_found; end
+
+  sig { void }
+  def mock_filter_via_custom_field_gid_value_gid_nil; end
+
+  sig { void }
+  def test_filter_via_custom_field_gid_value_gid_nil; end
+
+  sig { void }
+  def test_filter_via_custom_field_value_custom_fields_not_provided; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_custom_field_value_nil_none_found; end
+
+  sig { void }
+  def test_filter_via_custom_field_value_gid_nil_none_found; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_task_selector_tag; end
+
+  sig { void }
+  def test_filter_via_task_selector_not; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_task_selector_and; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_task_selector_or; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_task_selector_simple; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_task_selector_ready; end
+
+  sig { returns(T.untyped) }
+  def expect_now_jan_1_2019; end
+
+  sig { returns(T.untyped) }
+  def expect_starts_jan_1_2019_midnight; end
+
+  sig { returns(T.untyped) }
+  def expect_no_incomplete_dependencies; end
+
+  sig { returns(T.untyped) }
+  def mock_filter_via_task_selector_ready_between_relative_starts_no; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_task_selector_ready_between_relative_starts_now; end
+
+  sig { returns(T.untyped) }
+  def mock_filter_via_task_selector_ready_between_relative_starts_today; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_task_selector_ready_between_relative_starts_today; end
+
+  sig { returns(T.untyped) }
+  def mock_filter_via_task_selector_ready_between_relative_due_now; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_task_selector_ready_between_relative_due_now; end
+
+  sig { returns(T.untyped) }
+  def mock_due_on_jan_1_2019; end
+
+  sig { returns(T.untyped) }
+  def expect_no_start; end
+
+  sig { returns(T.untyped) }
+  def mock_filter_via_task_selector_ready_between_relative_due_today; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_task_selector_ready_between_relative_due_today; end
+
+  sig { returns(T.untyped) }
+  def expect_no_due; end
+
+  sig { returns(T.untyped) }
+  def mock_filter_via_task_selector_ready_between_relative_no_due; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_task_selector_ready_between_relative_no_due; end
+
+  sig { returns(T.untyped) }
+  def expect_due_jan_1_2099; end
+
+  sig { returns(T.untyped) }
+  def mock_filter_via_task_selector_ready_between_relative_due_far_future; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_task_selector_ready_between_relative_due_far_future; end
+
+  sig { returns(T.untyped) }
+  def expect_incomplete_dependencies; end
+
+  sig { returns(T.untyped) }
+  def expect_tasks_not_mocked; end
+
+  sig { void }
+  def test_filter_via_task_selector_unassigned; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_custom_field_gid_value_contains_all_gids; end
+
+  sig { void }
+  def test_filter_via_task_selector_due_date_set; end
+
+  sig { void }
+  def test_filter_via_task_selector_custom_field_less_than_n_days_from_now; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_task_selector_custom_field_less_than_n_days_from_now_not_set; end
+
+  sig { void }
+  def test_filter_via_task_selector_custom_field_less_than_n_days_from_now_custom_field_not_found; end
+
+  sig { void }
+  def test_filter_via_task_selector_custom_field_greater_than_or_equal_to_n_days_from_now; end
+
+  sig { void }
+  def test_filter_via_task_selector_custom_field_greater_than_or_equal_to_n_days_from_now_nil; end
+
+  sig { void }
+  def test_filter_via_task_selector_custom_field_greater_than_or_equal_to_n_days_from_now_custom_field_not_found; end
+
+  sig { returns(T.untyped) }
+  def mock_filter_via_task_selector_modified_less_than_n_days_ago; end
+
+  sig { void }
+  def test_filter_via_task_selector_modified_less_than_n_days_ago; end
+
+  sig { void }
+  def test_estimate_exceeds_duration_true; end
+
+  sig { void }
+  def test_estimate_exceeds_duration_false_no_estimate_set; end
+
+  sig { void }
+  def test_estimate_exceeds_duration_true_only_due_set; end
+
+  sig { void }
+  def test_estimate_exceeds_duration_true_no_dates_set; end
+
+  sig { void }
+  def test_estimate_exceeds_duration_no_estimate_field; end
+
+  sig { void }
+  def test_filter_via_task_selector_modified_less_than_n_days_ago_nil; end
+
+  sig { void }
+  def test_filter_via_task_selector_modified_less_than_n_days_ago_field_not_supported; end
+
+  sig { void }
+  def test_filter_via_task_selector_modified_less_than_n_days_ago_compound_field_not_supported; end
+
+  sig { void }
+  def mock_filter_via_task_selector_field_greater_than_or_equal_to_n_days_from_today_due_on; end
+
+  sig { void }
+  def test_filter_via_task_selector_field_greater_than_or_equal_to_n_days_from_today_due_on; end
+
+  sig { returns(T.untyped) }
+  def mock_filter_via_task_selector_field_greater_than_or_equal_to_n_days_from_today_due_at; end
+
+  sig { void }
+  def test_filter_via_task_selector_field_greater_than_or_equal_to_n_days_from_today_due_at; end
+
+  sig { void }
+  def mock_filter_via_task_selector_field_greater_than_or_equal_to_n_days_from_today_due_nil; end
+
+  sig { void }
+  def test_filter_via_task_selector_field_greater_than_or_equal_to_n_days_from_today_due_nil; end
+
+  sig { void }
+  def test_filter_via_task_selector_custom_field_equal_to_date; end
+
+  sig { void }
+  def test_filter_via_task_selector_custom_field_not_equal_to_date; end
+
+  sig { void }
+  def test_filter_via_task_selector_last_story_created_less_than_n_days_ago_no_stories; end
+
+  sig { void }
+  def mock_filter_via_task_selector_last_story_created_less_than_n_days_ago_ancient; end
+
+  sig { void }
+  def test_filter_via_task_selector_last_story_created_less_than_n_days_ago_ancient; end
+
+  sig { void }
+  def mock_filter_via_task_selector_last_story_created_less_than_n_days_ago_recent; end
+
+  sig { void }
+  def test_filter_via_task_selector_last_story_created_less_than_n_days_ago_recent; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_task_selector_in_project_named_false; end
+
+  sig { returns(T.untyped) }
+  def test_filter_via_task_selector_in_project_named_true; end
+
+  sig { returns(T.untyped) }
+  def test_dependent_on_previous_section_last_milestone; end
+
+  sig { returns(T.untyped) }
+  def test_in_portfolio_named_true; end
+
+  sig { returns(T.untyped) }
+  def test_in_portfolio_named_false; end
+
+  sig { returns(T.untyped) }
+  def test_custom_field_gid_value_contains_any_gid_false_multi_enum; end
+
+  sig { returns(T.untyped) }
+  def test_last_task_milestone_does_not_depend_on_this_task; end
+
+  sig { returns(T.untyped) }
+  def respond_like_instance_of; end
+
+  sig { returns(T.untyped) }
+  def respond_like; end
+
+  sig { returns(T.class_of(Checkoff::TaskSelectors)) }
+  def class_under_test; end
+end
+
+class TestProjectSelectors < ClassTest
+  extend Forwardable
+
+  sig { returns(Checkoff::ProjectSelectors) }
+  def get_test_object; end
+
+  sig { void }
+  def test_filter_via_custom_field_value_contain_any_value_false; end
+
+  sig { void }
+  def test_filter_via_custom_field_values_contain_any_value_true; end
+
+  sig { void }
+  def test_filter_via_custom_field_values_contain_any_value_true_single_in_multi_enum; end
+
+  sig { void }
+  def test_filter_via_custom_field_values_contain_any_value_true_multiple; end
+
+  sig { void }
+  def test_filter_via_custom_field_values_contain_any_value_false_nothing_set; end
+
+  sig { void }
+  def test_filter_via_custom_field_value_contains_any_value_no_custom_field_false; end
+
+  sig { void }
+  def test_filter_via_due_date_false; end
+
+  sig { void }
+  def test_filter_via_ready_false; end
+
+  sig { void }
+  def test_bogus_raises; end
+
+  sig { returns(T.class_of(Checkoff::ProjectSelectors)) }
+  def class_under_test; end
+
+  sig { returns(T.untyped) }
+  def respond_like_instance_of; end
+
+  sig { returns(T.untyped) }
+  def respond_like; end
+end
+
+class TestSectionSelectors < ClassTest
+  extend Forwardable
+
+  sig { returns(Checkoff::SectionSelectors) }
+  def get_test_object; end
+
+  sig { void }
+  def test_filter_via_ends_with_milestone_empty; end
+
+  sig { void }
+  def expect_client_tasks_pulled; end
+
+  sig { returns(T.untyped) }
+  def expect_section_gid_pulled; end
+
+  sig { returns(T.untyped) }
+  def mock_filter_via_ends_with_milestone_true; end
+
+  sig { void }
+  def test_filter_via_ends_with_milestone_true; end
+
+  sig { void }
+  def test_bogus_raises; end
+
+  sig { void }
+  def test_filter_via_has_tasks_false; end
+
+  sig { returns(T.class_of(Checkoff::SectionSelectors)) }
+  def class_under_test; end
+end
+
+class TestTaskHashes < ClassTest
+  MEMBER_OF_SECTION_A_IN_PROJECT_1 = T.let({
+  'section' => {
+    'gid' => 'section_a_gid',
+    'name' => 'section_a_name',
+  },
+  'project' => {
+    'gid' => 'project_1_gid',
+    'name' => 'project_1_name',
+  },
+}.freeze, T.untyped)
+  TASK_A_RAW_HASH = T.let({
+  'name' => 'a',
+  'custom_fields' => [
+    {
+      'name' => 'custom_field_x',
+      'display_value' => 'foo',
+    },
+  ],
+  'memberships' => [
+    MEMBER_OF_SECTION_A_IN_PROJECT_1,
+  ],
+}.freeze, T.untyped)
+  TASK_A_HASH = T.let({
+  'name' => 'a',
+  'task' => 'a',
+  'custom_fields' => [
+    { 'name' => 'custom_field_x', 'display_value' => 'foo' },
+  ],
+  'memberships' => [
+    MEMBER_OF_SECTION_A_IN_PROJECT_1,
+  ],
+  'unwrapped' => {
+    'custom_fields' => {
+      'custom_field_x' => {
+        'name' => 'custom_field_x',
+        'display_value' => 'foo',
+      },
+    },
+    'membership_by_section_gid' => {
+      'section_a_gid' => MEMBER_OF_SECTION_A_IN_PROJECT_1,
+    },
+    'membership_by_section_name' => {
+      'section_a_name' => MEMBER_OF_SECTION_A_IN_PROJECT_1,
+    },
+    'membership_by_project_gid' => {
+      'project_1_gid' => MEMBER_OF_SECTION_A_IN_PROJECT_1,
+    },
+    'membership_by_project_name' => {
+      'project_1_name' => MEMBER_OF_SECTION_A_IN_PROJECT_1,
+    },
+  },
+}.freeze, T.untyped)
+  TASK_B_RAW_HASH = T.let({
+  'name' => 'b',
+  'custom_fields' => [
+    {
+      'name' => 'custom_field_x',
+      'display_value' => 'bar',
+    },
+  ],
+}.freeze, T.untyped)
+  TASK_B_HASH = T.let({
+  'name' => 'b',
+  'task' => 'b',
+  'custom_fields' => [
+    { 'name' => 'custom_field_x', 'display_value' => 'bar' },
+  ],
+  'unwrapped' => {
+    'custom_fields' => {
+      'custom_field_x' => { 'name' => 'custom_field_x', 'display_value' => 'bar' },
+    },
+    'membership_by_section_gid' => {},
+    'membership_by_section_name' => {},
+    'membership_by_project_gid' => {},
+    'membership_by_project_name' => {},
+  },
+}.freeze, T.untyped)
+
+  sig { returns(T.untyped) }
+  def test_task_a_to_h; end
+
+  sig { returns(T.untyped) }
+  def test_task_b_to_h; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+end
+
+class TestTaskTiming < ClassTest
+  sig { returns(T.untyped) }
+  def test_date_or_time_field_by_name_raises_if_unknown_field; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+
+  sig { returns(T.untyped) }
+  def respond_like_instance_of; end
+
+  sig { returns(T.untyped) }
+  def respond_like; end
+end
+
+# Test the Checkoff::Internal::ConfigLoader class
+class TestConfigLoader < Minitest::Test
+  sig { returns(T.untyped) }
+  def mock_yaml_loaded; end
+
+  sig { returns(T.untyped) }
+  def test_requests_from_env_variable_neither_populated; end
+
+  sig { returns(T.untyped) }
+  def test_requests_from_env_variable_if_yaml_not_populated; end
+
+  sig { returns(T.untyped) }
+  def test_defers_to_yaml; end
+end
+
+class TestProjectHashes < ClassTest
+  PROJECT_A_RAW_HASH = T.let({
+  'name' => 'a',
+  'custom_fields' => [
+    {
+      'name' => 'custom_field_x',
+      'display_value' => 'foo',
+    },
+  ],
+}.freeze, T.untyped)
+  PROJECT_A_HASH = T.let({
+  'name' => 'a',
+  'project' => 'a',
+  'custom_fields' => [
+    { 'name' => 'custom_field_x', 'display_value' => 'foo' },
+  ],
+  'unwrapped' => {
+    'custom_fields' => {
+      'custom_field_x' => {
+        'name' => 'custom_field_x',
+        'display_value' => 'foo',
+      },
+    },
+  },
+}.freeze, T.untyped)
+  PROJECT_B_RAW_HASH = T.let({
+  'name' => 'b',
+  'custom_fields' => [
+    {
+      'name' => 'custom_field_x',
+      'display_value' => 'bar',
+    },
+  ],
+}.freeze, T.untyped)
+  PROJECT_B_HASH = T.let({
+  'name' => 'b',
+  'project' => 'b',
+  'custom_fields' => [
+    { 'name' => 'custom_field_x', 'display_value' => 'bar' },
+  ],
+  'unwrapped' => {
+    'custom_fields' => {
+      'custom_field_x' => { 'name' => 'custom_field_x', 'display_value' => 'bar' },
+    },
+  },
+}.freeze, T.untyped)
+
+  sig { returns(T.untyped) }
+  def test_project_a_to_h; end
+
+  sig { returns(T.untyped) }
+  def test_project_b_to_h; end
+
+  sig { returns(T.untyped) }
+  def test_project_b_to_h_named; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+end
+
+class TestProjectTiming < ClassTest
+  extend Forwardable
+
+  sig { returns(T.untyped) }
+  def test_date_or_time_field_by_name_due; end
+
+  sig { returns(T.untyped) }
+  def test_date_or_time_field_by_name_due_nil; end
+
+  sig { returns(T.untyped) }
+  def test_date_or_time_field_by_name_start; end
+
+  sig { returns(T.untyped) }
+  def test_date_or_time_field_by_name_start_nil; end
+
+  sig { returns(T.untyped) }
+  def test_date_or_time_field_by_name_ready; end
+
+  sig { returns(T.untyped) }
+  def test_date_or_time_field_by_name_custom_field; end
+
+  sig { returns(T.untyped) }
+  def test_date_or_time_field_by_name_custom_field_nil; end
+
+  sig { returns(T.untyped) }
+  def test_date_or_time_field_by_name_raises_if_unknown_field; end
+
+  sig { returns(T.untyped) }
+  def test_date_or_time_field_by_name_raises_if_unknown_array_field; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+
+  sig { returns(T.untyped) }
+  def respond_like_instance_of; end
+
+  sig { returns(T.untyped) }
+  def respond_like; end
+end
+
+# rubocop:disable Metrics/ClassLength
+class TestSearchUrlParser < ClassTest
+  sig { returns(Checkoff::Internal::SearchUrl::Parser) }
+  def get_test_object; end
+
+  sig { void }
+  def test_convert_params_1; end
+
+  sig { void }
+  def test_convert_params_2; end
+
+  sig { void }
+  def test_convert_params_3; end
+
+  sig { void }
+  def test_convert_params_4; end
+
+  sig { void }
+  def test_convert_params_5; end
+
+  sig { void }
+  def test_convert_params_6; end
+
+  sig { void }
+  def test_convert_params_7; end
+
+  sig { void }
+  def test_convert_params_8; end
+
+  sig { void }
+  def test_convert_params_9; end
+
+  sig { void }
+  def test_convert_params_10; end
+
+  sig { void }
+  def test_convert_params_11; end
+
+  sig { void }
+  def test_convert_params_12; end
+
+  sig { void }
+  def test_convert_params_13; end
+
+  sig { void }
+  def test_convert_params_14; end
+
+  sig { void }
+  def test_convert_params_15; end
+
+  sig { void }
+  def test_convert_params_16; end
+
+  sig { void }
+  def test_convert_params_17; end
+
+  sig { void }
+  def test_convert_params_18; end
+
+  sig { void }
+  def test_convert_params_19; end
+
+  sig { void }
+  def test_convert_params_20; end
+
+  sig { void }
+  def test_convert_params_21; end
+
+  sig { void }
+  def test_convert_params_22; end
+
+  sig { void }
+  def test_convert_params_23; end
+
+  sig { void }
+  def test_convert_params_24; end
+
+  sig { void }
+  def test_convert_params_25; end
+
+  sig { void }
+  def test_convert_params_26; end
+
+  sig { void }
+  def test_convert_params_27; end
+
+  sig { void }
+  def test_convert_params_28; end
+
+  sig { void }
+  def test_convert_params_29; end
+
+  sig { void }
+  def test_convert_params_30; end
+
+  sig { void }
+  def test_convert_params_31; end
+
+  sig { void }
+  def test_convert_params_32; end
+
+  sig { void }
+  def test_convert_params_33; end
+
+  sig { void }
+  def test_convert_params_34; end
+
+  sig { void }
+  def test_convert_params_35; end
+
+  sig { void }
+  def test_convert_params_36; end
+
+  sig { void }
+  def test_convert_params_37; end
+
+  sig { void }
+  def test_convert_params_38; end
+
+  sig { void }
+  def test_convert_params_39; end
+
+  sig { void }
+  def test_convert_params_40; end
+
+  sig { void }
+  def test_convert_params_41; end
+
+  sig { void }
+  def test_convert_params_42; end
+
+  sig { void }
+  def test_convert_params_43; end
+
+  sig { void }
+  def test_convert_params_44; end
+
+  sig { void }
+  def test_convert_params_45; end
+
+  sig { returns(T.class_of(Checkoff::Internal::SearchUrl::Parser)) }
+  def class_under_test; end
+end
+
+class TestAsanaEventFilter < ClassTest
+  extend Forwardable
+  TASK_NAME_CHANGED_EVENT = T.let({
+  'action' => 'changed',
+  'created_at' => '2024-01-16T20:10:27.783Z',
+  'change' => {
+    'field' => 'name',
+    'action' => 'changed',
+  },
+  'resource' => {
+    'gid' => '456',
+    'resource_type' => 'task',
+    'resource_subtype' => 'default_task',
+  },
+  'user' => {
+    'gid' => '123',
+    'resource_type' => 'user',
+  },
+}.freeze, T.untyped)
+  CUSTOM_FIELD_CHANGED_EVENT = T.let({
+  'action' => 'changed',
+  'created_at' => '2023-11-23T18:00:00.271Z',
+  'change' => {
+    'field' => 'custom_fields',
+    'action' => 'changed',
+    'new_value' => {
+      'gid' => '12',
+      'resource_type' => 'custom_field',
+      'resource_subtype' => 'enum',
+      'enum_value' => {
+        'gid' => '34',
+        'resource_type' => 'enum_option',
+      },
+    },
+  },
+  'resource' => {
+    'gid' => '56',
+    'resource_type' => 'task',
+    'resource_subtype' => 'default_task',
+  },
+  'user' => {
+    'gid' => '78',
+    'resource_type' => 'user',
+  },
+}.freeze, T.untyped)
+  TASK_REMOVED_FROM_SECTION_EVENT = T.let({
+  'action' => 'removed',
+  'created_at' => '2023-11-22T21:42:14.029Z',
+  'parent' => {
+    'gid' => '90',
+    'resource_type' => 'section',
+  },
+  'resource' => {
+    'gid' => '1',
+    'resource_type' => 'task',
+    'resource_subtype' => 'default_task',
+  },
+  'user' => {
+    'gid' => '78',
+    'resource_type' => 'user',
+  },
+}.freeze, T.untyped)
+  TASK_COMPLETED_EVENT = T.let({
+  'user' => {
+    'gid' => '123',
+    'resource_type' => 'user',
+  },
+  'created_at' => '2024-01-13T20:51:41.806Z',
+  'action' => 'changed',
+  'resource' => {
+    'gid' => '456',
+    'resource_type' => 'task',
+    'resource_subtype' => 'default_task',
+  },
+  'parent' => nil,
+  'change' => { 'field' => 'completed', 'action' => 'changed' },
+}.freeze, T.untyped)
+  TASK_COMPLETED_EVENT_2 = T.let({
+  'user' => {
+    'gid' => '123',
+    'resource_type' => 'user',
+  },
+  'created_at' => '2024-01-15T12:34:45.332Z',
+  'action' => 'changed',
+  'resource' => {
+    'gid' => '456',
+    'resource_type' => 'task',
+    'resource_subtype' => 'default_task',
+  },
+  'change' => {
+    'field' => 'completed',
+    'action' => 'changed',
+  },
+}.freeze, T.untyped)
+
+  sig { returns(T.untyped) }
+  def test_matches_nil_filters_true; end
+
+  sig { returns(T.untyped) }
+  def test_matches_zero_filters_false; end
+
+  sig { returns(T.untyped) }
+  def test_matches_on_resource_type_true; end
+
+  sig { returns(T.untyped) }
+  def test_matches_on_resource_subtype_true; end
+
+  sig { returns(T.untyped) }
+  def test_matches_on_action_true; end
+
+  sig { returns(T.untyped) }
+  def test_matches_on_action_false; end
+
+  sig { returns(T.untyped) }
+  def test_fetched_section_gid; end
+
+  sig { returns(T.untyped) }
+  def test_matches_on_fields_true; end
+
+  sig { params(gid: T.untyped, fields: T.untyped, task_obj: T.untyped).returns(T.untyped) }
+  def expect_task_fetched(gid, fields, task_obj); end
+
+  sig { returns(T.untyped) }
+  def test_task_completed_event_true; end
+
+  sig { returns(T.untyped) }
+  def test_matches_on_parent_gid_true; end
+
+  sig { returns(T.untyped) }
+  def test_matches_on_bad_key_raises; end
+
+  sig { returns(T.untyped) }
+  def class_under_test; end
+
+  sig { returns(T.untyped) }
+  def respond_like_instance_of; end
+
+  sig { returns(T.untyped) }
+  def respond_like; end
+end