How we unsubscribe all subscribers temporarily in specs

[krisleech]

I'm working on some legacy code which I'm trying to clean up a bit. We subscribe in a Rails initializer. In some specs we need to have only a subset of subscribers enabled. The way it works now is effectively this:

original_client = Rails.configuration.event_store
Rails.configuration.event_store =  RailsEventStore::Client.new(...)
Rails.configuration.event_store.susbcribe(...)
example.run
Rails.configuration.event_store = original_client

We have done some refactoring and now we have our own object which wraps RailsEventStore::Client, it's something like:

module EventKit
  def self.event_store
    @event_store ||= EventStore.new
  end

  class EventStore < SimpleDelegator
    def initalize
      super(default_event_store)
    end

    private

    def default_event_store
      RailsEventStore::Client.new(...)
    end
  end
end

What I'd like it a way to temporarily unsubscribe all subscribers, so in the specs we can do something like:

EventKit.event_store.without_subscribers do
  # ...
end

I was thinking doing the following, thought I'd share:

module EventKit
  class EventStore < SimpleDelegator
    def initialize(event_store: default_event_store)
      super(event_store)
    end

    def unwrap
      __getobj__
    end

    def unsubscribe_all(&block)
      original_event_store = unwrap
      reset!
      block.call
    ensure
      reset!(event_store: original_event_store)
    end

    private

    def default_event_store
      RailsEventStore::Client.new(...)
    end
  end
end

Instead of using Rails.configuration.event_store we do EventKit.event.store.

Any comments, thoughts, alternatives welcome 😄

[pjurewicz]

Hello @krisleech, nice to meet you!
in time of setting up subscriptions you can group them and store lambdas that are return in an array:

    def set_up_optional_subscription
      @optional_subscriptions = [
        event_store.subscribe(HandlerKlass.new, to: [EventKlass]),
        event_store.subscribe(AnotherHandlerKlass.new, to: [AnotherEventKlass]),
        event_store.subscribe(YetANotherHandlerKlass.new, to: [YetAnotherEventKlass]),
      ]
    end

Then you can invoke call on each of them to remove these subscriptions:

    def remove_optional_subscriptions
      @optional_subscriptions.each(&:call)
    end

You should be able to set up them again by calling set_up_optional_subscription on your wrapper.
Let me know if it works for you!

[krisleech]

Great suggestion, this got me thinking if I could store the unsubscribe lambda's when subscribing an event handler in the wrapper as such:

module EventKit
  class EventStore < SimpleDelegator
    def initialize(event_store: default_event_store)
     @unsubscribes = []
      super(event_store)
    end

    def subscribe(event_handler)
      super(event_handler, to: event_handler.events_handled).tap { |unsubscribe| @unsubscribes << unsubscribe }
    end

    def unsubscribe_all(&block)
      @unsubscribes.each(&:call)
      self
    end

    private

    def default_event_store
      RailsEventStore::Client.new(...)
    end
  end
end

Happy new year!

[pjurewicz]

Sure, you can. Happy new year!

[mostlyobvious]

An alternative approach might be to explicitly subscribe in tests. Have each test running with new event store instance that has to be configured beforehand. This works well when you already clear boundaries in the application.

Example:

module SampleApp
  class Configuration
    def call(event_store, command_bus)
      [
        Banking::Configuration.new, # subscriptions in the Banking context
        Accounting::Configuration.new,
        Cashflow::Configuration.new,
        Analytics::Configuration.new,
        Crm::Configuration.new
      ].each { |module_config| module_config.call(event_store, command_bus) }
    end
  end
end


class ActiveSupport::TestCase
  def command_bus
    Rails.configuration.command_bus
  end

  def event_store
    Rails.configuration.event_store
  end

  def replace_event_store_and_command_bus
    Rails.configuration.command_bus = Infra::CommandBus.new
    Rails.configuration.event_store = Infra::EventStore.new
  end

  def integrate_with_accounting
    Accounting::Configuration.new.call(event_store, command_bus)
  end

  def integrate_with_cashflow
    Cashflow::Configuration.new.call(event_store, command_bus)
  end

  # ...
end

module Accounting
  class TestCase < ActiveSupport::TestCase # each test in accounting has accounting handlers subscribed
    def before_setup
      super
      replace_event_store_and_command_bus
      integrate_with_accounting
    end
  end
end

module Accounting
  class RebuildFromScratchTest < TestCase
    def test_something_with_integration_of_cashflow_module
      integrate_with_cashflow # additionally integrate with cashflow module for "integration" of two contexts
      # ...
    end
  end
end

[krisleech]

Somewhat related, I started working on allowing the event store client to be swapped out.

module EventKit
  class EventStore < SimpleDelegator
    def initialize(event_store:)
      super(event_store)
    end

    def unsubscribe_all(&block)
      becomes(build(:default), &block)
    end

    def becomes(new_event_store, &block)
      original_event_store = __getobj__
      becomes!(new_event_store)

      block.call
    ensure
      becomes!(original_event_store)
    end

    def becomes!(new_event_store)
       __setobj__(build(event_store))
    end

  private

  # returns an instance of RailsEventStore::Client
   def build(event_store)
      Builder.call(event_store)
    end
end

EventKit.event_store.becomes(:in_memory)

The problem here is that swapping the event store unsubscribes everything, so I'd need to do something as you suggested and be able to re-subscribe in the specs. Unless I actually stored a copy of each handler when I subscribe them and could re-subscribe everything after becomes! is called 🤔 (I don't see a way I can get a list of handlers from the existing event store client).

Something like:

def initialize(event_store: default_event_store)
   @event_handlers = []
   super(event_store)
end

def subscribe(event_handler)
  @event_handers << event_handler
  super(event_handler, to: event_handler.events_handled)
end

def becomes!(new_event_store)
  __setobj__(build(event_store))
  @event_handlers.each(&method(:subscribe))
end

I'll have a play with this idea and see what i can come up with. Thanks for the feedback!

[mostlyobvious]

I don't see a way I can get a list of handlers from the existing event store client

You can retrieve handlers for particular event types:
https://github.com/RailsEventStore/rails_event_store/blob/master/ruby_event_store/lib/ruby_event_store/client.rb#L165-L171