rspec-openhab-scripting 0.0.15-java → 0.0.18-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d267863174213b2996edf9c92a8704499fb6e4c5136289fb2d2b2aae1a810bf
-  data.tar.gz: 0cd9ff249e7a045265337bbb8603c0ab7e87d2c7e24145454e08917869202d98
+  metadata.gz: 6ea44768dd3bccdfc7276944f329030e21182d161126e433126970f096543f46
+  data.tar.gz: 81be4550cd3ab271f43e15616959709bb9e5d1cf14a999dd8565e0b148d3a8d7
 SHA512:
-  metadata.gz: 4881e2d5e6cd7149dc15fa518fa6198d189db5177889571db981c204b299b674ac7a8e773fe1b3d14c0c4afeab244ef4653e3c1075a8585188dce465f9acbf5b
-  data.tar.gz: 7d4f79653bf22e61ea06e19f42efc08544cbf4ad3a3ce3226c28dbd9f54df41f4cfdccec2df8dd6bbdbf4bc42d3d05076fb4217e416ea8f0492ce19b2062c92d
+  metadata.gz: 4d70a68375f21fab304d05b620125cf79b5767f3522d5e22a0608301b56e4ed3b2f6baba7942bdfcdb9ffed742378452720b79b7bfc5d7523544087a0bcb15bc
+  data.tar.gz: d2ce66901858dc37eb7c76b5f37f82da6147f1b471b8fc70097037099d677eb01c6e4e25d77e12105847e28156a919e059d5420271f9ce5cfcb0c9af933b4383

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# 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 handle_command(channel, command); end
+
+          def set_callback(callback)
+            @callback = callback
+          end
+
+          def child_handler_initialized(child_handler, child_thing); end
+        end
+
+        class ThingHandlerFactory < org.openhab.core.thing.binding.BaseThingHandlerFactory
+          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/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,22 @@ module OpenHAB
         def add_bundle_listener(listener); end
       end
 
+      class BundleResolver
+        include org.openhab.core.util.BundleResolver
+
+        def initialize
+          @bundles = {}
+        end
+
+        def register(klass, bundle)
+          @bundles[klass] = bundle
+        end
+
+        def resolve_bundle(klass)
+          @bundles[klass]
+        end
+      end
+
       # don't depend on org.openhab.core.test
       class VolatileStorageService
         include org.openhab.core.storage.StorageService
@@ -98,13 +114,15 @@ module OpenHAB
         INSTALLED = 2
 
         def initialize(*jar_args)
+          return if jar_args.empty?
+
           file = Jars.find_jar(*jar_args)
           @jar = java.util.jar.JarFile.new(file)
           @symbolic_name = jar_args[1]
           @version = org.osgi.framework.Version.new(jar_args[2].tr("-", "."))
         end
 
-        attr_reader :symbolic_name, :version
+        attr_accessor :symbolic_name, :version
 
         def state
           INSTALLED
@@ -190,7 +208,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 +219,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 +237,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 +253,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
@@ -271,11 +325,12 @@ module OpenHAB
           bc = BundleContext.new(em)
           cc = ComponentContext.new(bc)
           cc.properties["measurementSystem"] = api.measurement_system if api
+          resolver = BundleResolver.new
 
           # 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 +341,25 @@ 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)
+          cgtr = org.openhab.core.thing.type.ChannelGroupTypeRegistry.new
 
           safe_emf = org.openhab.core.model.core.internal.SafeEMFImpl.new
           model_repository = org.openhab.core.model.core.internal.ModelRepositoryImpl.new(safe_emf)
@@ -360,15 +424,18 @@ module OpenHAB
 
           # link up event bus infrastructure
           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, resolver)
+          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)
-          em.add_event_factory(ief)
+          em.add_event_factory(org.openhab.core.items.events.ItemEventFactory.new)
+          em.add_event_factory(org.openhab.core.thing.events.ThingEventFactory.new)
 
           # set up the rules engine part 2
           k = org.openhab.core.automation.internal.module.factory.CoreModuleHandlerFactory
@@ -400,6 +467,42 @@ 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)
+
+          # set up ThingManager so we can trigger channels
+          localizer = org.openhab.core.thing.i18n.ThingStatusInfoI18nLocalizationService.new
+          tm = org.openhab.core.thing.internal.ThingManagerImpl.new(
+            resolver,
+            cgtr,
+            ctr,
+            cm,
+            nil,
+            nil,
+            ep,
+            iclr,
+            rs,
+            sc,
+            ss,
+            tr,
+            localizer,
+            ttr
+          )
+          thf = RSpec::OpenHAB::Core::Mocks::ThingHandlerFactory.new
+          this_bundle = Bundle.new
+          this_bundle.symbolic_name = "org.openhab.automation.jrubyscripting.rspec"
+          resolver.register(thf.class.java_class, this_bundle)
+          tm.add_thing_handler_factory(thf)
+          tm.on_ready_marker_added(org.openhab.core.service.ReadyMarker.new(nil, this_bundle.symbolic_name))
         end
       end
     end

data/lib/rspec/openhab/helpers.rb

@@ -24,6 +24,13 @@ module RSpec
         @rules.fetch(rule_name).execute(nil, { "event" => event })
       end
 
+      def trigger_channel(channel, event)
+        channel = org.openhab.core.thing.ChannelUID.new(channel) if channel.is_a?(String)
+        channel = channel.uid if channel.is_a?(org.openhab.core.thing.Channel)
+        thing = channel.thing
+        thing.handler.callback.channel_triggered(nil, channel, event)
+      end
+
       private
 
       def restore_autoupdate_items

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

@@ -39,6 +39,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 +57,163 @@ 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
+
+            $things.add(builder.build)
+          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.15"
+    VERSION = "0.0.18"
   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,11 @@ 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_handler"
+require "rspec/openhab/core/mocks/thing_type_provider"
 require "openhab/dsl/imports"
 OpenHAB::DSL::Imports.api = api
 OpenHAB::DSL::Imports.import_presets
@@ -90,6 +98,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.15
+  version: 0.0.18
 platform: java
 authors:
 - Cody Cutrer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-05 00:00:00.000000000 Z
+date: 2022-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -192,6 +192,11 @@ files:
 - 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_handler.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
@@ -236,7 +241,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:
   - - ">="
@@ -244,7 +249,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.