openhab-scripting 4.47.0 → 5.0.0

data/lib/openhab/rspec/mocks/bundle_install_support.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module OpenHAB
+  module RSpec
+    # @!visibility private
+    module Mocks
+      class BundleInstallSupport < SimpleDelegator
+        include org.apache.karaf.features.internal.service.BundleInstallSupport
+
+        def initialize(parent, karaf_wrapper)
+          super(parent)
+          @karaf_wrapper = karaf_wrapper
+        end
+
+        def set_bundle_start_level(bundle, _start_level)
+          return if @karaf_wrapper.send(:blocked_bundle?, bundle)
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/openhab/rspec/mocks/bundle_resolver.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module OpenHAB
+  module RSpec
+    module Mocks
+      class BundleResolver
+        include org.openhab.core.util.BundleResolver
+        include Singleton
+
+        def initialize
+          @classes = {}
+        end
+
+        def register_class(klass, bundle)
+          # ensure we have an individual java class already
+          @classes[klass.become_java!] = bundle
+        end
+
+        def resolve_bundle(clazz)
+          bundle = @classes[clazz]
+          return bundle if bundle
+
+          org.osgi.framework.FrameworkUtil.get_bundle(clazz)
+        end
+      end
+    end
+  end
+end

data/lib/openhab/rspec/mocks/event_admin.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module OpenHAB
+  module RSpec
+    module Mocks
+      # reimplement to not use a thread
+      class OSGiEventManager
+        attr_reader :logger
+
+        def initialize(typed_event_factories, typed_event_subscribers)
+          @typed_event_factories = typed_event_factories
+          @typed_event_subscribers = typed_event_subscribers
+          @logger = org.slf4j.LoggerFactory.get_logger("rspec.openhab.core.mocks.event_handler")
+        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: #{osgi_event.property_names.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.inspect}")
+          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.inspect}"
+                )
+              end
+            else
+              logger.trace("Skip event subscriber (#{event_subscriber.class}) because of its filter.")
+            end
+          end
+        end
+      end
+
+      class EventAdmin < org.osgi.util.tracker.ServiceTracker
+        include org.osgi.service.event.EventAdmin
+
+        def initialize(bundle_context)
+          super(bundle_context, "org.osgi.service.event.EventHandler", nil)
+
+          @handlers_matching_all_events = []
+          @handlers_matching_topics = Hash.new { |h, k| h[k] = [] }
+          open
+        end
+
+        def addingService(reference) # rubocop:disable Naming/MethodName
+          topics = Array(reference.get_property(org.osgi.service.event.EventConstants::EVENT_TOPIC))
+          topics = nil if topics.empty? || topics.include?("*")
+
+          service = OSGi.send(:bundle_context).get_service(reference)
+
+          if reference.get_property("component.name") == "org.openhab.core.internal.events.OSGiEventManager"
+            # OSGiEventManager will create a ThreadedEventHandler on OSGi activation;
+            # we're skipping that, and directly sending to a non-threaded event handler.
+            service.class.field_reader :typedEventFactories, :typedEventSubscribers
+            service = OSGiEventManager.new(service.typedEventFactories, service.typedEventSubscribers)
+          end
+          if topics.nil?
+            @handlers_matching_all_events << service
+          else
+            topics.each do |topic|
+              @handlers_matching_topics[topic] << service
+            end
+          end
+          service
+        end
+
+        def postEvent(event) # rubocop:disable Naming/MethodName
+          sendEvent(event)
+        end
+
+        def sendEvent(event) # rubocop:disable Naming/MethodName
+          # prevent re-entrancy
+          if (pending_events = Thread.current[:event_admin_pending_events])
+            pending_events << event
+            return
+          end
+
+          pending_events = Thread.current[:event_admin_pending_events] = []
+          handle_event(event)
+          handle_event(pending_events.shift) until pending_events.empty?
+          Thread.current[:event_admin_pending_events] = nil
+        end
+
+        private
+
+        def handle_event(event)
+          @handlers_matching_all_events.each { |h| h.handle_event(event) }
+          @handlers_matching_topics[event.topic].each { |h| h.handle_event(event) }
+        end
+      end
+    end
+  end
+end

data/lib/openhab/rspec/mocks/instance_method_stasher.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module RSpec
+    module Mocks
+      module InstanceMethodStasher
+        ::RSpec::Mocks::InstanceMethodStasher.prepend(self)
+
+        # Disable "singleton on non-persistent Java type"
+        # it doesn't matter during specs
+        def initialize(*)
+          original_verbose = $VERBOSE
+          $VERBOSE = nil
+
+          super
+        ensure
+          $VERBOSE = original_verbose
+        end
+      end
+    end
+  end
+end

data/lib/openhab/rspec/mocks/persistence_service.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module RSpec
+    module Mocks
+      class PersistenceService
+        include org.openhab.core.persistence.ModifiablePersistenceService
+        include Singleton
+
+        class HistoricItem
+          include org.openhab.core.persistence.HistoricItem
+
+          attr_reader :timestamp, :state, :name
+
+          def initialize(timestamp, state, name)
+            @timestamp = timestamp
+            @state = state
+            @name = name
+          end
+        end
+
+        module HistoricState
+          def timestamp
+            # PersistenceExtensions uses an anonymous class to wrap the current
+            # state if that happens to be an answer. Except it calls
+            # ZonedDateTime.now in Java land, bypassing Timecop.
+            # Detect that and make the call in Ruby
+            #
+            jc = @historic_item.class.java_class
+            return ZonedDateTime.now if jc.anonymous? && jc.enclosing_class == PersistenceExtensions.java_class
+
+            super
+          end
+        end
+        Core::Items::Persistence::HistoricState.prepend(HistoricState)
+
+        attr_reader :id
+
+        def initialize
+          @id = "default"
+          reset
+        end
+
+        def reset
+          @data = Hash.new { |h, k| h[k] = [] }
+        end
+
+        def store(item, date = nil, state = nil)
+          date = nil if date.is_a?(String) # alias overload
+          state ||= item.state
+          date ||= ZonedDateTime.now
+
+          new_item = HistoricItem.new(date, state, item.name)
+
+          item_history = @data[item.name]
+
+          insert_index = item_history.bsearch_index do |i|
+            i.timestamp.compare_to(date).positive?
+          end
+
+          return item_history << new_item unless insert_index
+
+          return item_history[insert_index].state = state if item_history[insert_index].timestamp == date
+
+          item_history.insert(insert_index, new_item)
+        end
+
+        def remove(filter)
+          query_internal(filter) do |item_history, index|
+            historic_item = item_history.delete_at(index)
+            @data.delete(historic_item.name) if item_history.empty?
+          end
+        end
+
+        def query(filter)
+          result = []
+
+          query_internal(filter) do |item_history, index|
+            result << item_history[index]
+
+            return result if filter.page_number.zero? && result.length == filter.page_size && filter.item_name
+          end
+
+          result.sort_by!(&:timestamp) unless filter.item_name
+
+          result = result.slice(filter.page_number * filter.page_size, filter.page_size) unless filter.page_number.zero?
+
+          result
+        end
+
+        def get_item_info # rubocop:disable Naming/AccessorMethodName must match Java interface
+          @data.to_set do |(n, entries)|
+            [n, entries.length, entries.first.timestamp, entries.last.timestamp]
+          end
+        end
+
+        def get_default_strategies # rubocop:disable Naming/AccessorMethodName must match Java interface
+          [org.openhab.core.persistence.strategy.PersistenceStrategy::Globals::CHANGE]
+        end
+
+        private
+
+        def query_internal(filter, &block)
+          if filter.item_name
+            return unless @data.key?(filter.item_name)
+
+            query_item_internal(@data[filter.item_name], filter, &block)
+          else
+            @data.each_value do |item_history|
+              query_item_internal(item_history, filter, &block)
+            end
+          end
+        end
+
+        def query_item_internal(item_history, filter)
+          first_index = 0
+          last_index = item_history.length
+
+          if filter.begin_date
+            first_index = item_history.bsearch_index do |i|
+              i.timestamp.compare_to(filter.begin_date).positive?
+            end
+            return if first_index.nil?
+          end
+
+          if filter.end_date
+            last_index = item_history.bsearch_index do |i|
+              i.timestamp.compare_to(filter.end_date).positive?
+            end
+            return if last_index.zero?
+
+            last_index ||= item_history.length
+          end
+
+          range = first_index...last_index
+
+          operator = filter.operator.symbol
+          operator = "==" if operator == "="
+
+          block = lambda do |i|
+            next if filter.state && !item_history[i].state.send(operator, filter.state)
+
+            yield(item_history, i)
+          end
+
+          if filter.ordering == filter.class::Ordering::DESCENDING
+            range.reverse_each(&block)
+          else
+            range.each(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openhab/rspec/mocks/safe_caller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module OpenHAB
+  module RSpec
+    module Mocks
+      class SafeCaller
+        include Singleton
+        include org.openhab.core.common.SafeCaller
+
+        class Builder
+          include org.openhab.core.common.SafeCallerBuilder
+
+          def initialize(target)
+            @target = target
+          end
+
+          def build
+            @target
+          end
+
+          def chain(*)
+            self
+          end
+
+          alias_method :withTimeout, :chain
+          alias_method :withIdentifier, :chain
+          alias_method :onException, :chain
+          alias_method :onTimeout, :chain
+          alias_method :withAsync, :chain
+        end
+
+        def create(target, _klass)
+          Builder.new(target)
+        end
+      end
+    end
+  end
+end

data/lib/openhab/rspec/mocks/space.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module RSpec
+    module Mocks
+      module Space
+        ::RSpec::Mocks::Space.prepend(self)
+
+        #
+        # When setting expectations on {Items::Proxy proxies}, set them against the item
+        # themselves, so that it will catch calls against `self` from within the instance.
+        #
+        def proxy_for(object)
+          return super unless ::RSpec.current_example&.example_group&.consistent_proxies?
+
+          object = object.__getobj__ if object.is_a?(Core::Items::Proxy)
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/openhab/rspec/mocks/synchronous_executor.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module OpenHAB
+  module RSpec
+    module Mocks
+      class CallbacksMap < java.util.HashMap
+        def put(_rule_uid, trigger_handler)
+          if trigger_handler.executor
+            trigger_handler.executor.shutdown_now
+            trigger_handler.executor = SynchronousExecutor.instance
+          end
+          super
+        end
+      end
+
+      class SynchronousExecutor < java.util.concurrent.ScheduledThreadPoolExecutor
+        include Singleton
+
+        attr_accessor :main_thread
+
+        def initialize
+          super(1)
+        end
+
+        def submit(runnable)
+          return super unless Thread.current == main_thread
+
+          runnable.respond_to?(:run) ? runnable.run : runnable.call
+
+          java.util.concurrent.CompletableFuture.completed_future(nil)
+        end
+
+        def execute(runnable)
+          return super unless Thread.current == main_thread
+
+          runnable.run
+        end
+
+        def shutdown; end
+
+        def shutdown_now
+          []
+        end
+        alias_method :shutdownNow, :shutdown_now
+      end
+
+      class SynchronousExecutorMap
+        include java.util.Map
+        include Singleton
+
+        def get(_key)
+          SynchronousExecutor.instance
+        end
+
+        def key_set
+          java.util.HashSet.new
+        end
+      end
+    end
+  end
+end

data/lib/openhab/rspec/mocks/thing_handler.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# rubocop:disable Naming/MethodName, Naming/AccessorMethodName
+
+require "singleton"
+
+module OpenHAB
+  module RSpec
+    module Mocks
+      class ThingHandler
+        include org.openhab.core.thing.binding.BridgeHandler
+
+        attr_reader :thing, :callback
+
+        def initialize(thing = nil)
+          # have to handle the interface method
+          if thing.nil?
+            status_info = org.openhab.core.thing.binding.builder.ThingStatusInfoBuilder
+                             .create(org.openhab.core.thing.ThingStatus::ONLINE).build
+            @callback.status_updated(self.thing, status_info)
+            return
+          end
+
+          # ruby initializer here
+          @thing = thing
+        end
+
+        def thing_updated(thing)
+          @thing = thing
+        end
+
+        def handle_command(channel, command); end
+
+        def set_callback(callback)
+          @callback = callback
+        end
+
+        def child_handler_initialized(child_handler, child_thing); end
+        def child_handler_disposed(child_handler, child_thing); end
+
+        def channel_linked(_channel_uid); end
+        def channel_unlinked(_channel_uid); end
+
+        def dispose; end
+      end
+
+      class ThingHandlerFactory < org.openhab.core.thing.binding.BaseThingHandlerFactory
+        include Singleton
+
+        class ComponentContext
+          include org.osgi.service.component.ComponentContext
+          include Singleton
+
+          def getBundleContext
+            org.osgi.framework.FrameworkUtil.get_bundle(org.openhab.core.thing.Thing.java_class).bundle_context
+          end
+        end
+        private_constant :ComponentContext
+
+        def initialize
+          super
+          activate(ComponentContext.instance)
+        end
+
+        def supportsThingType(_type)
+          true
+        end
+
+        def createHandler(thing)
+          ThingHandler.new(thing)
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Naming/MethodName, Naming/AccessorMethodName