openhab-jrubyscripting 5.0.0.rc1

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/metadata_provider.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module RSpec
+    module Mocks
+      class MetadataProvider
+        org.openhab.core.common.registry.Identifiable
+        include org.openhab.core.items.ManagedMetadataProvider
+
+        def initialize(parent)
+          @metadata = {}
+          @listeners = []
+          @parent = parent
+          @removed_from_parent = []
+        end
+
+        def addProviderChangeListener(listener) # rubocop:disable Naming/MethodName required by java interface
+          @listeners << listener
+        end
+
+        def removeProviderChangeListener(listener) # rubocop:disable Naming/MethodName required by java interface
+          old = @listeners.delete(listener)
+          return unless old
+
+          @listeners.each { |l| l.removed(self, old) }
+        end
+
+        def add(metadata)
+          @metadata[metadata.uid] = metadata
+          @listeners.each { |l| l.added(self, metadata) }
+        end
+
+        def update(metadata)
+          old_element = @metadata[metadata.uid]
+          raise ArgumentError if old_element.nil?
+
+          @metadata[metadata.uid] = metadata
+          @listeners.each { |l| l.updated(self, old_element, metadata) }
+          metadata
+        end
+
+        def remove(key)
+          m = @parent.remove(key)
+          @removed_from_parent << m if m
+          m = @metadata.delete(key)
+          @listeners.each { |l| l.removed(self, m) } if m
+          m
+        end
+
+        def restore_parent
+          @removed_from_parent.each do |m|
+            @parent.add(m)
+          end
+        end
+
+        def get(key)
+          @metadata[key]
+        end
+
+        def getAll # rubocop:disable Naming/MethodName required by java interface
+          @metadata.values
+        end
+
+        def removeItemMetadata(item_name) # rubocop:disable Naming/MethodName required by java interface
+          @metadata.delete_if do |k, v|
+            next unless k.item_name == item_name
+
+            @listeners.each { |l| l.removed(self, v) }
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# 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
+
+        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.map do |(n, entries)|
+            [n, entries.length, entries.first.timestamp, entries.last.timestamp]
+          end.to_set
+        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/synchronous_executor.rb

@@ -0,0 +1,56 @@
+# 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
+        class << self
+          def instance
+            @instance ||= new(1)
+          end
+        end
+
+        def submit(runnable)
+          runnable.respond_to?(:run) ? runnable.run : runnable.call
+
+          java.util.concurrent.CompletableFuture.completed_future(nil)
+        end
+
+        def execute(runnable)
+          runnable.run
+        end
+
+        def shutdown; end
+
+        def shutdown_now
+          []
+        end
+      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 have to follow java interface names
+
+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).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

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "timecop"
+
+module OpenHAB
+  module RSpec
+    module Mocks
+      class Timer < Core::Timer
+        # @!visibility private
+        module MockedZonedDateTime
+          def now
+            mocked_time_stack_item = Timecop.top_stack_item
+            return super unless mocked_time_stack_item
+
+            mocked_time_stack_item.time.to_zoned_date_time
+          end
+        end
+        ZonedDateTime.singleton_class.prepend(MockedZonedDateTime)
+
+        # extend Timecop to support Java time classes
+        # @!visibility private
+        module TimeCopStackItem
+          def parse_time(*args)
+            if args.length == 1
+              arg = args.first
+              if arg.is_a?(Time) ||
+                 (defined?(DateTime) && arg.is_a?(DateTime)) ||
+                 (defined?(Date) && arg.is_a?(Date))
+                return super
+              elsif arg.respond_to?(:to_zoned_date_time)
+                return arg.to_zoned_date_time.to_time
+              elsif arg.is_a?(java.time.temporal.TemporalAmount)
+                return (ZonedDateTime.now + arg).to_time
+              end
+            end
+
+            super
+          end
+        end
+        Timecop::TimeStackItem.prepend(TimeCopStackItem)
+
+        attr_reader :execution_time, :id, :block
+
+        def initialize(time, id:, thread_locals:, block:) # rubocop:disable Lint/MissingSuper
+          @time = time
+          @id = id
+          @block = block
+          @thread_locals = thread_locals
+          reschedule(time)
+        end
+
+        def reschedule(time = nil)
+          @execution_time = new_execution_time(time || @time)
+          @executed = false
+
+          DSL::TimerManager.instance.add(self)
+
+          self
+        end
+
+        def execute
+          raise "Timer already cancelled" if cancelled?
+          raise "Timer already executed" if terminated?
+
+          super
+          @executed = true
+        end
+
+        def cancel
+          return false if terminated? || cancelled?
+
+          DSL::TimerManager.instance.delete(self)
+          @execution_time = nil
+          true
+        end
+
+        def cancelled?
+          @execution_time.nil?
+        end
+
+        def terminated?
+          @executed || cancelled?
+        end
+
+        def running?
+          false
+        end
+
+        def active?
+          !terminated?
+        end
+      end
+    end
+  end
+end