ruby-dbus 0.16.0 → 0.25.0

data/spec/packet_unmarshaller_spec.rb

@@ -0,0 +1,248 @@
+#!/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)
+
+# Helper to access PacketUnmarshaller internals.
+# Add it to its public API?
+# @param p_u [PacketUnmarshaller]
+# @return [String] the binary string with unconsumed data
+def remaining_buffer(p_u)
+  raw_msg = p_u.instance_variable_get(:@raw_msg)
+  raw_msg.remaining_bytes
+end
+
+RSpec.shared_examples "parses good data" do |cases|
+  describe "parses all the instances of good test data" do
+    cases.each_with_index do |(buffer, endianness, expected), i|
+      it "parses plain data ##{i}" do
+        buffer = String.new(buffer, encoding: Encoding::BINARY)
+        subject = described_class.new(buffer, endianness)
+
+        results = subject.unmarshall(signature, mode: :plain)
+        # unmarshall works on multiple signatures but we use one
+        expect(results).to be_an(Array)
+        expect(results.size).to eq(1)
+        result = results.first
+
+        expect(result).to eq(expected)
+
+        expect(remaining_buffer(subject)).to be_empty
+      end
+
+      it "parses exact data ##{i}" do
+        buffer = String.new(buffer, encoding: Encoding::BINARY)
+        subject = described_class.new(buffer, endianness)
+
+        results = subject.unmarshall(signature, mode: :exact)
+        # unmarshall works on multiple signatures but we use one
+        expect(results).to be_an(Array)
+        expect(results.size).to eq(1)
+        result = results.first
+
+        expect(result).to be_a(DBus::Data::Base)
+        expect(result.value).to eq(expected)
+
+        expect(remaining_buffer(subject)).to be_empty
+      end
+    end
+  end
+end
+
+# this is necessary because we do an early switch on the signature
+RSpec.shared_examples "reports empty data" do
+  it "reports empty data" do
+    [:big, :little].each do |endianness|
+      subject = described_class.new("", endianness)
+      expect { subject.unmarshall(signature) }.to raise_error(DBus::IncompleteBufferException)
+    end
+  end
+end
+
+describe DBus::PacketUnmarshaller do
+  context "marshall.yaml" do
+    marshall_yaml.each do |test|
+      t = OpenStruct.new(test)
+      signature = t.sig
+      buffer = buffer_from_yaml(t.buf)
+      endianness = t.end.to_sym
+
+      # successful parse
+      if !t.val.nil?
+        expected = t.val
+
+        it "parses a '#{signature}' to get #{t.val.inspect} (plain)" do
+          subject = described_class.new(buffer, endianness)
+          results = subject.unmarshall(signature, mode: :plain)
+          # unmarshall works on multiple signatures but we use one
+          expect(results).to be_an(Array)
+          expect(results.size).to eq(1)
+          result = results.first
+
+          expect(result).to eq(expected)
+          expect(remaining_buffer(subject)).to be_empty
+        end
+
+        it "parses a '#{t.sig}' to get #{t.val.inspect} (exact)" do
+          subject = described_class.new(buffer, endianness)
+          results = subject.unmarshall(signature, mode: :exact)
+          # unmarshall works on multiple signatures but we use one
+          expect(results).to be_an(Array)
+          expect(results.size).to eq(1)
+          result = results.first
+
+          expect(result).to be_a(DBus::Data::Base)
+          expect(result.value).to eq(expected)
+
+          expect(remaining_buffer(subject)).to be_empty
+        end
+      elsif t.exc
+        next if t.unmarshall == false
+
+        exc_class = DBus.const_get(t.exc)
+        msg_re = Regexp.new(Regexp.escape(t.msg))
+
+        # TODO: InvalidPacketException is never rescued.
+        # The other end is sending invalid data. Can we do better than crashing?
+        # When we can test with peer connections, try it out.
+        it "parses a '#{signature}' to report a #{t.exc}" do
+          subject = described_class.new(buffer, endianness)
+          expect { subject.unmarshall(signature, mode: :plain) }.to raise_error(exc_class, msg_re)
+
+          subject = described_class.new(buffer, endianness)
+          expect { subject.unmarshall(signature, mode: :exact) }.to raise_error(exc_class, msg_re)
+        end
+      end
+    end
+  end
+
+  context "BYTEs" do
+    let(:signature) { "y" }
+    include_examples "reports empty data"
+  end
+
+  context "BOOLEANs" do
+    let(:signature) { "b" }
+    include_examples "reports empty data"
+  end
+
+  context "INT16s" do
+    let(:signature) { "n" }
+    include_examples "reports empty data"
+  end
+
+  context "UINT16s" do
+    let(:signature) { "q" }
+    include_examples "reports empty data"
+  end
+
+  context "INT32s" do
+    let(:signature) { "i" }
+    include_examples "reports empty data"
+  end
+
+  context "UINT32s" do
+    let(:signature) { "u" }
+    include_examples "reports empty data"
+  end
+
+  context "UNIX_FDs" do
+    let(:signature) { "h" }
+    include_examples "reports empty data"
+  end
+
+  context "INT64s" do
+    let(:signature) { "x" }
+    include_examples "reports empty data"
+  end
+
+  context "UINT64s" do
+    let(:signature) { "t" }
+    include_examples "reports empty data"
+  end
+
+  context "DOUBLEs" do
+    let(:signature) { "d" }
+    # See https://en.wikipedia.org/wiki/Double-precision_floating-point_format
+    # for binary representations
+    # TODO: figure out IEEE754 comparisons
+    good = [
+      # But == cant distinguish -0.0
+      ["\x00\x00\x00\x00\x00\x00\x00\x80", :little, -0.0],
+      # But NaN == NaN is false!
+      # ["\xff\xff\xff\xff\xff\xff\xff\xff", :little, Float::NAN],
+      ["\x80\x00\x00\x00\x00\x00\x00\x00", :big, -0.0]
+      # ["\xff\xff\xff\xff\xff\xff\xff\xff", :big, Float::NAN]
+    ]
+    include_examples "parses good data", good
+    include_examples "reports empty data"
+  end
+
+  context "STRINGs" do
+    let(:signature) { "s" }
+    include_examples "reports empty data"
+  end
+
+  context "OBJECT_PATHs" do
+    let(:signature) { "o" }
+    include_examples "reports empty data"
+  end
+
+  context "SIGNATUREs" do
+    let(:signature) { "g" }
+    include_examples "reports empty data"
+  end
+
+  context "ARRAYs" do
+    context "of BYTEs" do
+      let(:signature) { "ay" }
+      include_examples "reports empty data"
+    end
+
+    context "of UINT64s" do
+      let(:signature) { "at" }
+      include_examples "reports empty data"
+    end
+
+    context "of STRUCT of 2 UINT16s" do
+      let(:signature) { "a(qq)" }
+      include_examples "reports empty data"
+    end
+
+    context "of DICT_ENTRIES" do
+      let(:signature) { "a{yq}" }
+      include_examples "reports empty data"
+    end
+  end
+
+  context "STRUCTs" do
+    # TODO: this is invalid but does not raise
+    context "(generic 'r' struct)" do
+      let(:signature) { "r" }
+    end
+
+    context "of two shorts" do
+      let(:signature) { "(qq)" }
+      include_examples "reports empty data"
+    end
+  end
+
+  # makes sense here? or in array? remember invalid sigs are rejected elsewhere
+  context "DICT_ENTRYs" do
+    context "(generic 'e' dict_entry)" do
+      let(:signature) { "e" }
+    end
+  end
+
+  context "VARIANTs" do
+    let(:signature) { "v" }
+    include_examples "reports empty data"
+  end
+end

data/spec/platform_spec.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+describe DBus::Platform do
+  describe ".macos?" do
+    # code coverage chasing, as other tests mock it out
+    it "doesn't crash" do
+      expect { described_class.macos? }.to_not raise_error
+    end
+  end
+end

data/spec/property_spec.rb

@@ -1,11 +1,21 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 require_relative "spec_helper"
 require "dbus"
 
+# FIXME: factor out DBus::TestFixtures::Value in spec_helper
+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 "PropertyTest" do
   before(:each) do
-    session_bus = DBus::ASessionBus.new
-    @svc = session_bus.service("org.ruby.service")
+    @session_bus = DBus::ASessionBus.new
+    @svc = @session_bus.service("org.ruby.service")
     @obj = @svc.object("/org/ruby/MyInstance")
     @iface = @obj["org.ruby.SampleInterface"]
   end
@@ -21,17 +31,40 @@ describe "PropertyTest" do
     expect(iface["ReadMe"]).to eq("READ ME")
   end
 
+  context "when reading a property fails" do
+    it "gets an error, mentioning the qualified property name" do
+      expect { @iface["Explosive"] }
+        .to raise_error(DBus::Error, /getting.*SampleInterface.Explosive.*Something failed/)
+    end
+  end
+
   it "tests property nonreading" do
     expect { @iface["WriteMe"] }.to raise_error(DBus::Error, /not readable/)
   end
 
-  it "tests property writing" do
-    @iface["ReadOrWriteMe"] = "VALUE"
-    expect(@iface["ReadOrWriteMe"]).to eq("VALUE")
+  context "writing properties" do
+    it "tests property writing" do
+      @iface["ReadOrWriteMe"] = "VALUE"
+      expect(@iface["ReadOrWriteMe"]).to eq("VALUE")
+    end
+
+    context "when writing a read-only property" do
+      it "gets an error, mentioning the qualified property name" do
+        expect { @iface["ReadMe"] = "WROTE" }
+          .to raise_error(DBus::Error, /SampleInterface.ReadMe.*not writable/)
+      end
+    end
+
+    context "when writing a property fails" do
+      it "gets an error, mentioning the qualified property name" do
+        expect { @iface["WriteMe"] = "Bruno is a city in Czechia" }
+          .to raise_error(DBus::Error, /setting.*SampleInterface.WriteMe/)
+      end
+    end
   end
 
   # https://github.com/mvidner/ruby-dbus/pull/19
-  it "tests service select timeout" do
+  it "tests service select timeout", slow: true do
     @iface["ReadOrWriteMe"] = "VALUE"
     expect(@iface["ReadOrWriteMe"]).to eq("VALUE")
     # wait for the service to become idle
@@ -40,13 +73,9 @@ describe "PropertyTest" do
     expect(@iface["ReadOrWriteMe"]).to eq("VALUE")
   end
 
-  it "tests property nonwriting" do
-    expect { @iface["ReadMe"] = "WROTE" }.to raise_error(DBus::Error, /not writable/)
-  end
-
   it "tests get all" do
     all = @iface.all_properties
-    expect(all.keys.sort).to eq(["ReadMe", "ReadOrWriteMe"])
+    expect(all.keys.sort).to eq(["MyArray", "MyByte", "MyDict", "MyStruct", "MyVariant", "ReadMe", "ReadOrWriteMe"])
   end
 
   it "tests get all on a V1 object" do
@@ -54,7 +83,7 @@ describe "PropertyTest" do
     iface = obj["org.ruby.SampleInterface"]
 
     all = iface.all_properties
-    expect(all.keys.sort).to eq(["ReadMe", "ReadOrWriteMe"])
+    expect(all.keys.sort).to eq(["MyArray", "MyByte", "MyDict", "MyStruct", "MyVariant", "ReadMe", "ReadOrWriteMe"])
   end
 
   it "tests unknown property reading" do
@@ -64,4 +93,177 @@ describe "PropertyTest" do
   it "tests unknown property writing" do
     expect { @iface["Spoon"] = "FPRK" }.to raise_error(DBus::Error, /not found/)
   end
+
+  it "errors for a property on an unknown interface" do
+    # our idiomatic way would error out on interface lookup already,
+    # so do it the low level way
+    prop_if = @obj[DBus::PROPERTY_INTERFACE]
+    expect { prop_if.Get("org.ruby.NoSuchInterface", "SomeProperty") }.to raise_error(DBus::Error) do |e|
+      expect(e.name).to match(/UnknownProperty/)
+      expect(e.message).to match(/no such interface/)
+    end
+  end
+
+  it "errors for GetAll on an unknown interface" do
+    # no idiomatic way?
+    # so do it the low level way
+    prop_if = @obj[DBus::PROPERTY_INTERFACE]
+    expect { prop_if.GetAll("org.ruby.NoSuchInterface") }.to raise_error(DBus::Error) do |e|
+      expect(e.name).to match(/UnknownProperty/)
+      expect(e.message).to match(/no such interface/)
+    end
+  end
+
+  it "receives a PropertiesChanged signal", slow: true do
+    received = {}
+
+    # TODO: for client side, provide a helper on_properties_changed,
+    # or automate it even more in ProxyObject, ProxyObjectInterface
+    prop_if = @obj[DBus::PROPERTY_INTERFACE]
+    prop_if.on_signal("PropertiesChanged") do |_interface_name, changed_props, _invalidated_props|
+      received.merge!(changed_props)
+    end
+
+    @iface["ReadOrWriteMe"] = "VALUE"
+    @iface.SetTwoProperties("REAMDE", 255)
+
+    # loop to process the signal. complicated :-( see signal_spec.rb
+    loop = DBus::Main.new
+    loop << @session_bus
+    quitter = Thread.new do
+      sleep 1
+      loop.quit
+    end
+    loop.run
+    # quitter has told loop.run to quit
+    quitter.join
+
+    expect(received["ReadOrWriteMe"]).to eq("VALUE")
+    expect(received["ReadMe"]).to eq("REAMDE")
+    expect(received["MyByte"]).to eq(255)
+  end
+
+  context "a struct-typed property" do
+    it "gets read as a struct, not an array (#97)" do
+      struct = @iface["MyStruct"]
+      expect(struct).to be_frozen
+    end
+
+    it "Get returns the correctly typed value (check with dbus-send)" do
+      # As big as the DBus::Data branch is,
+      # it still does not handle the :exact mode on the client/proxy side.
+      # So we resort to parsing dbus-send output.
+      cmd = "dbus-send --print-reply " \
+            "--dest=org.ruby.service " \
+            "/org/ruby/MyInstance " \
+            "org.freedesktop.DBus.Properties.Get " \
+            "string:org.ruby.SampleInterface " \
+            "string:MyStruct"
+      reply = `#{cmd}`
+      expect(reply).to match(/variant\s+struct {\s+string "three"\s+string "strings"\s+string "in a struct"\s+}/)
+    end
+
+    it "GetAll returns the correctly typed value (check with dbus-send)" do
+      cmd = "dbus-send --print-reply " \
+            "--dest=org.ruby.service " \
+            "/org/ruby/MyInstance " \
+            "org.freedesktop.DBus.Properties.GetAll " \
+            "string:org.ruby.SampleInterface "
+      reply = `#{cmd}`
+      expect(reply).to match(/variant\s+struct {\s+string "three"\s+string "strings"\s+string "in a struct"\s+}/)
+    end
+  end
+
+  context "an array-typed property" do
+    it "gets read as an array" do
+      val = @iface["MyArray"]
+      expect(val).to eq([42, 43])
+    end
+  end
+
+  context "a dict-typed property" do
+    it "gets read as a hash" do
+      val = @iface["MyDict"]
+      expect(val).to eq({
+                          "one" => 1,
+                          "two" => "dva",
+                          "three" => [3, 3, 3]
+                        })
+    end
+
+    it "Get returns the correctly typed value (check with dbus-send)" do
+      cmd = "dbus-send --print-reply " \
+            "--dest=org.ruby.service " \
+            "/org/ruby/MyInstance " \
+            "org.freedesktop.DBus.Properties.Get " \
+            "string:org.ruby.SampleInterface " \
+            "string:MyDict"
+      reply = `#{cmd}`
+      # a bug about variant nesting lead to a "variant variant int32 1" value
+      match_rx = /variant \s+ array \s \[ \s+
+         dict \s entry\( \s+
+            string \s "one" \s+
+            variant \s+ int32 \s 1 \s+
+         \)/x
+      expect(reply).to match(match_rx)
+    end
+  end
+
+  context "a variant-typed property" do
+    it "gets read at all" do
+      obj = @svc.object("/org/ruby/MyDerivedInstance")
+      iface = obj["org.ruby.SampleInterface"]
+      val = iface["MyVariant"]
+      expect(val).to eq([42, 43])
+    end
+  end
+
+  context "a byte-typed property" do
+    # Slightly advanced RSpec:
+    # https://rspec.info/documentation/3.9/rspec-expectations/RSpec/Matchers.html#satisfy-instance_method
+    let(:a_byte_in_a_variant) do
+      satisfying { |x| x.is_a?(DBus::Data::Variant) && x.member_type.to_s == DBus::Type::BYTE }
+      # ^ This formatting keeps the matcher on a single line
+      # which enables RSpec to cite it if it fails, instead of saying "block".
+    end
+
+    let(:prop_iface) { @obj[DBus::PROPERTY_INTERFACE] }
+
+    it "gets set with a correct type (#108)" do
+      expect(prop_iface).to receive(:Set).with(
+        "org.ruby.SampleInterface",
+        "MyByte",
+        a_byte_in_a_variant
+      )
+      @iface["MyByte"] = 1
+    end
+
+    it "gets set with a correct type (#108), when using the DBus.variant workaround" do
+      expect(prop_iface).to receive(:Set).with(
+        "org.ruby.SampleInterface",
+        "MyByte",
+        a_byte_in_a_variant
+      )
+      @iface["MyByte"] = DBus.variant("y", 1)
+    end
+  end
+
+  context "marshall.yaml round-trip via a VARIANT property" do
+    marshall_yaml.each do |test|
+      t = OpenStruct.new(test)
+      next if t.val.nil?
+
+      # Round trips do not work yet because the properties
+      # must present a plain Ruby value so the exact D-Bus type is lost.
+      # Round trips will work once users can declare accepting DBus::Data
+      # in properties and method arguments.
+      it "Sets #{t.sig.inspect}:#{t.val.inspect} and Gets something back" do
+        before = DBus::Data.make_typed(t.sig, t.val)
+        expect { @iface["MyVariant"] = before }.to_not raise_error
+        expect { _after = @iface["MyVariant"] }.to_not raise_error
+        # round-trip:
+        # expect(after).to eq(before.value)
+      end
+    end
+  end
 end

data/spec/proxy_object_interface_spec.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+describe DBus::ProxyObjectInterface do
+  # TODO: tag tests that need a service, eg "needs-service"
+  # TODO: maybe remove this and rely on a packaged tool
+  around(:each) do |example|
+    with_private_bus do
+      with_service_by_activation(&example)
+    end
+  end
+
+  let(:bus) { DBus::ASessionBus.new }
+
+  context "when calling org.ruby.service" do
+    let(:svc) { bus["org.ruby.service"] }
+
+    # This is white box testing, knowing the implementation
+    # A better way would be structuring it according to the D-Bus Spec
+    # Or testing the service side doing the right thing? (What if our bugs cancel out)
+    describe "#define_method_from_descriptor" do
+      it "can call a method with multiple OUT arguments" do
+        obj = svc["/org/ruby/MyInstance"]
+        ifc = obj["org.ruby.SampleInterface"]
+
+        even, odd = ifc.EvenOdd([3, 1, 4, 1, 5, 9, 2, 6])
+        expect(even).to eq [4, 2, 6]
+        expect(odd).to eq [3, 1, 1, 5, 9]
+      end
+    end
+  end
+end

data/spec/proxy_object_spec.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 require_relative "spec_helper"
 require "dbus"
 

data/spec/{bus_driver_spec.rb → proxy_service_spec.rb}

@@ -1,15 +1,11 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 require_relative "spec_helper"
 require "dbus"
 
-describe DBus::Service do
-  context "when a private bus is set up" do
-    around(:each) do |example|
-      with_private_bus do
-        with_service_by_activation(&example)
-      end
-    end
-
+describe DBus::ProxyService do
+  context "when a private bus is set up", tag_service: true do
     let(:bus) { DBus::ASessionBus.new }
 
     describe "#exists?" do
@@ -24,5 +20,16 @@ describe DBus::Service do
         expect(svc.exists?).to be false
       end
     end
+
+    # This method is used by dbus-gui-gtk.
+    # Deprecate it? In favor of introspecting the tree gradually
+    # or move it to the application code?
+    describe "#introspect" do
+      it "creates the whole node tree" do
+        svc = bus.service("org.ruby.service")
+        expect { svc.introspect }.to_not raise_error
+        expect(svc.root.dig("org", "ruby", "MyInstance")).to be_a DBus::Node
+      end
+    end
   end
 end

data/spec/raw_message_spec.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+# Pedantic full coverage test.
+# The happy paths are covered via calling classes
+describe DBus::RawMessage do
+  describe ".endianness" do
+    it "returns :little for 'l'" do
+      expect(described_class.endianness("l")).to eq :little
+    end
+
+    it "returns :big for 'B'" do
+      expect(described_class.endianness("B")).to eq :big
+    end
+
+    it "raises for other strings" do
+      expect { described_class.endianness("m") }
+        .to raise_error(DBus::InvalidPacketException, /Incorrect endianness/)
+    end
+  end
+
+  describe "#align" do
+    it "raises for values other than 1 2 4 8" do
+      subject = described_class.new("l")
+      expect { subject.align(3) }.to raise_error(ArgumentError)
+      expect { subject.align(16) }.to raise_error(ArgumentError)
+    end
+  end
+end