rspec-openhab-scripting 0.0.14-java → 0.0.17-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b18cd9bfb33b5ddab9ba78ef3e83f9b5572aebc17ade365599bc9fae9ebd9bc
-  data.tar.gz: fab8152b3c09bcb23ae2af7ce6fb5a8380d97190ce7a3153e156d26d3c405d8e
+  metadata.gz: a5541ba712d1a3fef9112f736b456309acb491aa0cdf075098abe04712a59940
+  data.tar.gz: d75f2b90687529a2bbc63f6d456f639a23360e7636d8ea7c36ed4d2113c7b6d7
 SHA512:
-  metadata.gz: 1cf4905df6306b1a85db73ea49d164d245ce1510c76934bbf74d33e8941227a158ea3bf009b80fb9a2db726a8bf1d5dfd6b2948acc9f622096f39873464b2718
-  data.tar.gz: ffd0784c0995bac8a2188d6a8d5f7617422f441237affc07dc81782a89a54bd14f0de5709946b976fe9fa690a23b1ed8d35ffcb0b77a9d9a13661c5b89e8556e
+  metadata.gz: f576f81ea3fea76dbb173e8aa7ad3d1439f24e518bcd8574597266fe4bc457e325b6ec2f214e9c15a9c6b4c681d7350f7845fe055962f3b1b68214c0433b6b4d
+  data.tar.gz: 394f5a733ed2ddd02bf109f08fb80bbc35f8db5cebb340231a4b9bb17064ba17598ea1dbd90de18e16ff7d6ef52c387db001da6f6a3ae140c44928e71cef48c5

data/lib/rspec/openhab/api.rb

@@ -4,11 +4,12 @@ require "faraday"
 
 module OpenHAB
   class API
-    def initialize(url)
+    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
 
@@ -36,6 +37,22 @@ module OpenHAB
       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

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/mocks/channel_type_provider.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RSpec
+  module OpenHAB
+    module Core
+      module Mocks
+        class ChannelTypeProvider
+          include org.openhab.core.thing.type.ChannelTypeProvider
+          include Singleton
+
+          def initialize
+            @types = {}
+          end
+
+          def add(type)
+            @types[type.uid] = type
+          end
+
+          def get_channel_types(_locale)
+            @types.values
+          end
+
+          def get_channel_type(uid, _locale)
+            @types[uid]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RSpec
+  module OpenHAB
+    module Core
+      module Mocks
+        class ItemChannelLinkProvider
+          include org.openhab.core.thing.link.ItemChannelLinkProvider
+          include Singleton
+
+          def initialize
+            @listeners = []
+            @links = []
+          end
+
+          def add_provider_change_listener(listener)
+            @listeners << listener
+          end
+
+          def remove_provider_change_listener(listener)
+            @listeners.delete(listener)
+          end
+
+          def all
+            @links
+          end
+
+          def add(link)
+            @links << link
+            @listeners.each { |l| l.added(self, link) }
+          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/thing_type_provider.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RSpec
+  module OpenHAB
+    module Core
+      module Mocks
+        class ThingTypeProvider
+          include org.openhab.core.thing.binding.ThingTypeProvider
+          include Singleton
+
+          def initialize
+            @types = {}
+          end
+
+          def add(type)
+            @types[type.uid] = type
+          end
+
+          def get_thing_types(_locale)
+            @types.values
+          end
+
+          def get_thing_type(uid, _locale)
+            @types[uid]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,11 @@ module OpenHAB
   module Core
     class OSGI
       class << self
-        def register_service(name, service)
+        def register_service(name, service = nil)
+          if service.nil?
+            service = name
+            name = service.java_class.interfaces.first&.name || service.java_class.name
+          end
           (@services ||= {})[name] = service
         end
 

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

@@ -68,6 +68,12 @@ module OpenHAB
         def add_bundle_listener(listener); end
       end
 
+      class BundleResolver
+        include org.openhab.core.util.BundleResolver
+
+        def resolve_bundle(klass); end
+      end
+
       # don't depend on org.openhab.core.test
       class VolatileStorageService
         include org.openhab.core.storage.StorageService
@@ -190,7 +196,7 @@ module OpenHAB
           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}")
+                      "registered event factories has thrown an exception: #{e.inspect}")
           nil
         end
 
@@ -201,7 +207,9 @@ module OpenHAB
               begin
                 event_subscriber.receive(event)
               rescue Exception => e
-                logger.warn("Dispatching/filtering event for subscriber '#{event_subscriber.class}' failed: #{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.")
@@ -217,7 +225,7 @@ module OpenHAB
         include Singleton
 
         def submit(runnable)
-          runnable.run
+          runnable.respond_to?(:run) ? runnable.run : runnable.call
 
           java.util.concurrent.CompletableFuture.completed_future(nil)
         end
@@ -233,6 +241,40 @@ module OpenHAB
         end
       end
 
+      class SafeCaller
+        include org.openhab.core.common.SafeCaller
+        include org.openhab.core.common.SafeCallerBuilder
+
+        def create(target, _interface_type)
+          @target = target
+          self
+        end
+
+        def build
+          @target
+        end
+
+        def with_timeout(_timeout)
+          self
+        end
+
+        def with_identifier(_identifier)
+          self
+        end
+
+        def on_exception(_handler)
+          self
+        end
+
+        def on_timeout(_handler)
+          self
+        end
+
+        def with_async
+          self
+        end
+      end
+
       class CallbacksMap < java.util.HashMap
         def put(_rule_uid, trigger_handler)
           trigger_handler.executor.shutdown_now
@@ -275,7 +317,7 @@ module OpenHAB
           # the registries!
           ss = VolatileStorageService.new
           mr = org.openhab.core.internal.items.MetadataRegistryImpl.new
-          OpenHAB::Core::OSGI.register_service("org.openhab.core.items.MetadataRegistry", mr)
+          OpenHAB::Core::OSGI.register_service(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
@@ -286,16 +328,24 @@ module OpenHAB
           ir.event_publisher = ep
           up = org.openhab.core.internal.i18n.I18nProviderImpl.new(cc)
           ir.unit_provider = up
-          ir.item_state_converter = org.openhab.core.internal.items.ItemStateConverterImpl.new(up)
+          ir.item_state_converter = isc = org.openhab.core.internal.items.ItemStateConverterImpl.new(up)
           tr = org.openhab.core.thing.internal.ThingRegistryImpl.new
+          tr.managed_provider = mtp = org.openhab.core.thing.ManagedThingProvider.new(ss)
+          tr.add_provider(mtp)
           mtr = org.openhab.core.automation.internal.type.ModuleTypeRegistryImpl.new
           rr = org.openhab.core.automation.internal.RuleRegistryImpl.new
           rr.module_type_registry = mtr
           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)
+          iclr.add_provider(RSpec::OpenHAB::Core::Mocks::ItemChannelLinkProvider.instance)
+          OpenHAB::Core::OSGI.register_service(iclr)
           ctr = org.openhab.core.thing.type.ChannelTypeRegistry.new
+          OpenHAB::Core::OSGI.register_service(ctr)
+          ctr.add_channel_type_provider(RSpec::OpenHAB::Core::Mocks::ChannelTypeProvider.instance)
           ttr = org.openhab.core.thing.type.ThingTypeRegistry.new(ctr)
+          OpenHAB::Core::OSGI.register_service(ttr)
+          ttr.add_thing_type_provider(RSpec::OpenHAB::Core::Mocks::ThingTypeProvider.instance)
 
           safe_emf = org.openhab.core.model.core.internal.SafeEMFImpl.new
           model_repository = org.openhab.core.model.core.internal.ModelRepositoryImpl.new(safe_emf)
@@ -362,9 +412,12 @@ module OpenHAB
           iu = org.openhab.core.internal.items.ItemUpdater.new(ir)
           ief = org.openhab.core.items.events.ItemEventFactory.new
 
-          sc = org.openhab.core.internal.common.SafeCallerImpl.new({})
-          aum = org.openhab.core.thing.internal.AutoUpdateManager.new({ "enabled" => "true" }, nil, ep, iclr, mr, tr)
-          cm = org.openhab.core.thing.internal.CommunicationManager.new(aum, nil, nil, iclr, ir, nil, ep, sc, tr)
+          sc = SafeCaller.new
+          aum = org.openhab.core.thing.internal.AutoUpdateManager.new(
+            { "enabled" => true, "sendOptimisticUpdates" => true }, ctr, ep, iclr, mr, tr
+          )
+          spf = org.openhab.core.thing.internal.profiles.SystemProfileFactory.new(ctr, nil, BundleResolver.new)
+          cm = org.openhab.core.thing.internal.CommunicationManager.new(aum, ctr, spf, iclr, ir, isc, ep, sc, tr)
 
           em.add_event_subscriber(iu)
           em.add_event_subscriber(cm)
@@ -400,6 +453,17 @@ module OpenHAB
           el = org.openhab.core.io.monitor.internal.EventLogger.new(rs)
           em.add_event_subscriber(el)
           el.on_ready_marker_added(nil)
+
+          # set up persistence
+          psr = org.openhab.core.persistence.internal.PersistenceServiceRegistryImpl.new
+          org.openhab.core.persistence.extensions.PersistenceExtensions.new(psr)
+          psr.activate("default" => "default")
+          ps = RSpec::OpenHAB::Core::Mocks::PersistenceService.instance
+          psr.add_persistence_service(ps)
+
+          pm = org.openhab.core.persistence.internal.PersistenceManagerImpl.new(nil, ir, sc, rs)
+          pm.add_persistence_service(ps)
+          pm.on_ready_marker_added(nil)
         end
       end
     end

data/lib/rspec/openhab/hooks.rb

@@ -10,9 +10,11 @@ RSpec.configure do |config|
       end
     end
   end
+
   config.after do
     OpenHAB::DSL::Timers.timer_manager.cancel_all
     Timecop.return
     restore_autoupdate_items
+    RSpec::OpenHAB::Core::Mocks::PersistenceService.instance.reset
   end
 end

data/lib/rspec/openhab/items.rb

@@ -3,6 +3,18 @@
 module RSpec
   module OpenHAB
     module Items
+      class ThingHandler
+        include org.openhab.core.thing.binding.ThingHandler
+
+        attr_reader :thing
+
+        def initialize(thing)
+          @thing = thing
+        end
+
+        def handle_command(channel, command); end
+      end
+
       class << self
         def populate_items_from_api(api)
           all_items = api.items
@@ -39,6 +51,15 @@ module RSpec
             item.category = item_json["category"] if item_json["category"]
 
             $ir.add(item)
+
+            next unless item.meta["channel"]&.value
+
+            channel_uid = org.openhab.core.thing.ChannelUID.new(item.meta["channel"].value)
+            channel = $things.get_channel(channel_uid)
+            next unless channel
+
+            link = org.openhab.core.thing.link.ItemChannelLink.new(item.name, channel_uid)
+            Core::Mocks::ItemChannelLinkProvider.instance.add(link)
           end
           all_items.each do |item_json| # rubocop:disable Style/CombinableLoops
             item_json["groupNames"].each do |group_name|
@@ -48,6 +69,170 @@ module RSpec
             end
           end
         end
+
+        def populate_things_from_api(api)
+          populate_channel_types_from_api(api)
+          populate_thing_types_from_api(api)
+
+          thing_type_registry = ::OpenHAB::Core::OSGI.service("org.openhab.core.thing.type.ThingTypeRegistry")
+
+          api.things.each do |thing_json|
+            uid = org.openhab.core.thing.ThingUID.new(thing_json["UID"])
+            type_uid = org.openhab.core.thing.ThingTypeUID.new(thing_json["thingTypeUID"])
+            bridge_uid = org.openhab.core.thing.ThingUID.new(thing_json["bridgeUID"]) if thing_json["bridgeUID"]
+
+            type = thing_type_registry.get_thing_type(type_uid)
+            klass = if type.is_a?(org.openhab.core.thing.type.BridgeType)
+                      org.openhab.core.thing.binding.builder.BridgeBuilder
+                    else
+                      org.openhab.core.thing.binding.builder.ThingBuilder
+                    end
+            builder = klass.create(type_uid, uid)
+            builder.with_bridge(bridge_uid) if bridge_uid
+
+            thing_json.each do |(k, v)|
+              case k
+              when "UID", "thingTypeUID", "bridgeUID", "statusInfo", "editable"
+                nil
+              when "channels"
+                builder.with_channels(v.map { |c| build_channel(c) })
+              when "configuration"
+                builder.with_configuration(org.openhab.core.config.core.Configuration.new(v))
+              else
+                builder.send(:"with_#{k}", v)
+              end
+            end
+
+            thing = builder.build
+            # pretend everything is online so that AutoUpdateManager won't reject updates
+            # to items linked to offline channels
+            thing.status_info = org.openhab.core.thing.binding.builder.ThingStatusInfoBuilder
+                                   .create(org.openhab.core.thing.ThingStatus::ONLINE).build
+            handler = ThingHandler.new(thing)
+            thing.handler = handler
+            $things.add(thing)
+          end
+        end
+
+        private
+
+        def populate_channel_types_from_api(api)
+          api.channel_types.each do |ct_json|
+            uid = org.openhab.core.thing.type.ChannelTypeUID.new(ct_json["UID"])
+            builder = case ct_json["kind"]
+                      when "STATE"
+                        org.openhab.core.thing.type.ChannelTypeBuilder.state(uid, ct_json["label"], ct_json["itemType"])
+                      when "TRIGGER"
+                        org.openhab.core.thing.type.ChannelTypeBuilder.trigger(uid, ct_json["label"])
+                      else
+                        raise ArgumentError, "Unrecognized channel type kind #{ct_json["kind"]} for #{uid}"
+                      end
+
+            ct_json.each do |(k, v)|
+              case k
+              when "parameters", "parameterGroups", "label", "kind", "UID", "itemType"
+                nil
+              when "commandDescription"
+                builder.with_command_description(build_command_description(v))
+              when "stateDescription"
+                builder.with_state_description_fragment(build_state_description_fragment(v))
+              when "advanced"
+                builder.is_advanced(v)
+              else
+                builder.send(:"with_#{k}", v)
+              end
+            end
+
+            ct = builder.build
+            Core::Mocks::ChannelTypeProvider.instance.add(ct)
+          end
+        end
+
+        def build_command_description(json)
+          org.openhab.core.types.CommandDescriptionBuilder.create
+             .with_command_options(json["commandOptions"].map do |o|
+                                     org.openhab.core.types.CommandOption.new(o["command"], o["label"])
+                                   end)
+             .build
+        end
+
+        def build_state_description_fragment(json)
+          org.openhab.core.types.StateDescriptionFragmentBuilder.create
+             .with_minimum(json["minimum"]&.to_d)
+             .with_maximum(json["maximum"]&.to_d)
+             .with_step(json["step"&.to_d])
+             .with_pattern(json["pattern"])
+             .with_read_only(json["readOnly"])
+             .with_options(json["options"].map { |o| org.openhab.core.types.StateOption.new(o["value"], o["label"]) })
+             .build
+        end
+
+        def populate_thing_types_from_api(api)
+          api.thing_types.each do |tt_json|
+            uid = org.openhab.core.thing.ThingTypeUID.new(tt_json["UID"])
+            builder = org.openhab.core.thing.type.ThingTypeBuilder.instance(uid, tt_json["label"])
+            tt_json.each do |(k, v)|
+              case k
+              when "UID", "label", "bridge"
+                nil
+              when "listed"
+                builder.is_listed(v)
+              when "channels"
+                builder.with_channels(v.map { |c| build_channel_definition(c) })
+              when "channelGroups"
+                builder.with_channel_groups(v.map { |cg| build_channel_group_definition(cg) })
+              else
+                builder.send(:"with#{k[0].upcase}#{k[1..]}", v)
+              end
+            end
+
+            tt = tt_json["bridge"] ? builder.build_bridge : builder.build
+            Core::Mocks::ThingTypeProvider.instance.add(tt)
+          end
+        end
+
+        def build_channel_definition(json)
+          org.openhab.core.thing.type.ChannelDefinition.new(
+            json["uid"],
+            org.openhab.core.thing.type.ChannelTypeUID.new(json["typeUID"]),
+            json["description"],
+            json["properties"],
+            nil
+          )
+        end
+
+        def build_channel_group_definition(json)
+          org.openhab.core.thing.type.ChannelGroupDefinition.new(
+            json["uid"],
+            org.openhab.core.thing.type.ChannelGroupTypeUID.new(json["typeUID"]),
+            json["label"],
+            json["description"]
+          )
+        end
+
+        def build_channel(json)
+          uid = org.openhab.core.thing.ChannelUID.new(json["uid"])
+          builder = org.openhab.core.thing.binding.builder.ChannelBuilder.create(uid)
+
+          json.each do |(k, v)|
+            case k
+            when "uid", "id", "linkedItems", "itemType"
+              nil
+            when "channelTypeUID"
+              builder.with_type(org.openhab.core.thing.type.ChannelTypeUID.new((v)))
+            when "configuration"
+              builder.with_configuration(org.openhab.core.config.core.Configuration.new(v))
+            when "kind"
+              builder.with_kind(org.openhab.core.thing.type.ChannelKind.const_get(v, false))
+            when "defaultTags"
+              builder.with_default_tags(v.to_set)
+            else
+              builder.send("with_#{k}", v)
+            end
+          end
+
+          builder.build
+        end
       end
     end
   end

data/lib/rspec/openhab/version.rb

@@ -2,6 +2,6 @@
 
 module RSpec
   module OpenHAB
-    VERSION = "0.0.14"
+    VERSION = "0.0.17"
   end
 end

data/lib/rspec-openhab-scripting.rb

@@ -5,7 +5,8 @@
 $LOAD_PATH.unshift(File.expand_path("../vendor/gems/jar-dependencies-1.0.0/lib", __dir__))
 
 require "rspec/openhab/api"
-api = OpenHAB::API.new("http://#{ENV.fetch("OPENHAB_HOST", "localhost")}:#{ENV.fetch("OPENHAB_HTTP_PORT", "8080")}/")
+api = OpenHAB::API.new("http://#{ENV.fetch("OPENHAB_HOST", "localhost")}:#{ENV.fetch("OPENHAB_HTTP_PORT", "8080")}/",
+                       ENV.fetch("OPENHAB_TOKEN", nil))
 
 module OpenHAB
   module Core
@@ -42,9 +43,11 @@ maven_require do
   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.persistence, #{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}"
 end
+java_import org.openhab.core.persistence.extensions.PersistenceExtensions
 
 require "openhab/version"
 
@@ -64,6 +67,10 @@ 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 "rspec/openhab/core/mocks/channel_type_provider"
+require "rspec/openhab/core/mocks/item_channel_link_provider"
+require "rspec/openhab/core/mocks/persistence_service"
+require "rspec/openhab/core/mocks/thing_type_provider"
 require "openhab/dsl/imports"
 OpenHAB::DSL::Imports.api = api
 OpenHAB::DSL::Imports.import_presets
@@ -73,7 +80,8 @@ require "openhab"
 require "rspec/openhab/actions"
 require "rspec/openhab/core/cron_scheduler"
 
-# override several timer methods
+# override several openhab-scripting methods
+require_relative "rspec/openhab/core/item_proxy"
 require_relative "rspec/openhab/dsl/timers/timer"
 require_relative "rspec/openhab/dsl/rules/triggers/watch"
 
@@ -89,6 +97,7 @@ RSpec.configure do |config|
 end
 
 RSpec::OpenHAB::SuspendRules.suspend_rules do
+  RSpec::OpenHAB::Items.populate_things_from_api(api) if api.authenticated?
   RSpec::OpenHAB::Items.populate_items_from_api(api)
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.17
 platform: java
 authors:
 - Cody Cutrer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-04 00:00:00.000000000 Z
+date: 2022-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -189,8 +189,13 @@ files:
 - lib/rspec/openhab/actions.rb
 - lib/rspec/openhab/api.rb
 - lib/rspec/openhab/core/cron_scheduler.rb
+- lib/rspec/openhab/core/item_proxy.rb
 - lib/rspec/openhab/core/load_path.rb
 - lib/rspec/openhab/core/logger.rb
+- lib/rspec/openhab/core/mocks/channel_type_provider.rb
+- lib/rspec/openhab/core/mocks/item_channel_link_provider.rb
+- lib/rspec/openhab/core/mocks/persistence_service.rb
+- lib/rspec/openhab/core/mocks/thing_type_provider.rb
 - lib/rspec/openhab/core/openhab_setup.rb
 - lib/rspec/openhab/core/osgi.rb
 - lib/rspec/openhab/core/script_handling.rb
@@ -235,7 +240,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -243,7 +248,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements:
 - jar ch.qos.logback, logback-classic, 1.2.9
-rubygems_version: 3.3.17
+rubygems_version: 3.2.29
 signing_key:
 specification_version: 4
 summary: Library testing OpenHAB ruby rules with rspec.