plan_my_stuff 0.3.0 → 0.5.0

data/lib/plan_my_stuff/reminders/sweep.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module PlanMyStuff
+  module Reminders
+    # Walks a single repo's waiting issues, dispatching each to +Closer+
+    # when past the inactivity ceiling or +Fire+ when a reminder is due.
+    # Called from +RemindersSweepJob+; no ActiveJob dependency here so
+    # the logic stays unit-testable and callable from a plain rake task.
+    class Sweep
+      # @param repo [Symbol, String] repo key or full name
+      # @param now [Time] clock reference
+      #
+      def initialize(repo:, now: Time.now.utc)
+        @repo = repo
+        @now = now.utc
+      end
+
+      # Runs the sweep. No-op when +config.reminders_enabled+ is false.
+      #
+      # @return [void]
+      #
+      def call
+        return unless PlanMyStuff.configuration.reminders_enabled
+
+        candidates.each do |issue|
+          if Closer.should_close?(issue, now: @now)
+            Closer.new(issue, now: @now).call
+          elsif Fire.ready?(issue, now: @now)
+            Fire.new(issue, now: @now).call
+          end
+        end
+      end
+
+      private
+
+        # Issues carrying either waiting label, deduplicated by number.
+        # GitHub's labels filter is AND across multiple labels, so we
+        # query each label separately and merge.
+        #
+        # @return [Array<PlanMyStuff::Issue>]
+        #
+        def candidates
+          user_label = PlanMyStuff.configuration.waiting_on_user_label
+          approval_label = PlanMyStuff.configuration.waiting_on_approval_label
+
+          by_label = [user_label, approval_label].flat_map do |label|
+            PlanMyStuff::Issue.list(repo: @repo, labels: [label], state: :open)
+          end
+
+          by_label.uniq(&:number)
+        end
+    end
+  end
+end

data/lib/plan_my_stuff/reminders.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module PlanMyStuff
+  # Follow-up reminder engine. The +Sweep+ class walks the waiting issues
+  # in a repo and dispatches to +Fire+ for reminders that are due or
+  # +Closer+ for issues that have exceeded the inactivity threshold.
+  #
+  # Entry point for the sweep lives in +RemindersSweepJob+; this module
+  # holds the POROs so they can be unit-tested without ActiveJob.
+  module Reminders
+  end
+end
+
+require_relative 'reminders/closer'
+require_relative 'reminders/fire'
+require_relative 'reminders/sweep'

data/lib/plan_my_stuff/test_helpers.rb

@@ -58,8 +58,8 @@ module PlanMyStuff
           custom_fields: {},
         }.merge(metadata))
 
-        issue.instance_variable_set(:@metadata, issue_metadata)
-        issue.instance_variable_set(:@persisted, true)
+        issue.metadata = issue_metadata
+        issue.__send__(:persisted!)
 
         body_comment = build_comment(
           body: body,
@@ -98,8 +98,8 @@ module PlanMyStuff
           custom_fields: {},
         }.merge(metadata))
 
-        comment.instance_variable_set(:@metadata, comment_metadata)
-        comment.instance_variable_set(:@persisted, true)
+        comment.metadata = comment_metadata
+        comment.__send__(:persisted!)
         comment
       end
 
@@ -124,7 +124,7 @@ module PlanMyStuff
           statuses: status_options,
           fields: [{ id: 'field_status', name: 'Status', options: status_options }],
         )
-        project.instance_variable_set(:@persisted, true)
+        project.__send__(:persisted!)
 
         project.items = items.map do |item_hash|
           PlanMyStuff::ProjectItem.build(
@@ -143,6 +143,54 @@ module PlanMyStuff
 
         project
       end
+
+      # Sets approvals on an in-memory +Issue+ without hitting the API.
+      # Accepts user objects or integer user_ids.
+      #
+      # @param issue [PlanMyStuff::Issue]
+      # @param approved [Array<Object, Integer>] approvers who have approved
+      # @param pending [Array<Object, Integer>] approvers who have not yet approved
+      #
+      # @return [Array<PlanMyStuff::Approval>] the records written to +issue.metadata.approvals+
+      #
+      def stub_approvals(issue, approved: [], pending: [])
+        records =
+          pending.map { |u| PlanMyStuff::Approval.new(user_id: extract_user_id(u), status: 'pending') } +
+          approved.map do |u|
+            PlanMyStuff::Approval.new(user_id: extract_user_id(u), status: 'approved', approved_at: Time.current)
+          end
+        issue.metadata.approvals = records
+        records
+      end
+
+      # @return [Integer]
+      def extract_user_id(user)
+        user.is_a?(Integer) ? user : PlanMyStuff::UserResolver.user_id(user)
+      end
+    end
+
+    # Captures +plan_my_stuff.*+ +ActiveSupport::Notifications+ events fired
+    # inside the given block. Lets consuming apps assert that their code
+    # triggers gem events without threading subscriptions through every spec.
+    #
+    # Usage:
+    #
+    #   events = PlanMyStuff::TestHelpers::Notifications.capture do
+    #     PlanMyStuff::Issue.create!(...)
+    #   end
+    #   events.first[:name]    # => "plan_my_stuff.issue.created"
+    #   events.first[:payload] # => { issue:, user:, timestamp:, ... }
+    #
+    module Notifications
+      module_function
+
+      # @return [Array<Hash>] events as +{ name: String, payload: Hash }+
+      def capture(&)
+        events = []
+        callback = -> (name, _start, _finish, _id, payload) { events << { name: name, payload: payload } }
+        ActiveSupport::Notifications.subscribed(callback, /^plan_my_stuff\./, &)
+        events
+      end
     end
 
     # RSpec matchers included when the module is included in a test config.
@@ -218,6 +266,41 @@ module PlanMyStuff
       expect_pms_action(:item_assigned, 'item to be assigned', **filters)
     end
 
+    # @param filters [Hash] attribute filters (e.g. assignee:, project_number:)
+    def expect_pms_pipeline_submitted(**filters)
+      expect_pms_action(:pipeline_submitted, 'pipeline submission', **filters)
+    end
+
+    # @param filters [Hash] attribute filters (e.g. item_id:)
+    def expect_pms_pipeline_taken(**filters)
+      expect_pms_action(:pipeline_started, 'pipeline item to be taken', **filters)
+    end
+
+    # @param filters [Hash] attribute filters (e.g. item_id:)
+    def expect_pms_pipeline_in_review(**filters)
+      expect_pms_action(:pipeline_in_review, 'pipeline item marked in review', **filters)
+    end
+
+    # @param filters [Hash] attribute filters (e.g. item_id:)
+    def expect_pms_pipeline_testing(**filters)
+      expect_pms_action(:pipeline_testing, 'pipeline item moved to testing', **filters)
+    end
+
+    # @param filters [Hash] attribute filters (e.g. item_id:)
+    def expect_pms_pipeline_ready_for_release(**filters)
+      expect_pms_action(:pipeline_ready_for_release, 'pipeline item marked ready for release', **filters)
+    end
+
+    # @param filters [Hash] attribute filters (e.g. project_number:, commit_sha:)
+    def expect_pms_pipeline_deployment_started(**filters)
+      expect_pms_action(:pipeline_deployment_started, 'pipeline deployment started', **filters)
+    end
+
+    # @param filters [Hash] attribute filters (e.g. item_id:, deployment_id:)
+    def expect_pms_pipeline_deployment_completed(**filters)
+      expect_pms_action(:pipeline_deployment_completed, 'pipeline deployment completed', **filters)
+    end
+
     private
 
       # @return [void]
@@ -265,10 +348,11 @@ module PlanMyStuff
       stub_comment_class_methods!
       stub_project_class_methods!
       stub_project_item_class_methods!
+      stub_pipeline_methods!
       @_test_mode = true
     end
 
-    # Restores original class methods overwritten by test_mode!
+    # Restores original class / instance methods overwritten by test_mode!
     #
     # @return [void]
     #
@@ -276,8 +360,13 @@ module PlanMyStuff
       return unless @_test_mode
 
       (@_test_mode_originals || {}).each do |klass, methods|
-        methods.each do |name, original|
-          klass.define_singleton_method(name, original)
+        methods.each do |key, original|
+          kind, name = key
+          if kind == :instance
+            klass.define_method(name, original)
+          else
+            klass.define_singleton_method(name, original)
+          end
         end
       end
 
@@ -288,7 +377,7 @@ module PlanMyStuff
 
     private
 
-      # Saves the original method so it can be restored by exit_test_mode!
+      # Saves the original class method so it can be restored by exit_test_mode!
       #
       # @param klass [Class]
       # @param method_name [Symbol]
@@ -297,13 +386,26 @@ module PlanMyStuff
       #
       def save_original(klass, method_name)
         @_test_mode_originals[klass] ||= {}
-        @_test_mode_originals[klass][method_name] = klass.method(method_name)
+        @_test_mode_originals[klass][[:class, method_name]] = klass.method(method_name)
+      end
+
+      # Saves the original instance method so it can be restored by exit_test_mode!
+      #
+      # @param klass [Class]
+      # @param method_name [Symbol]
+      #
+      # @return [void]
+      #
+      def save_instance_original(klass, method_name)
+        @_test_mode_originals[klass] ||= {}
+        @_test_mode_originals[klass][[:instance, method_name]] = klass.instance_method(method_name)
       end
 
       # @return [void]
       def stub_issue_class_methods!
         issue_mod = PlanMyStuff::Issue
-        %i[create! find list update! add_viewers remove_viewers].each { |m| save_original(issue_mod, m) }
+        %i[create! find list update!].each { |m| save_original(issue_mod, m) }
+        %i[add_viewers remove_viewers].each { |m| save_instance_original(issue_mod, m) }
 
         issue_mod.define_singleton_method(:create!) do |**params|
           PlanMyStuff::TestHelpers.recorded_actions << {
@@ -359,19 +461,19 @@ module PlanMyStuff
           nil
         end
 
-        issue_mod.define_singleton_method(:add_viewers) do |**params|
+        issue_mod.define_method(:add_viewers) do |user_ids:, user: nil|
           PlanMyStuff::TestHelpers.recorded_actions << {
             type: :viewers_added,
-            params: params,
+            params: { number: number, repo: repo&.to_s, user_ids: Array.wrap(user_ids), user: user },
           }
 
           nil
         end
 
-        issue_mod.define_singleton_method(:remove_viewers) do |**params|
+        issue_mod.define_method(:remove_viewers) do |user_ids:, user: nil|
           PlanMyStuff::TestHelpers.recorded_actions << {
             type: :viewers_removed,
-            params: params,
+            params: { number: number, repo: repo&.to_s, user_ids: Array.wrap(user_ids), user: user },
           }
 
           nil
@@ -505,5 +607,148 @@ module PlanMyStuff
           nil
         end
       end
+
+      # @return [void]
+      def stub_pipeline_methods!
+        pipeline_mod = PlanMyStuff::Pipeline
+        %i[
+          submit! take! mark_in_review! request_testing! mark_ready_for_release! start_deployment! complete_deployment!
+        ].each { |m| save_original(pipeline_mod, m) }
+
+        pipeline_mod.define_singleton_method(:submit!) do |issue, assignee:, project_number: nil|
+          number =
+            project_number || PlanMyStuff.configuration.pipeline_project_number ||
+            PlanMyStuff.configuration.default_project_number
+
+          PlanMyStuff::TestHelpers.recorded_actions << {
+            type: :pipeline_submitted,
+            params: {
+              issue_number: issue.respond_to?(:number) ? issue.number : nil,
+              assignee: assignee,
+              project_number: number,
+            },
+          }
+
+          project = PlanMyStuff::TestHelpers.build_project(number: number || 1)
+          PlanMyStuff::ProjectItem.build(
+            {
+              id: "PVTI_fake_#{rand(10_000)}",
+              title: issue.respond_to?(:title) ? issue.title : 'Untitled',
+              number: issue.respond_to?(:number) ? issue.number : nil,
+              status: PlanMyStuff::Pipeline::Status::SUBMITTED,
+              field_values: {},
+            },
+            project: project,
+          )
+        end
+
+        pipeline_mod.define_singleton_method(:take!) do |project_item|
+          PlanMyStuff::TestHelpers.recorded_actions << {
+            type: :pipeline_started,
+            params: {
+              item_id: project_item.respond_to?(:id) ? project_item.id : nil,
+              issue_number: project_item.respond_to?(:number) ? project_item.number : nil,
+            },
+          }
+
+          nil
+        end
+
+        pipeline_mod.define_singleton_method(:mark_in_review!) do |project_item|
+          PlanMyStuff::TestHelpers.recorded_actions << {
+            type: :pipeline_in_review,
+            params: {
+              item_id: project_item.respond_to?(:id) ? project_item.id : nil,
+              issue_number: project_item.respond_to?(:number) ? project_item.number : nil,
+            },
+          }
+
+          nil
+        end
+
+        pipeline_mod.define_singleton_method(:request_testing!) do |project_item|
+          PlanMyStuff::TestHelpers.recorded_actions << {
+            type: :pipeline_testing,
+            params: {
+              item_id: project_item.respond_to?(:id) ? project_item.id : nil,
+              issue_number: project_item.respond_to?(:number) ? project_item.number : nil,
+            },
+          }
+
+          nil
+        end
+
+        pipeline_mod.define_singleton_method(:mark_ready_for_release!) do |project_item|
+          PlanMyStuff::TestHelpers.recorded_actions << {
+            type: :pipeline_ready_for_release,
+            params: {
+              item_id: project_item.respond_to?(:id) ? project_item.id : nil,
+              issue_number: project_item.respond_to?(:number) ? project_item.number : nil,
+            },
+          }
+
+          nil
+        end
+
+        pipeline_mod.define_singleton_method(:start_deployment!) do |project_number: nil, commit_sha: nil|
+          number =
+            project_number || PlanMyStuff.configuration.pipeline_project_number ||
+            PlanMyStuff.configuration.default_project_number
+
+          PlanMyStuff::TestHelpers.recorded_actions << {
+            type: :pipeline_deployment_started,
+            params: {
+              project_number: number,
+              commit_sha: commit_sha,
+            },
+          }
+
+          []
+        end
+
+        pipeline_mod.define_singleton_method(:complete_deployment!) do |project_item, deployment_id: nil|
+          PlanMyStuff::TestHelpers.recorded_actions << {
+            type: :pipeline_deployment_completed,
+            params: {
+              item_id: project_item.respond_to?(:id) ? project_item.id : nil,
+              issue_number: project_item.respond_to?(:number) ? project_item.number : nil,
+              deployment_id: deployment_id,
+            },
+          }
+
+          nil
+        end
+      end
+  end
+end
+
+if defined?(RSpec::Matchers)
+  # Asserts that a +plan_my_stuff.<name>+ event was fired inside the block.
+  # Chain +.with(key: value, ...)+ to match on a payload subset.
+  #
+  #   expect { Issue.create!(...) }.to(have_fired_event('plan_my_stuff.issue.created'))
+  #   expect { Issue.create!(...) }.to(have_fired_event('plan_my_stuff.issue.created').with(user: alice))
+  #
+  RSpec::Matchers.define(:have_fired_event) do |event_name|
+    supports_block_expectations
+
+    chain(:with) { |expected_payload| @expected_payload = expected_payload }
+
+    match do |block|
+      events = PlanMyStuff::TestHelpers::Notifications.capture(&block)
+      matching = events.select { |e| e[:name] == event_name }
+      @fired_events = events
+      next false if matching.empty?
+      next true if @expected_payload.nil?
+
+      matching.any? { |e| @expected_payload.all? { |k, v| e[:payload][k] == v } }
+    end
+
+    failure_message do
+      fired_names = @fired_events.pluck(:name)
+      base = "expected block to fire #{event_name.inspect}"
+      base += " with payload including #{@expected_payload.inspect}" if @expected_payload
+      "#{base}, but fired: #{fired_names.empty? ? '(none)' : fired_names.inspect}"
+    end
   end
 end