ruby-dbus 0.18.0.beta4 → 0.18.0.beta7

data/spec/property_spec.rb

@@ -60,7 +60,7 @@ describe "PropertyTest" do
 
   it "tests get all" do
     all = @iface.all_properties
-    expect(all.keys.sort).to eq(["MyArray", "MyDict", "MyStruct", "MyVariant", "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
@@ -68,7 +68,7 @@ describe "PropertyTest" do
     iface = obj["org.ruby.SampleInterface"]
 
     all = iface.all_properties
-    expect(all.keys.sort).to eq(["MyArray", "MyDict", "MyStruct", "MyVariant", "ReadMe", "ReadOrWriteMe"])
+    expect(all.keys.sort).to eq(["MyArray", "MyByte", "MyDict", "MyStruct", "MyVariant", "ReadMe", "ReadOrWriteMe"])
   end
 
   it "tests unknown property reading" do
@@ -163,7 +163,7 @@ describe "PropertyTest" do
     end
   end
 
-  context "an dict-typed property" do
+  context "a dict-typed property" do
     it "gets read as a hash" do
       val = @iface["MyDict"]
       expect(val).to eq({
@@ -172,6 +172,23 @@ describe "PropertyTest" do
                           "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
@@ -183,6 +200,36 @@ describe "PropertyTest" do
     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 RSpect 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)

data/spec/service_newapi.rb

@@ -28,6 +28,8 @@ class Test < DBus::Object
       "three" => [3, 3, 3]
     }
     @my_variant = @my_array.dup
+    # 201 is a RET instruction for ZX Spectrum which has turned 40 recently
+    @my_byte = 201
     @main_loop = nil
   end
 
@@ -111,6 +113,8 @@ class Test < DBus::Object
     dbus_attr_accessor :my_array, "aq"
     dbus_attr_accessor :my_dict, "a{sv}"
     dbus_attr_accessor :my_variant, "v"
+
+    dbus_attr_accessor :my_byte, "y"
   end
 
   # closing and reopening the same interface

data/spec/type_spec.rb

@@ -45,6 +45,7 @@ describe DBus do
       ["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{s", "DICT_ENTRY not closed"],
       ["a{sv", "DICT_ENTRY not closed"],
       ["}", "DICT_ENTRY unexpectedly closed"],
 
@@ -79,4 +80,148 @@ describe DBus do
       end
     end
   end
+
+  describe DBus::Type do
+    let(:as1) { DBus.type("as") }
+    let(:as2) { DBus.type("as") }
+    let(:aas) { DBus.type("aas") }
+
+    describe "#==" do
+      it "is true for same types" do
+        expect(as1).to eq(as2)
+      end
+
+      it "is true for a type and its string representation" do
+        expect(as1).to eq("as")
+      end
+
+      it "is false for different types" do
+        expect(as1).to_not eq(aas)
+      end
+
+      it "is false for a type and a different string" do
+        expect(as1).to_not eq("aas")
+      end
+    end
+
+    describe "#eql?" do
+      it "is true for same types" do
+        expect(as1).to eql(as2)
+      end
+
+      it "is false for a type and its string representation" do
+        expect(as1).to_not eql("as")
+      end
+
+      it "is false for different types" do
+        expect(as1).to_not eql(aas)
+      end
+
+      it "is false for a type and a different string" do
+        expect(as1).to_not eql("aas")
+      end
+    end
+
+    describe "#<<" do
+      it "raises if the argument is not a Type" do
+        t = DBus::Type.new(DBus::Type::ARRAY)
+        expect { t << "s" }.to raise_error(ArgumentError)
+      end
+
+      # TODO: the following raise checks do not occur in practice, as there are
+      # parallel checks in the parses. The code could be simplified?
+      it "raises if adding too much to an array" do
+        t = DBus::Type.new(DBus::Type::ARRAY)
+        b = DBus::Type.new(DBus::Type::BOOLEAN)
+        t << b
+        expect { t << b }.to raise_error(DBus::Type::SignatureException)
+      end
+
+      it "raises if adding too much to a dict_entry" do
+        t = DBus::Type.new(DBus::Type::DICT_ENTRY, abstract: true)
+        b = DBus::Type.new(DBus::Type::BOOLEAN)
+        t << b
+        t << b
+        expect { t << b }.to raise_error(DBus::Type::SignatureException)
+      end
+
+      it "raises if adding to a non-container" do
+        t = DBus::Type.new(DBus::Type::STRING)
+        b = DBus::Type.new(DBus::Type::BOOLEAN)
+        expect { t << b }.to raise_error(DBus::Type::SignatureException)
+
+        t = DBus::Type.new(DBus::Type::VARIANT)
+        expect { t << b }.to raise_error(DBus::Type::SignatureException)
+      end
+    end
+
+    describe DBus::Type::Array do
+      describe ".[]" do
+        it "takes Type argument" do
+          t = DBus::Type::Array[DBus::Type.new("s")]
+          expect(t.to_s).to eq "as"
+        end
+
+        it "takes 's':String argument" do
+          t = DBus::Type::Array["s"]
+          expect(t.to_s).to eq "as"
+        end
+
+        it "takes String:Class argument" do
+          t = DBus::Type::Array[String]
+          expect(t.to_s).to eq "as"
+        end
+
+        it "rejects Integer:Class argument" do
+          expect { DBus::Type::Array[Integer] }.to raise_error(ArgumentError)
+        end
+
+        it "rejects /./:Regexp argument" do
+          expect { DBus::Type::Array[/./] }.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    describe DBus::Type::Hash do
+      describe ".[]" do
+        it "takes Type arguments" do
+          t = DBus::Type::Hash[DBus::Type.new("s"), DBus::Type.new("v")]
+          expect(t.to_s).to eq "a{sv}"
+        end
+
+        it "takes 's':String arguments" do
+          t = DBus::Type::Hash["s", "v"]
+          expect(t.to_s).to eq "a{sv}"
+        end
+
+        it "takes String:Class argument" do
+          t = DBus::Type::Hash[String, DBus::Type::VARIANT]
+          expect(t.to_s).to eq "a{sv}"
+        end
+      end
+    end
+
+    describe DBus::Type::Struct do
+      describe ".[]" do
+        it "takes Type arguments" do
+          t = DBus::Type::Struct[DBus::Type.new("s"), DBus::Type.new("v")]
+          expect(t.to_s).to eq "(sv)"
+        end
+
+        it "takes 's':String arguments" do
+          t = DBus::Type::Struct["s", "v"]
+          expect(t.to_s).to eq "(sv)"
+        end
+
+        it "takes String:Class argument" do
+          t = DBus::Type::Struct[String, DBus::Type::VARIANT]
+          expect(t.to_s).to eq "(sv)"
+        end
+
+        it "raises on no arguments" do
+          expect { DBus::Type::Struct[] }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-dbus
 version: !ruby/object:Gem::Version
-  version: 0.18.0.beta4
+  version: 0.18.0.beta7
 platform: ruby
 authors:
 - Ruby DBus Team
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-21 00:00:00.000000000 Z
+date: 2022-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rexml
@@ -202,7 +202,7 @@ homepage: https://github.com/mvidner/ruby-dbus
 licenses:
 - LGPL-2.1
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -217,9 +217,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.3
-signing_key: 
+rubygems_version: 3.3.0.dev
+signing_key:
 specification_version: 4
 summary: Ruby module for interaction with D-Bus
 test_files: []