rspec-openhab-scripting 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1f9f1f804d263fe2179ef5680704f14bc2ba476dc4525f014329aa30ea6e01d0
+  data.tar.gz: 924e7e3a2cc0f2578ff526d21a9a4050e216c7555004ebf21a7a76eca62a5e9c
+SHA512:
+  metadata.gz: 292ebc4f0386a670ee9b02528e13880e9c9801c397ada5bc83cc9193ff5728f056a27b6b780f6b5b8b789970da03fec6fa63fe6bc3420140ceaedba06f909e9e
+  data.tar.gz: b8c0d8e5619c50499189bfc1b85fa496d76549c03bbb23cae531e61afbac87a16b9f2d37cf4b6cb5518a55a5557570a248a0525ad4be66a84bcdb84a03b96bbf

data/lib/rspec/openhab/actions.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module Actions
+      # redefine these to do nothing so that rules won't fail
+      def notify(msg, email: nil) # rubocop:disable Lint/UnusedMethodArgument:
+        logger.debug("notify: #{msg}")
+      end
+
+      def say(text, voice: nil, sink: nil, volume: nil) # rubocop:disable Lint/UnusedMethodArgument:
+        logger.debug("say: #{text}")
+      end
+
+      def play_sound(filename, sink: nil, volume: nil) # rubocop:disable Lint/UnusedMethodArgument:
+        logger.debug("play_sound: #{filename}")
+      end
+    end
+  end
+end

data/lib/rspec/openhab/api.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "faraday"
+
+module OpenHAB
+  class API
+    def initialize(url, token = nil)
+      @faraday = Faraday.new(url) do |f|
+        f.response :raise_error
+        f.response :json
+        f.path_prefix = "/rest/"
+        f.headers = { "X-OPENHAB-TOKEN" => token } if token
+      end
+    end
+
+    def version
+      version = root_data.dig("runtimeInfo", "version")
+      version = "#{version}-SNAPSHOT" if root_data.dig("runtimeInfo", "buildString")&.start_with?("Build #")
+      version
+    end
+
+    def locale
+      root_data["locale"]
+    end
+
+    def measurement_system
+      root_data["measurementSystem"]
+    end
+
+    def items
+      @faraday.get("items", metadata: ".*").body
+    end
+
+    def item(name)
+      @faraday.get("items/#{name}").body
+    rescue Faraday::ResourceNotFound
+      nil
+    end
+
+    def channel_types
+      @faraday.get("channel-types").body
+    end
+
+    def thing_types
+      @faraday.get("thing-types").body
+    end
+
+    def things
+      @faraday.get("things").body
+    end
+
+    def authenticated?
+      @faraday.headers.key?("X-OPENHAB-TOKEN")
+    end
+
+    private
+
+    def root_data
+      @root_data ||= @faraday.get.body
+    end
+  end
+end

data/lib/rspec/openhab/core/item_proxy.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    class ItemProxy
+      @proxies = {}
+
+      class << self
+        # ensure each item only has a single proxy, so that
+        # expect(item).to receive(:method) works
+        def new(item)
+          @proxies.fetch(item.name) do
+            @proxies[item.name] = super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/openhab/core/logger.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    class Logger
+      class << self
+        def log_service
+          @log_service = OSGI.service("org.apache.karaf.log.core.LogService")
+        end
+      end
+
+      def name
+        @sl4fj_logger.name
+      end
+
+      def level
+        self.class.log_service.get_level(name)[name]&.downcase&.to_sym
+      end
+
+      def level=(level)
+        self.class.log_service.set_level(name, level.to_s)
+      end
+    end
+  end
+
+  module Log
+    class << self
+      def root
+        logger(org.slf4j.Logger::ROOT_LOGGER_NAME)
+      end
+
+      def events
+        logger("openhab.event")
+      end
+
+      def logger(object)
+        logger_name = object if object.is_a?(String)
+        logger_name ||= logger_name(object)
+        @loggers[logger_name] ||= Core::Logger.new(logger_name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module RSpec
+  module OpenHAB
+    module Core
+      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
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module RSpec
+  module OpenHAB
+    module Core
+      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
+end

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module RSpec
+  module OpenHAB
+    module Core
+      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 = ::OpenHAB::Core::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
+end

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module RSpec
+  module OpenHAB
+    module Core
+      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! { |hi| hi.timestamp.to_instant.to_epoch_milli } unless filter.item_name
+
+            unless filter.page_number.zero?
+              result = result.slice(filter.page_number * filter.page_size, filter.page_size)
+            end
+
+            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
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module RSpec
+  module OpenHAB
+    module Core
+      module Mocks
+        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 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
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+# rubocop:disable Naming have to follow java interface names
+module RSpec
+  module OpenHAB
+    module Core
+      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
+end
+# rubocop:enable Naming

data/lib/rspec/openhab/core/openhab_setup.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "openhab/core/services"
+
+module OpenHAB
+  module Core
+    class << self
+      def wait_till_openhab_ready; end
+    end
+  end
+end

data/lib/rspec/openhab/dsl/rules/triggers/watch.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module Rules
+      module Triggers
+        def watch(path, glob: "*", for: %i[created deleted modified], attach: nil); end
+      end
+    end
+  end
+end