ruby-dbus 0.17.0 → 0.18.0.beta3

data/spec/packet_unmarshaller_spec.rb

@@ -0,0 +1,262 @@
+#!/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)
+        if expected.is_a?(Hash)
+          expect(result.value.size).to eq(expected.size)
+          result.value.each_key do |result_key|
+            expect(result.value[result_key]).to eq(expected[result_key.value])
+          end
+        else
+          expect(result.value).to eq(expected)
+        end
+
+        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)
+          if expected.is_a?(Hash)
+            expect(result.value.size).to eq(expected.size)
+            result.value.each_key do |result_key|
+              expect(result.value[result_key]).to eq(expected[result_key.value])
+            end
+          else
+            expect(result.value).to eq(expected)
+          end
+
+          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/property_spec.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 require_relative "spec_helper"
 require "dbus"
 
@@ -50,7 +52,7 @@ describe "PropertyTest" do
 
   it "tests get all" do
     all = @iface.all_properties
-    expect(all.keys.sort).to eq(["ReadMe", "ReadOrWriteMe"])
+    expect(all.keys.sort).to eq(["MyArray", "MyDict", "MyStruct", "MyVariant", "ReadMe", "ReadOrWriteMe"])
   end
 
   it "tests get all on a V1 object" do
@@ -58,7 +60,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", "MyDict", "MyStruct", "MyVariant", "ReadMe", "ReadOrWriteMe"])
   end
 
   it "tests unknown property reading" do
@@ -114,4 +116,60 @@ describe "PropertyTest" do
 
     expect(received["ReadOrWriteMe"]).to eq("VALUE")
   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 "an 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
+  end
+
+  context "a variant-typed property" do
+    it "gets read at all" do
+      val = @iface["MyVariant"]
+      expect(val).to eq([42, 43])
+    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/server_robustness_spec.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 # Test that a server survives various error cases
 require_relative "spec_helper"
 require "dbus"

data/spec/server_spec.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 # Test that a server survives various error cases
 require_relative "spec_helper"
 require "dbus"

data/spec/service_newapi.rb

@@ -1,25 +1,42 @@
 #!/usr/bin/env ruby
-# -*- coding: utf-8 -*-
+# frozen_string_literal: true
 
 require_relative "spec_helper"
 SimpleCov.command_name "Service Tests" if Object.const_defined? "SimpleCov"
 # find the library without external help
-$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 
 require "dbus"
 
-PROPERTY_INTERFACE = "org.freedesktop.DBus.Properties".freeze
+PROPERTY_INTERFACE = "org.freedesktop.DBus.Properties"
 
 class Test < DBus::Object
-  INTERFACE = "org.ruby.SampleInterface".freeze
+  Point2D = Struct.new(:x, :y)
+
+  attr_writer :main_loop
+
+  INTERFACE = "org.ruby.SampleInterface"
   def initialize(path)
     super path
     @read_me = "READ ME"
     @read_or_write_me = "READ OR WRITE ME"
+    @my_struct = ["three", "strings", "in a struct"].freeze
+    @my_array = [42, 43]
+    @my_dict = {
+      "one" => 1,
+      "two" => "dva",
+      "three" => [3, 3, 3]
+    }
+    @my_variant = @my_array.dup
+    @main_loop = nil
   end
 
   # Create an interface aggregating all upcoming dbus_method defines.
   dbus_interface INTERFACE do
+    dbus_method :quit, "" do
+      @main_loop&.quit
+    end
+
     dbus_method :hello, "in name:s, in name2:s" do |name, name2|
       puts "hello(#{name}, #{name2})"
     end
@@ -60,6 +77,16 @@ class Test < DBus::Object
       [bytes]
     end
 
+    dbus_method :Coordinates, "out coords:(dd)" do
+      coords = [3.0, 4.0].freeze
+      [coords]
+    end
+
+    dbus_method :Coordinates2, "out coords:(dd)" do
+      coords = Point2D.new(5.0, 12.0)
+      [coords]
+    end
+
     # Properties:
     # ReadMe:string, returns "READ ME" at first, then what WriteMe received
     # WriteMe:string
@@ -79,6 +106,11 @@ class Test < DBus::Object
       raise "Something failed"
     end
     dbus_reader :explosive, "s"
+
+    dbus_attr_reader :my_struct, "(sss)"
+    dbus_attr_reader :my_array, "aq"
+    dbus_attr_reader :my_dict, "a{sv}"
+    dbus_attr_reader :my_variant, "v"
   end
 
   # closing and reopening the same interface
@@ -178,6 +210,7 @@ end
 puts "listening, with ruby-#{RUBY_VERSION}"
 main = DBus::Main.new
 main << bus
+myobj.main_loop = main
 begin
   main.run
 rescue SystemCallError

data/spec/session_bus_spec.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 require_relative "spec_helper"
 require "dbus"
 
@@ -23,7 +25,7 @@ describe DBus::ASessionBus do
 
     before do
       # mocks of files for address_from_file method
-      machine_id_path = File.expand_path("/etc/machine-id", __FILE__)
+      machine_id_path = File.expand_path("/etc/machine-id", __dir__)
       expect(Dir).to receive(:[]).with(any_args) { [machine_id_path] }
       expect(File).to receive(:read).with(machine_id_path) { "baz" }
       expect(File).to receive(:exist?).with(session_bus_file_path) { true }

data/spec/session_bus_spec_manual.rb

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

data/spec/signal_spec.rb

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

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 coverage = if ENV["COVERAGE"]
              ENV["COVERAGE"] == "true"
            else
@@ -7,12 +9,14 @@ coverage = if ENV["COVERAGE"]
 
 if coverage
   require "simplecov"
-  SimpleCov.root File.expand_path("../..", __FILE__)
+  SimpleCov.root File.expand_path("..", __dir__)
 
   # do not cover specs
   SimpleCov.add_filter "_spec.rb"
   # do not cover the activesupport helpers
   SimpleCov.add_filter "/core_ext/"
+  # measure all if/else branches on a line
+  SimpleCov.enable_coverage :branch
 
   SimpleCov.start
 
@@ -34,7 +38,7 @@ if coverage
   end
 end
 
-$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 
 if Object.const_defined? "RSpec"
   # http://betterspecs.org/#expect
@@ -48,7 +52,7 @@ end
 require "tempfile"
 require "timeout"
 
-TOPDIR = File.expand_path("../..", __FILE__)
+TOPDIR = File.expand_path("..", __dir__)
 
 # path of config file for a private bus
 def config_file_path
@@ -116,3 +120,15 @@ def with_service_by_activation(&block)
 
   system "pkill -f #{exec}"
 end
+
+# Make a binary string from readable YAML pieces; see data/marshall.yaml
+def buffer_from_yaml(parts)
+  strings = parts.flatten.map do |part|
+    if part.is_a? Integer
+      part.chr
+    else
+      part
+    end
+  end
+  strings.join.force_encoding(Encoding::BINARY)
+end

data/spec/thread_safety_spec.rb

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

data/spec/type_spec.rb

@@ -1,18 +1,81 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 require_relative "spec_helper"
 require "dbus"
 
 describe DBus do
   describe ".type" do
-    ["i", "ai", "a(ii)", "aai"].each do |s|
-      it "parses some type #{s}" do
-        expect(DBus.type(s).to_s).to be_eql s
+    good = [
+      "i",
+      "ai",
+      "a(ii)",
+      "aai"
+    ]
+
+    context "valid single types" do
+      good.each do |s|
+        it "#{s.inspect} is parsed" do
+          expect(DBus.type(s).to_s).to eq(s)
+        end
       end
     end
 
-    ["aa", "(ii", "ii)", "hrmp"].each do |s|
-      it "raises exception for invalid type #{s}" do
-        expect { DBus.type(s).to_s }.to raise_error DBus::Type::SignatureException
+    bad = [
+      ["\x00", "Unknown type code"],
+      ["!", "Unknown type code"],
+
+      # ARRAY related
+      ["a", "Empty ARRAY"],
+      ["aa", "Empty ARRAY"],
+
+      # STRUCT related
+      ["r", "Abstract STRUCT"],
+      ["()", "Empty STRUCT"],
+      ["(ii", "STRUCT not closed"],
+      ["a{i)", "STRUCT unexpectedly closed"],
+
+      # TODO: deep nesting arrays, structs, combined
+
+      # DICT_ENTRY related
+      ["e", "Abstract DICT_ENTRY"],
+      ["a{}", "DICT_ENTRY must have 2 subtypes, found 0"],
+      ["a{s}", "DICT_ENTRY must have 2 subtypes, found 1"],
+      ["a{sss}", "DICT_ENTRY must have 2 subtypes, found 3"],
+      ["a{vs}", "DICT_ENTRY key must be basic (non-container)"],
+      ["{sv}", "DICT_ENTRY not an immediate child of an ARRAY"],
+      ["a({sv})", "DICT_ENTRY not an immediate child of an ARRAY"],
+      ["a{sv", "DICT_ENTRY not closed"],
+      ["}", "DICT_ENTRY unexpectedly closed"],
+
+      # Too long
+      ["(#{"y" * 254})", "longer than 255"],
+
+      # not Single Complete Types
+      ["", "expecting a Single Complete Type"],
+      ["ii", "more than a Single Complete Type"]
+    ]
+    context "invalid single types" do
+      bad.each.each do |s, msg|
+        it "#{s.inspect} raises an exception mentioning: #{msg}" do
+          rx = Regexp.new(Regexp.quote(msg))
+          expect { DBus.type(s) }.to raise_error(DBus::Type::SignatureException, rx)
+        end
+      end
+    end
+  end
+
+  describe ".types" do
+    good = [
+      "",
+      "ii"
+    ]
+
+    context "valid signatures" do
+      good.each do |s|
+        it "#{s.inspect} is parsed" do
+          expect(DBus.types(s).map(&:to_s).join).to eq(s)
+        end
       end
     end
   end

data/spec/value_spec.rb

@@ -1,5 +1,6 @@
 #!/usr/bin/env rspec
-# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
 require_relative "spec_helper"
 require "dbus"
 
@@ -91,4 +92,18 @@ describe "ValueTest" do
   it "aligns short integers correctly" do
     expect(@obj.i16_plus(10, -30)[0]).to eq(-20)
   end
+
+  context "structs" do
+    it "they are returned as FROZEN arrays" do
+      struct = @obj.Coordinates[0]
+      expect(struct).to be_an(Array)
+      expect(struct).to be_frozen
+    end
+
+    it "they are returned also from structs" do
+      struct = @obj.Coordinates2[0]
+      expect(struct).to be_an(Array)
+      expect(struct).to be_frozen
+    end
+  end
 end

data/spec/variant_spec.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 # Test marshalling variants according to ruby types
 require_relative "spec_helper"
 require "dbus"
@@ -9,8 +11,8 @@ describe "VariantTest" do
     @svc = @bus.service("org.ruby.service")
   end
 
-  def make_variant(a)
-    DBus::PacketMarshaller.make_variant(a)
+  def make_variant(val)
+    DBus::PacketMarshaller.make_variant(val)
   end
 
   it "tests make variant scalar" do