rspec-openhab-scripting 0.0.16-java → 0.0.19-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5dd7ea9915aa3edecf86f75d7331bfe77ad3fbbbee4c278fd130895e4bc1e6c
-  data.tar.gz: 489db2879bf94009c027fcbb87572ae5b3834d31fab17f473cddc2fdecfebdfd
+  metadata.gz: ea386c264164b6c12be46d5483fdd349c3e5fdadcba22bff4987a2db5c6a9803
+  data.tar.gz: 20c364d137e43d5de1a1ab5eda9341318132cbde7532cf9c84901badce83ed49
 SHA512:
-  metadata.gz: 967d33cd26a809179324637df7ebb9243ec901ae6c75aaa97a1615a6f699082bb83050727502c326bcf85732f86521f93ce253877306d8e6cf86b4ed84030708
-  data.tar.gz: 375c3ebb1c64176b3da00a8489b8b9574e5636d767a2cb981100dc3b6b3128cbf23fc8b7ab9998ed3b7154a9d0754be6f349d3711ef326e7714ec360cac89732
+  metadata.gz: 13ae42f75b1bcaa898969e4077cefd1bbbc0979a7a081b7e904db9ff2c0b9550205bef2f4d20e3c502c2d12c449b64886819622101cb4425ee8ce4083cc02ea8
+  data.tar.gz: dd85b3c9249e88031ed3bf297dd09c1e7698cdb6d0958b04b0efbe35117dc6c71043b22f258b49fa0b52bb58a98ff3c3d5e6e492c6f551c393ce5a16187e9f75

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/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,11 +4,17 @@ 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
 
         def service(name)
+          name = name.java_class if name.is_a?(Class)
+          name = name.name if name.is_a?(java.lang.Class)
           @services&.[](name)
         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
@@ -385,6 +452,8 @@ module OpenHAB
 
           rs = org.openhab.core.internal.service.ReadyServiceImpl.new
           re = org.openhab.core.automation.internal.RuleEngineImpl.new(mtr, rr, ss, rs)
+          OpenHAB::Core::OSGI.register_service(re)
+
           # overwrite thCallbacks to one that will spy to remove threading
           field = re.class.java_class.declared_field("thCallbacks")
           field.accessible = true
@@ -411,6 +480,31 @@ module OpenHAB
           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

@@ -1,8 +1,51 @@
 # frozen_string_literal: true
 
+module OpenHAB
+  module Transform
+    class << self
+      def add_script(modules, script)
+        full_name = modules.join("/")
+        name = modules.pop
+        (@scripts ||= {})[full_name] = engine_factory.script_engine.compile(script)
+
+        mod = modules.inject(self) { |m, n| m.const_get(n, false) }
+        mod.singleton_class.define_method(name) do |input, **kwargs|
+          Transform.send(:transform, full_name, input, kwargs)
+        end
+      end
+
+      private
+
+      def engine_factory
+        @engine_factory ||= org.jruby.embed.jsr223.JRubyEngineFactory.new
+      end
+
+      def transform(name, input, kwargs)
+        script = @scripts[name]
+        ctx = script.engine.context
+        ctx.set_attribute("input", input.to_s, javax.script.ScriptContext::ENGINE_SCOPE)
+        kwargs.each do |(k, v)|
+          ctx.set_attribute(k.to_s, v.to_s, javax.script.ScriptContext::ENGINE_SCOPE)
+        end
+        script.eval
+      end
+    end
+  end
+end
+
 module RSpec
   module OpenHAB
     module Helpers
+      module BindingHelper
+        def add_kwargs_to_current_binding(binding, kwargs)
+          kwargs.each { |(k, v)| binding.local_variable_set(k, v) }
+        end
+      end
+
+      private_constant :BindingHelper
+
+      singleton_class.include(Helpers)
+
       def autoupdate_all_items
         @autoupdated_items ||= {}
         $ir.for_each do |_provider, item|
@@ -24,8 +67,158 @@ 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
+
+      def populate_items_from_api
+        api = ::OpenHAB::DSL::Imports.api
+        all_items = api.items
+
+        item_factory = org.openhab.core.library.CoreItemFactory.new
+
+        all_items.each do |item_json|
+          full_type = item_json["type"]
+          name = item_json["name"]
+
+          type, _dimension = full_type.split(":")
+          if type == "Group"
+            base_item = item_factory.create_item(item_json["groupType"], name) if item_json["groupType"]
+            if item_json["function"]
+              dto = org.openhab.core.items.dto.GroupFunctionDTO.new
+              dto.name = item_json.dig("function", "name")
+              dto.params = item_json.dig("function", "params")
+              function = org.openhab.core.items.dto.ItemDTOMapper.map_function(base_item, dto)
+            end
+            item = GroupItem.new(name, base_item, function)
+          else
+            item = item_factory.create_item(full_type, name)
+          end
+
+          item.label = item_json["label"]
+          item_json["tags"].each do |tag|
+            item.add_tag(tag)
+          end
+          item_json["metadata"]&.each do |key, config|
+            item.meta[key] = config["value"], config["config"]
+          end
+          item.meta["stateDescription"] = item_json["stateDescription"] if item_json["stateDescription"]
+          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|
+            next unless (group = $ir.get(group_name))
+
+            group.add_member($ir.get(item_json["name"]))
+          end
+        end
+      end
+
+      def populate_things_from_api
+        api = ::OpenHAB::DSL::Imports.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
+
+      def load_rules
+        automation_path = "#{org.openhab.core.OpenHAB.config_folder}/automation/jsr223/ruby/personal"
+
+        RSpec::OpenHAB::SuspendRules.suspend_rules do
+          Dir["#{automation_path}/*.rb"].each do |f|
+            load f
+          rescue Exception => e
+            warn "Failed loading #{f}: #{e.inspect}"
+            warn e.backtrace
+          end
+        end
+      end
+
+      def load_transforms
+        transform_path = "#{org.openhab.core.OpenHAB.config_folder}/transform"
+        Dir["#{transform_path}/**/*.script"].each do |filename|
+          script = File.read(filename)
+          next unless ruby_file?(script)
+
+          filename.slice!(0..transform_path.length)
+          dir = File.dirname(filename)
+          modules = dir == "." ? [] : moduleize(dir)
+          basename = File.basename(filename)
+          method = basename[0...-7]
+          modules << method
+          ::OpenHAB::Transform.add_script(modules, script)
+        end
+      end
+
       private
 
+      EMACS_MODELINE_REGEXP = /# -\*-(.+)-\*-/.freeze
+
+      def parse_emacs_modeline(line)
+        line[EMACS_MODELINE_REGEXP, 1]
+            &.split(";")
+            &.map(&:strip)
+            &.map { |l| l.split(":", 2).map(&:strip).tap { |a| a[1] ||= nil } }
+            &.to_h
+      end
+
+      def ruby_file?(script)
+        # check the first 1KB for an emacs magic comment
+        script[0..1024].split("\n").any? { |line| parse_emacs_modeline(line)&.dig("mode") == "ruby" }
+      end
+
+      def moduleize(term)
+        term
+          .sub(/^[a-z\d]*/, &:capitalize)
+          .gsub(%r{(?:_|(/))([a-z\d]*)}) { "#{$1}#{$2.capitalize}" }
+          .split("/")
+      end
+
       def restore_autoupdate_items
         return unless instance_variable_defined?(:@autoupdated_items)
 
@@ -33,6 +226,124 @@ module RSpec
           item.meta["autoupdate"] = meta
         end
       end
+
+      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
 
     RSpec.configure do |config|

data/lib/rspec/openhab/hooks.rb

@@ -1,20 +1,33 @@
 # frozen_string_literal: true
 
-RSpec.configure do |config|
-  config.before do
-    suspend_rules do
-      $ir.for_each do |_provider, item|
-        next if item.is_a?(GroupItem) # groups only have calculated states
+module RSpec
+  module OpenHAB
+    RSpec.configure do |config|
+      config.before(:suite) do
+        Helpers.populate_things_from_api if ::OpenHAB::DSL::Imports.api.authenticated?
+        Helpers.populate_items_from_api
+        Helpers.load_transforms
+        Helpers.suspend_rules do
+          Helpers.load_rules
+        end
+      end
+
+      config.before do
+        suspend_rules do
+          $ir.for_each do |_provider, item|
+            next if item.is_a?(GroupItem) # groups only have calculated states
 
-        item.state = NULL unless item.raw_state == NULL
+            item.state = NULL unless item.raw_state == NULL
+          end
+        end
       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
+      config.after do
+        ::OpenHAB::DSL::Timers.timer_manager.cancel_all
+        Timecop.return
+        restore_autoupdate_items
+        Core::Mocks::PersistenceService.instance.reset
+      end
+    end
   end
 end

data/lib/rspec/openhab/version.rb

@@ -2,6 +2,6 @@
 
 module RSpec
   module OpenHAB
-    VERSION = "0.0.16"
+    VERSION = "0.0.19"
   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
@@ -66,7 +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
@@ -83,7 +88,6 @@ require_relative "rspec/openhab/dsl/rules/triggers/watch"
 
 # RSpec additions
 require "rspec/core"
-require "rspec/openhab/items"
 require "rspec/openhab/helpers"
 require "rspec/openhab/hooks"
 require "rspec/openhab/suspend_rules"
@@ -92,25 +96,9 @@ RSpec.configure do |config|
   config.include OpenHAB::Core::EntityLookup
 end
 
-RSpec::OpenHAB::SuspendRules.suspend_rules do
-  RSpec::OpenHAB::Items.populate_items_from_api(api)
-end
-
 # make bundler/inline _not_ destroy the already existing load path
 module Bundler
   module SharedHelpers
     def clean_load_path; end
   end
 end
-
-# load rules files
-OPENHAB_AUTOMATION_PATH = "#{org.openhab.core.OpenHAB.config_folder}/automation/jsr223/ruby/personal"
-
-RSpec::OpenHAB::SuspendRules.suspend_rules do
-  Dir["#{OPENHAB_AUTOMATION_PATH}/*.rb"].each do |f|
-    load f
-  rescue Exception => e
-    warn "Failed loading #{f}: #{e.inspect}"
-    warn e.backtrace
-  end
-end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.19
 platform: java
 authors:
 - Cody Cutrer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-18 00:00:00.000000000 Z
+date: 2022-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -192,7 +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
@@ -201,7 +205,6 @@ files:
 - lib/rspec/openhab/dsl/timers/timer.rb
 - lib/rspec/openhab/helpers.rb
 - lib/rspec/openhab/hooks.rb
-- lib/rspec/openhab/items.rb
 - lib/rspec/openhab/suspend_rules.rb
 - lib/rspec/openhab/version.rb
 - vendor/gems/jar-dependencies-1.0.0/lib/jar-dependencies.rb
@@ -237,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:
   - - ">="

data/lib/rspec/openhab/items.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module RSpec
-  module OpenHAB
-    module Items
-      class << self
-        def populate_items_from_api(api)
-          all_items = api.items
-
-          gfh = org.openhab.core.internal.items.GroupFunctionHelper.new
-          item_factory = org.openhab.core.library.CoreItemFactory.new
-
-          all_items.each do |item_json|
-            full_type = item_json["type"]
-            name = item_json["name"]
-
-            type, _dimension = full_type.split(":")
-            if type == "Group"
-              base_item = item_factory.create_item(item_json["groupType"], name) if item_json["groupType"]
-              if item_json["function"]
-                dto = org.openhab.core.items.dto.GroupFunctionDTO.new
-                dto.name = item_json.dig("function", "name")
-                dto.params = item_json.dig("function", "params")
-                function = gfh.create_group_function(dto, base_item)
-              end
-              item = GroupItem.new(name, base_item, function)
-            else
-              item = item_factory.create_item(full_type, name)
-            end
-
-            item.label = item_json["label"]
-            item_json["tags"].each do |tag|
-              item.add_tag(tag)
-            end
-            item_json["metadata"]&.each do |key, config|
-              item.meta[key] = config["value"], config["config"]
-            end
-            item.meta["stateDescription"] = item_json["stateDescription"] if item_json["stateDescription"]
-            item.category = item_json["category"] if item_json["category"]
-
-            $ir.add(item)
-          end
-          all_items.each do |item_json| # rubocop:disable Style/CombinableLoops
-            item_json["groupNames"].each do |group_name|
-              next unless (group = $ir.get(group_name))
-
-              group.add_member($ir.get(item_json["name"]))
-            end
-          end
-        end
-      end
-    end
-  end
-end