ruby-dbus 0.16.0 → 0.25.0

data/spec/node_spec.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+describe DBus::Node do
+  describe "#inspect" do
+    # the behavior needs improvement
+    it "shows the node, poorly" do
+      parent = described_class.new("parent")
+      parent.object = DBus::Object.new("/parent")
+
+      3.times do |i|
+        child_name = "child#{i}"
+        child = described_class.new(child_name)
+        parent[child_name] = child
+      end
+
+      expect(parent.inspect).to match(/<DBus::Node [0-9a-f]+ {child0 => {},child1 => {},child2 => {}}>/)
+    end
+  end
+
+  describe "#descendant_objects" do
+    let(:manager_path) { "/org/example/FooManager" }
+    let(:child_paths) do
+      [
+        # NOTE: "/org/example/FooManager/good"
+        # is a path under a managed object but there is no object there
+        "/org/example/FooManager/good/1",
+        "/org/example/FooManager/good/2",
+        "/org/example/FooManager/good/3",
+        "/org/example/FooManager/bad/1",
+        "/org/example/FooManager/bad/2"
+      ]
+    end
+
+    let(:non_child_paths) do
+      [
+        "/org/example/BarManager/good/1",
+        "/org/example/BarManager/good/2"
+      ]
+    end
+
+    context "on the bus" do
+      let(:bus) { DBus::ASessionBus.new }
+      let(:service) { bus.object_server }
+
+      before do
+        service.export(DBus::Object.new(manager_path))
+        non_child_paths.each do |p|
+          service.export(DBus::Object.new(p))
+        end
+      end
+
+      it "returns just the descendants of the specified objects" do
+        child_exported_objects = child_paths.map { |p| DBus::Object.new(p) }
+        child_exported_objects.each { |obj| service.export(obj) }
+
+        node = service.get_node(manager_path, create: false)
+        expect(node.descendant_objects).to eq child_exported_objects
+      end
+    end
+  end
+end

data/spec/object_manager_spec.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+describe DBus::ObjectManager do
+  describe "GetManagedObjects" do
+    let(:bus) { DBus::ASessionBus.new }
+    let(:service) { bus["org.ruby.service"] }
+    let(:obj) { service["/org/ruby/MyInstance"] }
+    let(:parent_iface) { obj["org.ruby.TestParent"] }
+    let(:om_iface) { obj["org.freedesktop.DBus.ObjectManager"] }
+
+    it "returns the interfaces and properties of currently managed objects" do
+      c1_opath = parent_iface.New("child1")
+      c2_opath = parent_iface.New("child2")
+
+      parent_iface.Delete(c1_opath)
+      expected_gmo = {
+        "/org/ruby/MyInstance/child2" => {
+          "org.freedesktop.DBus.Introspectable" => {},
+          "org.freedesktop.DBus.Properties" => {},
+          "org.ruby.TestChild" => { "Name" => "Child2" }
+        }
+      }
+      expect(om_iface.GetManagedObjects).to eq(expected_gmo)
+
+      parent_iface.Delete(c2_opath)
+      expect(om_iface.GetManagedObjects).to eq({})
+    end
+  end
+end

data/spec/object_path_spec.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 require_relative "spec_helper"
 require "dbus"
 
@@ -18,6 +20,7 @@ describe DBus::ObjectPath do
       expect(described_class.valid?("/EmptyLastComponent/")).to be_falsey
       expect(described_class.valid?("/Invalid Character")).to be_falsey
       expect(described_class.valid?("/Invalid-Character")).to be_falsey
+      expect(described_class.valid?("/InválídCháráctér")).to be_falsey
     end
   end
 end

data/spec/object_server_spec.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+describe DBus::ObjectServer do
+  let(:bus) { DBus::ASessionBus.new }
+  let(:server) { bus.object_server }
+
+  describe "#descendants_for" do
+    it "raises for not existing path" do
+      expect { server.descendants_for("/notthere") }.to raise_error(ArgumentError, /notthere doesn't exist/)
+    end
+  end
+
+  # tag_bus MEANS that the test needs a session bus
+  # tag_service MEANS that it needs a session bus with our testing services
+
+  describe "#export, #object, #[]", tag_bus: true do
+    it "object and [] return the object if it was exported" do
+      path = "/org/ruby/Foo"
+      obj = DBus::Object.new(path)
+      server.export(obj)
+      expect(server.object(path)).to be_equal(obj)
+      expect(server[path]).to be_equal(obj)
+    end
+
+    it "object and [] return nil if the path was not found or has no object" do
+      path = "/org/ruby/Bar"
+      obj = DBus::Object.new(path)
+      server.export(obj)
+
+      path2 = "/org/ruby/nosuch"
+      expect(server.object(path2)).to be_nil
+      expect(server[path2]).to be_nil
+
+      path3 = "/org"
+      expect(server.object(path3)).to be_nil
+      expect(server[path3]).to be_nil
+    end
+  end
+
+  describe "#export", tag_bus: true do
+    context "when exporting at a path where an object exists already" do
+      let(:path) { "/org/ruby/Same" }
+      let(:obj1) do
+        o = DBus::Object.new(path)
+        o.define_singleton_method(:which) { 1 }
+        o
+      end
+      let(:obj2) do
+        o = DBus::Object.new(path)
+        o.define_singleton_method(:which) { 2 }
+        o
+      end
+
+      it "raises an error" do
+        server.export(obj1)
+        expect { server.export(obj2) }.to raise_error(RuntimeError, /there is already an object/)
+      end
+    end
+  end
+
+  describe "#unexport", tag_bus: true do
+    before(:each) do
+      bus = DBus::ASessionBus.new
+      @svc = bus.object_server
+    end
+
+    it "returns the unexported leaf object" do
+      obj = DBus::Object.new "/org/ruby/Foo"
+      @svc.export obj
+      expect(@svc.unexport(obj)).to be_equal(obj)
+    end
+
+    it "returns the unexported leaf object, if specified by its path" do
+      obj = DBus::Object.new "/org/ruby/Foo"
+      @svc.export obj
+      expect(@svc.unexport(obj.path)).to be_equal(obj)
+
+      obj = DBus::Object.new "/org/ruby/Foo"
+      @svc.export obj
+      expect(@svc.unexport(DBus::ObjectPath.new(obj.path))).to be_equal(obj)
+    end
+
+    it "returns false if the object was never exported" do
+      obj = DBus::Object.new "/org/ruby/Foo"
+      expect(@svc.unexport(obj)).to be false
+    end
+
+    it "raises false if the path has no node" do
+      obj = DBus::Object.new "/org/ruby/Foo"
+      @svc.export obj
+      expect { @svc.unexport("/org/ruby/NotFoo") }.to raise_error(ArgumentError)
+      @svc.unexport obj
+    end
+
+    it "raises false if the path has no object" do
+      obj = DBus::Object.new "/org/ruby/Foo"
+      @svc.export obj
+      expect { @svc.unexport("/org/ruby") }.to raise_error(ArgumentError)
+      @svc.unexport obj
+    end
+
+    it "raises when argument is not usable" do
+      expect { @svc.unexport(:foo) }.to raise_error(ArgumentError)
+    end
+
+    context "/child_of_root" do
+      it "returns the unexported object" do
+        obj = DBus::Object.new "/child_of_root"
+        @svc.export obj
+        expect(@svc.unexport(obj)).to be_equal(obj)
+      end
+    end
+
+    context "/ (root)" do
+      it "returns the unexported object" do
+        obj = DBus::Object.new "/"
+        @svc.export obj
+        expect(@svc.unexport(obj)).to be_equal(obj)
+      end
+    end
+
+    context "not a leaf object" do
+      it "maintains objects on child paths" do
+        obj = DBus::Object.new "/org/ruby"
+        @svc.export obj
+        obj2 = DBus::Object.new "/org/ruby/Foo"
+        @svc.export obj2
+
+        @svc.unexport(obj)
+        expect(@svc.object("/org/ruby/Foo")).to be_a DBus::Object
+      end
+    end
+  end
+end

data/spec/object_spec.rb

@@ -0,0 +1,194 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+class ObjectTest < DBus::Object
+  T = DBus::Type unless const_defined? "T"
+
+  dbus_interface "org.ruby.ServerTest" do
+    dbus_attr_writer :write_me, T::Struct[String, String]
+
+    attr_accessor :read_only_for_dbus
+
+    dbus_reader :read_only_for_dbus, T::STRING, emits_changed_signal: :invalidates
+  end
+end
+
+describe DBus::Object do
+  describe ".dbus_attr_writer" do
+    describe "the declared assignment method" do
+      # Slightly advanced RSpec:
+      # https://rspec.info/documentation/3.9/rspec-expectations/RSpec/Matchers.html#satisfy-instance_method
+      let(:a_struct_in_a_variant) do
+        satisfying { |x| x.is_a?(DBus::Data::Variant) && x.member_type.to_s == "(ss)" }
+        # ^ This formatting keeps the matcher on a single line
+        # which enables RSpec to cite it if it fails, instead of saying "block".
+      end
+
+      it "emits PropertyChanged with correctly typed argument" do
+        obj = ObjectTest.new("/test")
+        expect(obj).to receive(:PropertiesChanged).with(
+          "org.ruby.ServerTest",
+          {
+            "WriteMe" => a_struct_in_a_variant
+          },
+          []
+        )
+        # bug: call PC with simply the assigned value,
+        # which will need type guessing
+        obj.write_me = ["two", "strings"]
+      end
+    end
+  end
+
+  describe ".dbus_accessor" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_accessor :foo, DBus::Type::STRING
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+  end
+
+  describe ".dbus_reader" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_reader :foo, DBus::Type::STRING
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+
+    it "fails when the signature is invalid" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_interface "org.ruby.ServerTest" do
+            dbus_reader :foo2, "!"
+          end
+        end
+      end.to raise_error(DBus::Type::SignatureException)
+    end
+  end
+
+  describe ".dbus_reader, when paired with attr_accessor" do
+    describe "the declared assignment method" do
+      it "emits PropertyChanged" do
+        obj = ObjectTest.new("/test")
+        expect(obj).to receive(:PropertiesChanged).with(
+          "org.ruby.ServerTest",
+          {},
+          ["ReadOnlyForDbus"]
+        )
+        obj.read_only_for_dbus = "myvalue"
+      end
+    end
+  end
+
+  describe ".dbus_writer" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_writer :foo, DBus::Type::STRING
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+  end
+
+  describe ".dbus_watcher" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_watcher :foo
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+  end
+
+  describe ".dbus_method" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_method :foo do
+          end
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+  end
+
+  describe ".dbus_signal" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_signal :signal_without_interface
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+
+    it "cannot be named with a bang" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_interface "org.ruby.ServerTest" do
+            # a valid Ruby symbol but an invalid DBus name; Ticket#38
+            dbus_signal :signal_with_a_bang!
+          end
+        end
+      end.to raise_error(DBus::InvalidMethodName)
+    end
+  end
+
+  describe ".emits_changed_signal" do
+    it "raises UndefinedInterface when so" do
+      expect { ObjectTest.emits_changed_signal = false }
+        .to raise_error DBus::Object::UndefinedInterface
+    end
+
+    it "assigns to the current interface" do
+      ObjectTest.instance_exec do
+        dbus_interface "org.ruby.Interface" do
+          self.emits_changed_signal = false
+        end
+      end
+      ecs = ObjectTest.intfs["org.ruby.Interface"].emits_changed_signal
+      expect(ecs).to eq false
+    end
+
+    it "only can be assigned once" do
+      expect do
+        Class.new(DBus::Object) do
+          dbus_interface "org.ruby.Interface" do
+            self.emits_changed_signal = false
+            self.emits_changed_signal = :invalidates
+          end
+        end
+      end.to raise_error(RuntimeError, /assigned more than once/)
+    end
+  end
+
+  # coverage obsession
+  describe "#dispatch" do
+    it "survives being called with a non-METHOD_CALL, doing nothing" do
+      obj = ObjectTest.new("/test")
+      msg = DBus::MethodReturnMessage.new
+      expect { obj.dispatch(msg) }.to_not raise_error
+    end
+  end
+
+  describe "#emit" do
+    context "before the object has been exported" do
+      it "raises an explanatory error" do
+        obj = ObjectTest.new("/test")
+
+        intf = DBus::Interface.new("org.example.Test")
+        signal = DBus::Signal.new("Ring")
+        expect { obj.emit(intf, signal) }
+          .to raise_error(
+            RuntimeError,
+            %r{Cannot emit signal org.example.Test.Ring before /test is exported}
+          )
+      end
+    end
+  end
+end

data/spec/packet_marshaller_spec.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+require "ostruct"
+require "yaml"
+
+data_dir = File.expand_path("data", __dir__)
+marshall_yaml_s = File.read("#{data_dir}/marshall.yaml")
+marshall_yaml = YAML.safe_load(marshall_yaml_s)
+
+describe DBus::PacketMarshaller do
+  context "marshall.yaml" do
+    marshall_yaml.each do |test|
+      t = OpenStruct.new(test)
+      next if t.marshall == false
+      # skip test cases for invalid unmarshalling
+      next if t.val.nil?
+
+      # while the marshaller can use only native endianness, skip the other
+      endianness = t.end.to_sym
+
+      signature = t.sig
+      expected = buffer_from_yaml(t.buf)
+
+      it "writes a '#{signature}' with value #{t.val.inspect} (#{endianness})" do
+        subject = described_class.new(endianness: endianness)
+        subject.append(signature, t.val)
+        expect(subject.packet).to eq(expected)
+      end
+
+      it "writes a '#{signature}' with typed value #{t.val.inspect} (#{endianness})" do
+        subject = described_class.new(endianness: endianness)
+        typed_val = DBus::Data.make_typed(signature, t.val)
+        subject.append(signature, typed_val)
+        expect(subject.packet).to eq(expected)
+      end
+    end
+  end
+end