ruby-dbus 0.16.0 → 0.18.1

data/spec/emits_changed_signal_spec.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+describe DBus::EmitsChangedSignal do
+  describe "#initialize" do
+    it "accepts a simple value" do
+      expect(described_class.new(:const).value).to eq :const
+    end
+
+    it "avoids nil by asking the interface" do
+      ifc = DBus::Interface.new("org.example.Foo")
+      ifc.emits_changed_signal = described_class.new(:invalidates)
+
+      expect(described_class.new(nil, interface: ifc).value).to eq :invalidates
+    end
+
+    it "fails for unknown value" do
+      expect { described_class.new(:huh) }.to raise_error(ArgumentError, /Seen :huh/)
+    end
+
+    it "fails for 2 nils" do
+      expect { described_class.new(nil, interface: nil) }.to raise_error(ArgumentError, /Both/)
+    end
+  end
+
+  describe "#==" do
+    it "is true for two different objects with the same value" do
+      const_a = described_class.new(:const)
+      const_b = described_class.new(:const)
+      expect(const_a == const_b).to be true
+    end
+  end
+
+  describe "#to_xml" do
+    it "uses a string value" do
+      expect(described_class.new(:const).to_xml)
+        .to eq "    <annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"const\"/>\n"
+    end
+  end
+
+  describe "#to_s" do
+    it "uses a string value" do
+      expect(described_class.new(:const).to_s).to eq "const"
+    end
+  end
+end
+
+describe DBus::Interface do
+  describe ".emits_changed_signal=" do
+    it "only allows an EmitsChangedSignal as argument" do
+      ifc = described_class.new("org.ruby.Interface")
+      expect { ifc.emits_changed_signal = :const }.to raise_error(TypeError)
+    end
+  end
+end

data/spec/err_msg_spec.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 # should report it missing on org.ruby.SampleInterface
 # (on object...) instead of on DBus::Proxy::ObjectInterface
 require_relative "spec_helper"

data/spec/introspect_xml_parser_spec.rb

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

data/spec/introspection_spec.rb

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

data/spec/main_loop_spec.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 # Test the main loop
 require_relative "spec_helper"
 require "dbus"
@@ -70,7 +72,7 @@ describe "MainLoopTest" do
     @obj.on_signal "LongTaskEnd"
   end
 
-  it "tests loop quit" do
+  it "tests loop quit", slow: true do
     test_loop_quit 1
   end
 

data/spec/node_spec.rb

@@ -0,0 +1,23 @@
+#!/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
+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_spec.rb

@@ -0,0 +1,138 @@
+#!/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
+  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 ".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
+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

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