rspec-openhab-scripting 0.0.8-java → 0.0.11-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b4f4a385d3672410faee3ca6a90eb931f4499060de30d5dfc11869c73b78db7
-  data.tar.gz: 2d6c73ceabd6796134434250824ee255f80cc74b98b16f4172ac76d6be350c5b
+  metadata.gz: 3ef6a42e87b4466cf53972b65523d3a810060cbeac84497796ab4514b377d445
+  data.tar.gz: 0b3be611dddf1a4e5643cdb48fd3f8a05d35eda32e50e9b4062a063f49f6ad17
 SHA512:
-  metadata.gz: e9153da220c8491f9a8f79bed277646df27b95ed4c17fb0181dcfd8519df0d9443c989ace2f2fe8da3fb39c14e177d7147e7148cffd5a47baa6a121a821ce883
-  data.tar.gz: 70b3fefd8b2df95db3fc553fcb785c48c8e63d3671c0922328bd0937819e7f3b3cc164edb58e3d4fc04da20101297c65868696ebf624b664892b16c86bed22cd
+  metadata.gz: 0ffaf54c3e64d9a4f1be5ff0ecec757976db0e5ebbddec2d916d254fb9f9f730f3e1e1245fc478a970e8e42509613877ac535f9983aa94288cbb9c1f7abfa826
+  data.tar.gz: 3333117270aa1e6b2de597ad9570df51a9f829d0c5da345cdbb1aed5f50d5bf841cdd1b9a140a94cf06695982acce024280ec814f4cbe5b46ab94dce88566b40

data/lib/rspec/openhab/dsl/imports.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "singleton"
+
 require "openhab/core/osgi"
 
 module OpenHAB
@@ -20,6 +22,7 @@ module OpenHAB
 
         def initialize(event_manager)
           @event_manager = event_manager
+          @pending_events = nil
         end
 
         def post_event(event)
@@ -27,7 +30,17 @@ module OpenHAB
         end
 
         def send_event(event)
+          if @pending_events
+            @pending_events << event
+            return
+          end
+
+          @pending_events = []
           @event_manager.handle_event(event)
+
+          @event_manager.handle_event(@pending_events.shift) until @pending_events.empty?
+
+          @pending_events = nil
         end
       end
 
@@ -123,6 +136,119 @@ module OpenHAB
         field_reader :typedEventFactories, :typedEventSubscribers
       end
 
+      # reimplement to not use a thread
+      class EventHandler
+        def initialize(typed_event_subscribers, typed_event_factories)
+          @typed_event_subscribers = typed_event_subscribers
+          @typed_event_factories = typed_event_factories
+        end
+
+        def handle_event(osgi_event)
+          type = osgi_event.get_property("type")
+          payload = osgi_event.get_property("payload")
+          topic = osgi_event.get_property("topic")
+          source = osgi_event.get_property("source")
+
+          if type.is_a?(String) && payload.is_a?(String) && topic.is_a?(String)
+            handle_event_internal(type, payload, topic, source) unless type.empty? || payload.empty? || topic.empty?
+          else
+            logger.error("The handled OSGi event is invalid. " \
+                         "Expect properties as string named 'type', 'payload', and 'topic'. " \
+                         "Received event properties are: #{properties.keys.inspect}")
+          end
+        end
+
+        private
+
+        def handle_event_internal(type, payload, topic, source)
+          event_factory = @typed_event_factories[type]
+          unless event_factory
+            logger.debug("Could not find an Event Factory for the event type '#{type}'.")
+            return
+          end
+
+          event_subscribers = event_subscribers(type)
+          return if event_subscribers.empty?
+
+          event = create_event(event_factory, type, payload, topic, source)
+          return unless event
+
+          dispatch_event(event_subscribers, event)
+        end
+
+        def event_subscribers(event_type)
+          event_type_subscribers = @typed_event_subscribers[event_type]
+          all_event_type_subscribers = @typed_event_subscribers["ALL"]
+
+          subscribers = java.util.HashSet.new
+          subscribers.add_all(event_type_subscribers) if event_type_subscribers
+          subscribers.add_all(all_event_type_subscribers) if all_event_type_subscribers
+          subscribers
+        end
+
+        def create_event(event_factory, type, payload, topic, source)
+          event_factory.create_event(type, topic, payload, source)
+        rescue Exception => e
+          logger.warn("Creation of event failed, because one of the " \
+                      "registered event factories has thrown an exception: #{e}")
+          nil
+        end
+
+        def dispatch_event(event_subscribers, event)
+          event_subscribers.each do |event_subscriber|
+            filter = event_subscriber.event_filter
+            if filter.nil? || filter.apply(event)
+              begin
+                event_subscriber.receive(event)
+              rescue Exception => e
+                logger.warn("Dispatching/filtering event for subscriber '#{event_subscriber.class}' failed: #{e}")
+              end
+            else
+              logger.trace("Skip event subscriber (#{event_subscriber.class}) because of its filter.")
+            end
+          end
+        end
+      end
+
+      org.openhab.core.automation.internal.TriggerHandlerCallbackImpl.field_accessor :executor
+      org.openhab.core.automation.internal.TriggerHandlerCallbackImpl.field_reader :ruleUID
+      class SynchronousExecutor
+        include java.util.concurrent.ScheduledExecutorService
+        include Singleton
+
+        def submit(runnable)
+          runnable.run
+
+          java.util.concurrent.CompletableFuture.completed_future(nil)
+        end
+
+        def execute(runnable)
+          runnable.run
+        end
+
+        def shutdown_now; end
+
+        def shutdown?
+          false
+        end
+      end
+
+      class CallbacksMap < java.util.HashMap
+        def put(_rule_uid, trigger_handler)
+          trigger_handler.executor.shutdown_now
+          trigger_handler.executor = SynchronousExecutor.instance
+          super
+        end
+      end
+
+      class SynchronousExecutorMap
+        include java.util.Map
+
+        def get(_key)
+          SynchronousExecutor.instance
+        end
+      end
+
       @imported = false
 
       class << self
@@ -133,18 +259,13 @@ module OpenHAB
 
           @imported = true
 
-          # some background java threads get created; kill them at_exit
-          at_exit do
-            status = 0
-            status = $!.status if $!.is_a?(SystemExit)
-            exit!(status)
-          end
+          org.openhab.core.common.ThreadPoolManager.field_accessor :pools
+          org.openhab.core.common.ThreadPoolManager.pools = SynchronousExecutorMap.new
 
           # OSGiEventManager will create a ThreadedEventHandler on OSGi activation;
           # we're skipping that, and directly sending to a non-threaded event handler.
           em = EventManager.new
-          eh = org.openhab.core.internal.events.EventHandler.new(em.typedEventSubscribers, em.typedEventFactories)
-          at_exit { eh.close }
+          eh = EventHandler.new(em.typedEventSubscribers, em.typedEventFactories)
           ea = EventAdmin.new(eh)
           ep = org.openhab.core.internal.events.OSGiEventPublisher.new(ea)
           bc = BundleContext.new(em)
@@ -157,6 +278,8 @@ module OpenHAB
           OpenHAB::Core::OSGI.register_service("org.openhab.core.items.MetadataRegistry", mr)
           mr.managed_provider = mmp = org.openhab.core.internal.items.ManagedMetadataProviderImpl.new(ss)
           mr.add_provider(mmp)
+          gmp = org.openhab.core.model.item.internal.GenericMetadataProvider.new
+          mr.add_provider(gmp)
           ir = org.openhab.core.internal.items.ItemRegistryImpl.new(mr)
           ir.managed_provider = mip = org.openhab.core.items.ManagedItemProvider.new(ss, nil)
           ir.add_provider(mip)
@@ -171,6 +294,22 @@ module OpenHAB
           rr.managed_provider = mrp = org.openhab.core.automation.ManagedRuleProvider.new(ss)
           rr.add_provider(mrp)
           iclr = org.openhab.core.thing.link.ItemChannelLinkRegistry.new(tr, ir)
+          ctr = org.openhab.core.thing.type.ChannelTypeRegistry.new
+          ttr = org.openhab.core.thing.type.ThingTypeRegistry.new(ctr)
+
+          safe_emf = org.openhab.core.model.core.internal.SafeEMFImpl.new
+          model_repository = org.openhab.core.model.core.internal.ModelRepositoryImpl.new(safe_emf)
+
+          # set up state descriptions
+          sds = org.openhab.core.internal.service.StateDescriptionServiceImpl.new
+          gip = org.openhab.core.model.item.internal.GenericItemProvider.new(model_repository, gmp, {})
+          sds.add_state_description_fragment_provider(gip)
+          msdfp = org.openhab.core.internal.items.MetadataStateDescriptionFragmentProvider.new(mr, {})
+          sds.add_state_description_fragment_provider(msdfp)
+          csdp = org.openhab.core.thing.internal.ChannelStateDescriptionProvider.new(iclr, ttr, tr)
+          csdp.activate(org.osgi.framework.Constants::SERVICE_RANKING => java.lang.Integer.new(-1))
+          sds.add_state_description_fragment_provider(csdp)
+          ir.state_description_service = sds
 
           # set up stuff accessed from rules
           preset = org.openhab.core.automation.module.script.internal.defaultscope
@@ -216,8 +355,7 @@ module OpenHAB
           $se = $scriptExtension = sew
 
           # need to create some singletons referencing registries
-          scheduler = org.openhab.core.internal.scheduler.SchedulerImpl.new
-          org.openhab.core.model.script.ScriptServiceUtil.new(ir, tr, ep, nil, scheduler)
+          org.openhab.core.model.script.ScriptServiceUtil.new(ir, tr, ep, nil, nil)
           org.openhab.core.model.script.internal.engine.action.SemanticsActionService.new(ir)
 
           # link up event bus infrastructure
@@ -247,6 +385,12 @@ module OpenHAB
 
           rs = org.openhab.core.internal.service.ReadyServiceImpl.new
           re = org.openhab.core.automation.internal.RuleEngineImpl.new(mtr, rr, ss, rs)
+          # overwrite thCallbacks to one that will spy to remove threading
+          field = re.class.java_class.declared_field("thCallbacks")
+          field.accessible = true
+          field.set(re, CallbacksMap.new)
+          re.class.field_accessor :executor
+          re.executor = SynchronousExecutor.instance
           re.add_module_handler_factory(cmhf)
           re.add_module_handler_factory(scmhf)
           re.add_module_handler_factory(spmhf)

data/lib/rspec/openhab/dsl/timers/timer.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    class Timer
+      module MockedZonedDateTime
+        def now
+          mocked_time_stack_item = Timecop.top_stack_item
+          return super unless mocked_time_stack_item
+
+          instant = java.time.Instant.of_epoch_milli((Time.now.to_f * 1000).to_i)
+          ZonedDateTime.of_instant(instant, java.time.ZoneId.system_default)
+        end
+      end
+      ZonedDateTime.singleton_class.prepend(MockedZonedDateTime)
+
+      # extend Timecop to support java time classes
+      module TimeCopStackItem
+        def parse_time(*args)
+          if args.length == 1 && args.first.is_a?(Duration)
+            return time_klass.at(ZonedDateTime.now.plus(args.first).to_instant.to_epoch_milli / 1000.0)
+          end
+
+          super
+        end
+      end
+      Timecop::TimeStackItem.prepend(TimeCopStackItem)
+
+      attr_reader :execution_time
+
+      def initialize(duration:, thread_locals: {}, &block) # rubocop:disable Lint/UnusedMethodArgument
+        @block = block
+        reschedule(duration)
+      end
+
+      def reschedule(duration = nil)
+        @duration = duration || @duration
+        @execution_time = ZonedDateTime.now.plus(@duration)
+        @executed = @cancelled = false
+
+        Timers.timer_manager.add(self)
+      end
+
+      def execute
+        raise "Timer already cancelled" if cancelled?
+        raise "Timer already executed" if terminated?
+
+        @block.call
+        Timers.timer_manager.delete(self)
+        @executed = true
+      end
+
+      def cancel
+        Timers.timer_manager.delete(self)
+        @executed = false
+        @cancelled = true
+        true
+      end
+
+      def cancelled?
+        @cancelled
+      end
+
+      def terminated?
+        @executed || @cancelled
+      end
+
+      def running?
+        active? && @execution_time > ZonedDateTime.now
+      end
+
+      def active?
+        !terminated?
+      end
+    end
+
+    module Support
+      class TimerManager
+        def execute_timers
+          @timers.each { |t| t.execute if t.active? && t.execution_time < ZonedDateTime.now }
+        end
+      end
+    end
+  end
+end

data/lib/rspec/openhab/helpers.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RSpec
+  module OpenHAB
+    module Helpers
+      def autoupdate_all_items
+        @autoupdated_items ||= {}
+        $ir.for_each do |_provider, item|
+          @autoupdated_items[item] = item.meta.delete("autoupdate") if item.meta.key?("autoupdate")
+        end
+      end
+
+      def execute_timers
+        OpenHAB::DSL::Timers.timer_manager.execute_timers
+      end
+
+      def suspend_rules(&block)
+        SuspendRules.suspend_rules(&block)
+      end
+
+      def trigger_rule(rule_name, event = nil)
+        @rules ||= ::OpenHAB::DSL::Rules::Rule.script_rules.each_with_object({}) { |r, obj| obj[r.name] = r }
+
+        @rules.fetch(rule_name).execute(nil, { "event" => event })
+      end
+
+      private
+
+      def restore_autoupdate_items
+        return unless instance_variable_defined?(:@autoupdated_items)
+
+        @autoupdated_items.each do |(item, meta)|
+          item.meta["autoupdate"] = meta
+        end
+      end
+    end
+
+    RSpec.configure do |config|
+      config.include Helpers
+    end
+  end
+end

data/lib/rspec/openhab/hooks.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+RSpec.configure do |config|
+  config.before(:all) { OpenHAB::DSL::Timers.timer_manager.cancel_all }
+
+  config.before do
+    suspend_rules do
+      $ir.for_each do |_provider, item|
+        item.state = NULL unless item.raw_state == NULL
+      end
+    end
+  end
+  config.after do
+    OpenHAB::DSL::Timers.timer_manager.cancel_all
+    Timecop.return
+    restore_autoupdate_items
+  end
+end

data/lib/rspec/openhab/items.rb

@@ -8,25 +8,24 @@ module RSpec
           all_items = api.items
 
           gfh = org.openhab.core.internal.items.GroupFunctionHelper.new
+          item_factory = org.openhab.core.library.CoreItemFactory.new
 
           all_items.each do |item_json|
-            type, _dimension = item_json["type"].split(":")
+            full_type = item_json["type"]
+            name = item_json["name"]
+
+            type, _dimension = full_type.split(":")
             if type == "Group"
-              if item_json["groupType"]
-                type, _dimension = item_json["groupType"].split(":")
-                klass = ::OpenHAB::DSL::Items.const_get(:"#{type}Item")
-                base_item = klass.new(item_json["name"])
-              end
+              base_item = item_factory.create_item(item_json["groupType"], name) if item_json["groupType"]
               if item_json["function"]
                 dto = org.openhab.core.items.dto.GroupFunctionDTO.new
                 dto.name = item_json.dig("function", "name")
                 dto.params = item_json.dig("function", "params")
                 function = gfh.create_group_function(dto, base_item)
               end
-              item = GroupItem.new(item_json["name"], base_item, function)
+              item = GroupItem.new(name, base_item, function)
             else
-              klass = ::OpenHAB::DSL::Items.const_get(:"#{type}Item")
-              item = klass.new(item_json["name"])
+              item = item_factory.create_item(full_type, name)
             end
 
             item.label = item_json["label"]
@@ -36,6 +35,8 @@ module RSpec
             item_json["metadata"]&.each do |key, config|
               item.meta[key] = config["value"], config["config"]
             end
+            item.meta["stateDescription"] = item_json["stateDescription"] if item_json["stateDescription"]
+            item.category = item_json["category"] if item_json["category"]
 
             $ir.add(item)
           end
@@ -48,30 +49,6 @@ module RSpec
           end
         end
       end
-
-      def autoupdate_all_items
-        @autoupdated_items ||= {}
-        $ir.for_each do |_provider, item|
-          @autoupdated_items[item] = item.meta.delete("autoupdate") if item.meta.key?("autoupdate")
-        end
-      end
-
-      private
-
-      def restore_autoupdate_items
-        return unless instance_variable_defined?(:@autoupdated_items)
-
-        @autoupdated_items.each do |(item, meta)|
-          item.meta["autoupdate"] = meta
-        end
-      end
-
-      ::RSpec.configure do |config|
-        config.include(self)
-        config.after do
-          restore_autoupdate_items
-        end
-      end
     end
   end
 end

data/lib/rspec/openhab/suspend_rules.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RSpec
+  module OpenHAB
+    module SuspendRules
+      # I'd prefer to prepend a module, but I can't because of
+      # https://github.com/jruby/jruby/issues/6966#issuecomment-1172983776
+      class ::OpenHAB::DSL::Rules::AutomationRule # rubocop:disable Style/ClassAndModuleChildren
+        def execute(mod = nil, inputs = nil)
+          if SuspendRules.suspended?
+            logger.debug("Skipping execution of #{name} because rules are suspended.")
+            return
+          end
+
+          # super
+          ::OpenHAB::DSL.import_presets
+          thread_local(RULE_NAME: name) do
+            logger.trace { "Execute called with mod (#{mod&.to_string}) and inputs (#{inputs.inspect})" }
+            logger.trace { "Event details #{inputs["event"].inspect}" } if inputs&.key?("event")
+            trigger_conditions(inputs).process(mod: mod, inputs: inputs) do
+              process_queue(create_queue(inputs), mod, inputs)
+            end
+          end
+        end
+      end
+      # private_constant :AutomationRule
+      # ::OpenHAB::DSL::Rules::AutomationRule.prepend(AutomationRule)
+
+      module Timers
+        def after(*)
+          return if SuspendRules.suspended?
+
+          super
+        end
+      end
+      private_constant :Timers
+      ::Object.prepend(Timers)
+
+      @suspended = false
+
+      class << self
+        def suspend_rules
+          old_suspended = @suspended
+          @suspended = true
+          yield
+        ensure
+          @suspended = old_suspended
+        end
+
+        def suspended?
+          @suspended
+        end
+      end
+    end
+  end
+end

data/lib/rspec/openhab/version.rb

@@ -2,6 +2,6 @@
 
 module RSpec
   module OpenHAB
-    VERSION = "0.0.8"
+    VERSION = "0.0.11"
   end
 end

data/lib/rspec-openhab-scripting.rb

@@ -40,6 +40,7 @@ maven_require do
   require "jar org.openhab.core.bundles, org.openhab.core.config.core, #{openhab_version}"
   require "jar org.openhab.core.bundles, org.openhab.core.io.monitor, #{openhab_version}"
   require "jar org.openhab.core.bundles, org.openhab.core.model.core, #{openhab_version}"
+  require "jar org.openhab.core.bundles, org.openhab.core.model.item, #{openhab_version}"
   require "jar org.openhab.core.bundles, org.openhab.core.model.script, #{openhab_version}"
   require "jar org.openhab.core.bundles, org.openhab.core.semantics, #{openhab_version}"
   require "jar org.openhab.core.bundles, org.openhab.core.thing, #{openhab_version}"
@@ -56,8 +57,13 @@ def oh.config_folder
 end
 
 # global variables need to be set up before openhab-scripting loads
+require "timecop"
 require "openhab/log/logger"
 require "rspec/openhab/core/logger"
+
+# during testing, we don't want "regular" output from rules
+OpenHAB::Log.logger("org.openhab.automation.jruby.runtime").level = :warn
+OpenHAB::Log.logger("org.openhab.automation.jruby.logger").level = :warn
 require "openhab/dsl/imports"
 OpenHAB::DSL::Imports.api = api
 OpenHAB::DSL::Imports.import_presets
@@ -67,16 +73,24 @@ require "openhab"
 require "rspec/openhab/actions"
 require "rspec/openhab/core/cron_scheduler"
 
+# override several timer methods
+require_relative "rspec/openhab/dsl/timers/timer"
+
 # RSpec additions
 require "rspec/core"
 require "rspec/openhab/dsl/rules/rspec"
 require "rspec/openhab/items"
-require "rspec/openhab/state"
-require "rspec/openhab/timer"
-require "rspec/openhab/trigger"
-require "rspec/openhab/wait"
+require "rspec/openhab/helpers"
+require "rspec/openhab/hooks"
+require "rspec/openhab/suspend_rules"
 
-RSpec::OpenHAB::Items.populate_items_from_api(api)
+RSpec.configure do |config|
+  config.include OpenHAB::Core::EntityLookup
+end
+
+RSpec::OpenHAB::SuspendRules.suspend_rules do
+  RSpec::OpenHAB::Items.populate_items_from_api(api)
+end
 
 # make bundler/inline _not_ destroy the already existing load path
 module Bundler
@@ -90,7 +104,7 @@ OPENHAB_AUTOMATION_PATH = "#{org.openhab.core.OpenHAB.config_folder}/automation/
 
 Dir["#{OPENHAB_AUTOMATION_PATH}/*.rb"].each do |f|
   load f
-rescue Exception => e # rubocop:disable Lint/RescueException
+rescue Exception => e
   warn "Failed loading #{f}: #{e.inspect}"
   warn e.backtrace
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.11
 platform: java
 authors:
 - Cody Cutrer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-02 00:00:00.000000000 Z
+date: 2022-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.3'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  name: timecop
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -182,12 +196,12 @@ files:
 - lib/rspec/openhab/core/script_handling.rb
 - lib/rspec/openhab/dsl/imports.rb
 - lib/rspec/openhab/dsl/rules/rspec.rb
+- lib/rspec/openhab/dsl/timers/timer.rb
+- lib/rspec/openhab/helpers.rb
+- lib/rspec/openhab/hooks.rb
 - lib/rspec/openhab/items.rb
-- lib/rspec/openhab/state.rb
-- lib/rspec/openhab/timer.rb
-- lib/rspec/openhab/trigger.rb
+- lib/rspec/openhab/suspend_rules.rb
 - lib/rspec/openhab/version.rb
-- lib/rspec/openhab/wait.rb
 - vendor/gems/jar-dependencies-1.0.0/lib/jar-dependencies.rb
 - vendor/gems/jar-dependencies-1.0.0/lib/jar_dependencies.rb
 - vendor/gems/jar-dependencies-1.0.0/lib/jar_install_post_install_hook.rb

data/lib/rspec/openhab/state.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.configure do |config|
-  config.before(:each) do
-    ep = $ir.event_publisher
-
-    # stash event publishers to avoid triggering any rules
-    $ir.for_each do |_provider, item|
-      item.event_publisher = nil
-    end
-
-    $ir.for_each do |_provider, item| # rubocop:disable Style/CombinableLoops
-      item.state = NULL # don't use update, to avoid triggering any rules
-    end
-  ensure
-    $ir.for_each do |_provider, item|
-      item.event_publisher = ep
-    end
-  end
-end

data/lib/rspec/openhab/timer.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.configure do |config|
-  config.before(:each) do
-    OpenHAB::DSL::Timers.timer_manager.cancel_all
-    wait_for_background_tasks
-  end
-  config.after(:each) do
-    OpenHAB::DSL::Timers.timer_manager.cancel_all
-    wait_for_background_tasks
-  end
-end

data/lib/rspec/openhab/trigger.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module RSpec
-  module OpenHAB
-    module Trigger
-      def trigger_rule(rule_name, event = nil)
-        @rules ||= ::OpenHAB::DSL::Rules::Rule.script_rules.each_with_object({}) { |r, obj| obj[r.name] = r }
-
-        @rules.fetch(rule_name).execute(nil, { "event" => event })
-      end
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include RSpec::OpenHAB::Trigger
-end

data/lib/rspec/openhab/wait.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module RSpec
-  module OpenHAB
-    module Wait
-      def wait_for_rules
-        wait_for_background_tasks(timers: false)
-      end
-
-      def wait_for_timers
-        wait_for_background_tasks(rules: false)
-      end
-
-      def wait_for_background_tasks(rules: true, timers: true)
-        loop do
-          sleep 0.1
-          next if java.lang.Thread.all_stack_traces.any? do |(t, stack)|
-            # this is just an estimate. I see 9 when it's parked waiting
-            # for an event, but once it hits ruby it gets real big real quick
-            min_frames = 15
-
-            case t.name
-            when /^OH-scheduler-/
-              # timer thread; born and die for each timer
-              if thread_running?(t) || stack.length > min_frames
-                logger.debug "thread #{t.name} is running (#{stack.length})"
-                stack.each do |frame|
-                  logger.trace "  #{frame}"
-                end
-                next timers
-              end
-            when /^OH-rule-/
-
-              if thread_running?(t) || stack.length > min_frames
-                logger.debug "thread #{t.name} is running (#{stack.length})"
-                stack.each do |frame|
-                  logger.trace "  #{frame}"
-                end
-
-                next rules
-              end
-            when /^OH-(?:eventwatcher|eventexecutor)-/
-              # an event is making its way through the system
-              if thread_running?(t)
-                logger.debug "thread #{t.name} is running"
-                next rules
-              end
-            end
-          end
-
-          # no need to retry if there were no timers
-          break unless timers && wait_for_next_timer
-        end
-      end
-
-      private
-
-      def thread_running?(thread)
-        ![java.lang.Thread::State::WAITING,
-          java.lang.Thread::State::TIMED_WAITING].include?(thread.state)
-      end
-
-      def wait_for_next_timer
-        latest = ::OpenHAB::DSL::Timers.timer_manager.instance_variable_get(:@timers).min_by(&:execution_time)
-        return false unless latest
-
-        delta = (latest.execution_time.to_instant.to_epoch_milli - java.time.Instant.now.to_epoch_milli) / 1000.0
-        # in the past? it's probably executing
-        return true if delta.negative?
-
-        logger.info("Waiting #{delta}s for next timer") if delta > 5
-
-        sleep(delta)
-        true
-      end
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include RSpec::OpenHAB::Wait
-end