ruby-dbus-openplacos 0.6.0

data/test/dbus-launch-simple

@@ -0,0 +1,35 @@
+#! /bin/sh
+# A wrapper for DBus tests
+# Reimplementing dbus-launch because it is in dbus-1-x11.rpm
+# Sets up a private session bus and call the specified program
+set -o errexit
+
+# This launches the bus daemon,
+# exports DBUS_SESSION_BUS_ADDRESS and sets DBUS_SESSION_BUS_PID
+my_dbus_launch () {
+    # reimplementing dbus-launch because it is in dbus-1-x11.rpm
+    PF=`mktemp dbus.pid.XXXXXX` || exit
+    AF=`mktemp dbus.addr.XXXXXX` || exit
+    RM_FILES="$RM_FILES $PF $AF"
+
+    dbus-daemon --config-file=dbus-limited-session.conf --print-address=3 3>$AF --print-pid=4 4>$PF &
+    # wait for the daemon to print the info
+    TRIES=0
+    while [ ! -s $AF -o ! -s $PF ]; do
+	sleep 0.1
+	TRIES=`expr $TRIES + 1`
+	if [ $TRIES -gt 100 ]; then echo "dbus-daemon failed?"; exit 1; fi
+    done
+    DBUS_SESSION_BUS_PID=$(cat $PF)
+    export DBUS_SESSION_BUS_ADDRESS=$(cat $AF)
+    KILLS="$KILLS $DBUS_SESSION_BUS_PID"
+#    dbus-monitor &
+}
+
+my_dbus_launch
+
+# Clean up at exit.
+trap "kill \$KILLS; rm -rf \$RM_FILES" EXIT TERM INT
+
+# run the payload; the return value is passed on
+"$@"

data/test/dbus-limited-session.conf

@@ -0,0 +1,28 @@
+<!-- This configuration file controls the testing message bus.
+     It is based on a session bus config. -->
+
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-Bus Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+  <!-- Our well-known bus type, don't change this -->
+  <type>session</type>
+
+  <listen>unix:tmpdir=/tmp</listen>
+  <listen>tcp:host=localhost,port=0,family=ipv4</listen>
+
+  <standard_session_servicedirs />
+
+  <policy context="default">
+    <!-- Allow everything to be sent -->
+    <allow send_destination="*" eavesdrop="true"/>
+    <!-- Allow everything to be received -->
+    <allow eavesdrop="true"/>
+    <!-- Allow anyone to own anything -->
+    <allow own="*"/>
+  </policy>
+
+  <!-- Do not increase the limits.
+       Instead, lower some so that we can test resource leaks. -->
+  <limit name="max_match_rules_per_connection">50</limit><!-- was 512 -->
+
+</busconfig>

data/test/property_test.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+require "test/unit"
+require "dbus"
+
+class PropertyTest < Test::Unit::TestCase
+  def setup
+    session_bus = DBus::ASessionBus.new
+    svc = session_bus.service("org.ruby.service")
+    @obj = svc.object("/org/ruby/MyInstance")
+    @obj.introspect
+    @iface = @obj["org.ruby.SampleInterface"]
+  end
+
+  def test_property_reading
+    assert_equal "READ ME", @iface["ReadMe"]
+  end
+
+  def test_property_nonreading
+    e = assert_raises DBus::Error do
+      @iface["WriteMe"]
+    end
+    assert_match(/not readable/, e.to_s)
+  end
+
+  def test_property_writing
+    @iface["ReadOrWriteMe"] = "VALUE"
+    assert_equal "VALUE", @iface["ReadOrWriteMe"]
+  end
+
+  def test_property_nonwriting
+    e = assert_raises DBus::Error do
+      @iface["ReadMe"] = "WROTE"
+    end
+    assert_match(/not writable/, e.to_s)
+  end
+
+  def test_get_all
+    all = @iface.all_properties
+    assert_equal ["ReadMe", "ReadOrWriteMe"], all.keys.sort
+  end
+
+  def test_unknown_property_reading
+    e = assert_raises DBus::Error do
+      @iface["Spoon"]
+    end
+    assert_match(/not found/, e.to_s)
+  end
+
+  def test_unknown_property_writing
+    e = assert_raises DBus::Error do
+      @iface["Spoon"] = "FORK"
+    end
+    assert_match(/not found/, e.to_s)
+  end
+end

data/test/server_robustness_test.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+# Test that a server survives various error cases
+require "test/unit"
+require "dbus"
+
+class ServerRobustnessTest < Test::Unit::TestCase
+  def setup
+    @bus = DBus::ASessionBus.new
+    @svc = @bus.service("org.ruby.service")
+  end
+
+  # https://trac.luon.net/ruby-dbus/ticket/31
+  # the server should not crash
+  def test_no_such_path_with_introspection
+    obj = @svc.object "/org/ruby/NotMyInstance"
+    obj.introspect
+    assert false, "should have raised"
+  rescue DBus::Error => e
+    assert_no_match(/timeout/, e.to_s)
+  end
+
+  def test_no_such_path_without_introspection
+    obj = @svc.object "/org/ruby/NotMyInstance"
+    ifc = DBus::ProxyObjectInterface.new(obj, "org.ruby.SampleInterface")
+    ifc.define_method("the_answer", "out n:i")
+    ifc.the_answer
+    assert false, "should have raised"
+  rescue DBus::Error => e
+    assert_no_match(/timeout/, e.to_s)
+  end
+
+  def test_a_method_that_raises
+    obj = @svc.object "/org/ruby/MyInstance"
+    obj.introspect
+    obj.default_iface = "org.ruby.SampleInterface"
+    obj.will_raise
+    assert false, "should have raised"
+  rescue DBus::Error => e
+    assert_no_match(/timeout/, e.to_s)
+  end
+
+  def test_a_method_that_raises_name_error
+    obj = @svc.object "/org/ruby/MyInstance"
+    obj.introspect
+    obj.default_iface = "org.ruby.SampleInterface"
+    obj.will_raise_name_error
+    assert false, "should have raised"
+  rescue DBus::Error => e
+    assert_no_match(/timeout/, e.to_s)
+  end
+
+  # https://trac.luon.net/ruby-dbus/ticket/31#comment:3
+  def test_no_such_method_without_introspection
+    obj = @svc.object "/org/ruby/MyInstance"
+    ifc = DBus::ProxyObjectInterface.new(obj, "org.ruby.SampleInterface")
+    ifc.define_method("not_the_answer", "out n:i")
+    ifc.not_the_answer
+    assert false, "should have raised"
+  rescue DBus::Error => e
+    assert_no_match(/timeout/, e)
+  end
+
+  def test_no_such_interface_without_introspection
+    obj = @svc.object "/org/ruby/MyInstance"
+    ifc = DBus::ProxyObjectInterface.new(obj, "org.ruby.NoSuchInterface")
+    ifc.define_method("the_answer", "out n:i")
+    ifc.the_answer
+    assert false, "should have raised"
+  rescue DBus::Error => e
+    assert_no_match(/timeout/, e)
+  end
+end

data/test/server_test.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# Test that a server survives various error cases
+require "test/unit"
+require "dbus"
+
+class Foo < DBus::Object
+  dbus_interface "org.ruby.ServerTest" do
+    dbus_signal :signal_without_arguments
+    dbus_signal :signal_with_argument, "epsilon:d"
+  end
+
+  dbus_signal :signal_without_interface
+rescue DBus::Object::UndefinedInterface => e
+  # raised by the preceding signal declaration
+end
+
+class Bar < DBus::Object
+  dbus_interface "org.ruby.ServerTest" do
+    # a valid Ruby symbol but an invalid DBus name; Ticket#38
+    dbus_signal :signal_with_a_bang!
+  end
+rescue DBus::InvalidMethodName
+  # raised by the preceding signal declaration
+end
+
+class ServerTest < Test::Unit::TestCase
+  def setup
+    @bus = DBus::ASessionBus.new
+    @svc = @bus.request_service "org.ruby.server-test"
+  end
+
+  def teardown
+    @bus.proxy.ReleaseName "org.ruby.server-test"
+  end
+
+  def test_unexporting_an_object
+    obj = Foo.new "/org/ruby/Foo"
+    @svc.export obj
+    assert @svc.unexport(obj)
+  end
+
+  def test_unexporting_an_object_not_exported
+    obj = Foo.new "/org/ruby/Foo"
+    assert !@svc.unexport(obj)
+  end
+
+  def test_emiting_signals
+    obj = Foo.new "/org/ruby/Foo"
+    @svc.export obj
+    obj.signal_without_arguments    
+    obj.signal_with_argument(-0.1)
+  end
+end

data/test/service_newapi.rb

@@ -0,0 +1,197 @@
+#!/usr/bin/env ruby
+
+# find the library without external help
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'dbus'
+
+def d(msg)
+  puts "#{$$} #{msg}" if $DEBUG
+end
+
+PROPERTY_INTERFACE = "org.freedesktop.DBus.Properties"
+
+class Test < DBus::Object
+  INTERFACE = "org.ruby.SampleInterface"
+  def initialize(path)
+    super path
+    @read_me = "READ ME"
+    @read_or_write_me = "READ OR WRITE ME"
+  end
+
+  # Create an interface aggregating all upcoming dbus_method defines.
+  dbus_interface INTERFACE do
+    dbus_method :hello, "in name:s, in name2:s" do |name, name2|
+      puts "hello(#{name}, #{name2})"
+    end
+
+    dbus_method :test_variant, "in stuff:v" do |variant|
+      p variant
+    end
+
+    dbus_method :bounce_variant, "in stuff:v, out chaff:v" do |variant|
+      [variant]
+    end
+
+    dbus_method :variant_size, "in stuff:v, out size:u" do |variant|
+      [variant.size]
+    end
+
+    dbus_method :the_answer, "out answer:i" do
+      42
+    end
+
+    dbus_method :will_raise, "" do
+      raise "Handle this"
+    end
+
+    dbus_method :will_raise_error_failed, "" do
+      raise DBus.error, "failed as designed"
+    end
+
+    dbus_method :will_raise_name_error, "" do
+      "foo".frobnicate
+    end
+
+    dbus_method :Error, "in name:s, in description:s" do |name, description|
+      raise DBus.error(name), description
+    end
+
+    dbus_signal :SomethingJustHappened, "toto:s, tutu:u"
+  end
+
+  dbus_interface "org.ruby.AnotherInterface" do
+    dbus_method :ThatsALongMethodNameIThink do
+      puts "ThatsALongMethodNameIThink"
+    end
+    dbus_method :Reverse, "in instr:s, out outstr:s" do |instr|
+      outstr = instr.split(//).reverse.join
+      puts "got: #{instr}, replying: #{outstr}"
+      [outstr]
+    end
+  end
+
+  dbus_interface "org.ruby.Ticket30" do
+    dbus_method :Sybilla, 'in choices:av, out advice:s' do |choices|
+      ["Do #{choices[0]}"]
+    end
+  end
+
+  dbus_interface "org.ruby.Loop" do
+    # starts doing something long, but returns immediately
+    # and sends a signal when done
+    dbus_method :LongTaskBegin, 'in delay:i' do |delay|
+# FIXME did not complain about mismatch between signature and block args
+      d "Long task began"
+      task = Thread.new do
+        d "Long task thread started (#{delay}s)"
+        sleep delay
+        d "Long task will signal end"
+        self.LongTaskEnd
+      end
+      task.abort_on_exception = true # protect from test case bugs
+    end
+
+    dbus_signal :LongTaskEnd
+  end
+
+  # Properties:
+  # ReadMe:string, returns "READ ME" at first, then what WriteMe received
+  # WriteMe:string
+  # ReadOrWriteMe:string, returns "READ OR WRITE ME" at first
+  dbus_interface PROPERTY_INTERFACE do
+    dbus_method :Get, "in interface:s, in propname:s, out value:v" do |interface, propname|
+      if interface == INTERFACE
+        if propname == "ReadMe"
+          [@read_me]
+        elsif propname == "ReadOrWriteMe"
+          [@read_or_write_me]
+        elsif propname == "WriteMe"
+          raise DBus.error("org.freedesktop.DBus.Error.InvalidArgs"), "Property '#{interface}.#{propname}' (on object '#{@path}') is not readable"
+        else
+          raise DBus.error("org.freedesktop.DBus.Error.InvalidArgs"), "Property '#{interface}.#{propname}' not found on object '#{@path}'"
+        end
+      else
+        raise DBus.error("org.freedesktop.DBus.Error.UnknownInterface"), "Interface '#{interface}' not found on object '#{@path}'"
+      end
+# what should happen for unknown properties
+# plasma: InvalidArgs (propname), UnknownInterface (interface)
+    end
+
+    dbus_method :Set, "in interface:s, in propname:s, in  value:v" do |interface, propname, value|
+      if interface == INTERFACE
+        if propname == "ReadMe"
+          raise DBus.error("org.freedesktop.DBus.Error.InvalidArgs"), "Property '#{interface}.#{propname}' (on object '#{@path}') is not writable"
+        elsif propname == "ReadOrWriteMe"
+          @read_or_write_me = value
+          self.PropertiesChanged(interface, {propname => value}, [])
+        elsif propname == "WriteMe"
+          @read_me = value
+          self.PropertiesChanged(interface, {"ReadMe" => value}, [])
+        else
+          raise DBus.error("org.freedesktop.DBus.Error.InvalidArgs"), "Property '#{interface}.#{propname}' not found on object '#{@path}'"
+        end
+      else
+        raise DBus.error("org.freedesktop.DBus.Error.UnknownInterface"), "Interface '#{interface}' not found on object '#{@path}'"
+      end
+    end
+
+    dbus_method :GetAll, "in interface:s, out value:a{sv}" do |interface|
+      if interface == INTERFACE
+        [ {
+            "ReadMe" => @read_me,
+            "ReadOrWriteMe" =>@read_or_write_me,
+          } ]
+      else
+        raise DBus.error("org.freedesktop.DBus.Error.UnknownInterface"), "Interface '#{interface}' not found on object '#{@path}'"
+      end
+    end
+
+    dbus_signal :PropertiesChanged, "interface:s, changed_properties:a{sv}, invalidated_properties:as"
+  end
+end
+
+class Derived < Test
+end
+
+class Test2 < DBus::Object
+  dbus_interface "org.ruby.Test2" do
+    dbus_method :hi, "in name:s, out greeting:s" do |name|
+      "Hi, #{name}!"
+    end
+  end
+end
+
+bus = DBus::SessionBus.instance
+service = bus.request_service("org.ruby.service")
+myobj = Test.new("/org/ruby/MyInstance")
+service.export(myobj)
+derived = Derived.new "/org/ruby/MyDerivedInstance"
+service.export derived
+test2 = Test2.new "/org/ruby/MyInstance2"
+service.export test2 
+
+# introspect every other connection, Ticket #34
+#  (except the one that activates us - it has already emitted
+#  NOC by the time we run this. Therefore the test for #34 will not work
+#  by running t2.rb alone, one has to run t1 before it; 'rake' does it)
+mr = DBus::MatchRule.new.from_s "type='signal',interface='org.freedesktop.DBus',member='NameOwnerChanged'"
+bus.add_match(mr) do |msg|
+  new_unique_name = msg.params[2]
+  unless new_unique_name.empty?
+    d "RRRING #{new_unique_name}"
+    bus.introspect_data(new_unique_name, "/") do
+      # ignore the result
+    end
+  end
+end
+
+puts "listening"
+main = DBus::Main.new
+main << bus
+begin
+  main.run
+rescue SystemCallError
+  # the test driver will kill the bus, that's OK
+end
+

data/test/session_bus_test_manual.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require "test/unit"
+require "dbus"
+
+def d(msg)
+  puts msg if $DEBUG
+end
+
+class SessionBusAddressTest < Test::Unit::TestCase
+  def setup
+    # test getting the session bus address even if unset in ENV (Issue#4)
+    ENV.delete "DBUS_SESSION_BUS_ADDRESS"
+    @bus = DBus::ASessionBus.new
+    @svc = @bus.service("org.freedesktop.DBus")
+  end
+
+  def test_connection
+    assert @svc.exists?
+  end
+end

data/test/signal_test.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+# Test the signal handlers
+require "test/unit"
+require "dbus"
+
+def d(msg)
+  puts "#{$$} #{msg}" if $DEBUG
+end
+
+class SignalHandlerTest < Test::Unit::TestCase
+  def setup
+    @session_bus = DBus::ASessionBus.new
+    svc = @session_bus.service("org.ruby.service")
+    @obj = svc.object("/org/ruby/MyInstance")
+    @obj.introspect                  # necessary
+    @obj.default_iface = "org.ruby.Loop"
+
+    @loop = DBus::Main.new
+    @loop << @session_bus
+  end
+
+  # testing for commit 017c83 (kkaempf)
+  def test_overriding_a_handler
+    counter = 0
+
+    @obj.on_signal "LongTaskEnd" do
+      d "+10"
+      counter += 10
+    end
+    @obj.on_signal "LongTaskEnd" do
+      d "+1"
+      counter += 1
+    end
+
+    d "will begin"
+    @obj.LongTaskBegin 3
+
+    quitter = Thread.new do
+      d "sleep before quit"
+      # FIXME if we sleep for too long
+      # the socket will be drained and we deadlock in a select.
+      # It could be worked around by sending ourselves a Unix signal
+      # (with a dummy handler) to interrupt the select
+      sleep 1
+      d "will quit"
+      @loop.quit
+    end
+    @loop.run
+
+    assert_equal 1, counter
+  end
+
+  def test_too_many_rules
+    100.times do
+      @obj.on_signal "Whichever" do
+        puts "not called"
+      end
+    end
+  end
+
+  def test_removing_a_nonexistent_rule
+    @obj.on_signal "DoesNotExist"
+  end
+end

data/test/t1

@@ -0,0 +1,4 @@
+#! /bin/sh
+SEND0="dbus-send  --session --dest=org.ruby.service"
+CALL="$SEND0 --type=method_call --print-reply"
+$CALL /org/ruby/MyInstance org.ruby.AnotherInterface.Reverse string:Hello

data/test/t2.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+require "test/unit"
+require "dbus"
+
+class ValueTest < Test::Unit::TestCase
+  def setup
+    session_bus = DBus::ASessionBus.new
+    svc = session_bus.service("org.ruby.service")
+    @obj = svc.object("/org/ruby/MyInstance")
+    @obj.introspect                  # necessary
+    @obj.default_iface = "org.ruby.SampleInterface"
+  end
+
+  def test_passing_an_array_through_a_variant
+    # old explicit typing
+    @obj.test_variant(["as", ["coucou", "kuku"]])
+    # automatic typing
+    @obj.test_variant(["coucou", "kuku"])
+    @obj.test_variant(["saint", "was that a word or a signature?"])
+  end
+
+  def test_bouncing_a_variant
+    assert_equal "cuckoo", @obj.bounce_variant("cuckoo")[0]
+    assert_equal ["coucou", "kuku"], @obj.bounce_variant(["coucou", "kuku"])[0]
+    assert_equal [], @obj.bounce_variant([])[0]
+    empty_hash = {}
+    assert_equal empty_hash, @obj.bounce_variant(empty_hash)[0]
+  end
+  
+  # these are ambiguous
+  def test_pairs_with_a_string
+    
+    # deprecated
+    assert_equal "foo", @obj.bounce_variant(["s", "foo"])[0]
+    
+    assert_equal "foo", @obj.bounce_variant(DBus.variant("s", "foo"))[0]
+    assert_equal "foo", @obj.bounce_variant([DBus.type("s"), "foo"])[0]
+
+    # does not work, because the server side forgets the explicit typing
+#    assert_equal ["s", "foo"], @obj.bounce_variant(["av", ["s", "foo"]])[0]
+#    assert_equal ["s", "foo"], @obj.bounce_variant(["as", ["s", "foo"]])[0]
+
+    # instead, use this to demonstrate that the variant is passed as expected
+    assert_equal 4, @obj.variant_size(["s", "four"])[0]
+    # "av" is the simplest thing that will work,
+    # shifting the heuristic from a pair to the individual items
+    assert_equal 2, @obj.variant_size(["av", ["s", "four"]])[0]
+  end
+
+  def test_marshalling_an_array_of_variants
+    # https://trac.luon.net/ruby-dbus/ticket/30
+    @obj.default_iface = "org.ruby.Ticket30"
+    choices = []
+    choices << ['s', 'Plan A']
+    choices << ['s', 'Plan B']
+    # old explicit typing
+    assert_equal "Do Plan A", @obj.Sybilla(choices)[0]
+    # automatic typing
+    assert_equal "Do Plan A", @obj.Sybilla(["Plan A", "Plan B"])[0]
+  end
+
+  def test_service_returning_nonarray
+    # "warning: default `to_a' will be obsolete"
+    @obj.the_answer
+  end
+end

data/test/t3-ticket27.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# Test passing a particular struct array through a variant
+# https://trac.luon.net/ruby-dbus/ticket/27
+require "dbus"
+session_bus = DBus::ASessionBus.new
+svc = session_bus.service("org.ruby.service")
+obj = svc.object("/org/ruby/MyInstance")
+obj.introspect                  # necessary
+obj.default_iface = "org.ruby.SampleInterface"
+# The bug is probably alignment related so whether it triggers
+# depends also on the combined length of service, interface,
+# and method names. Luckily here it works out.
+triple = ['a(uuu)', []]
+obj.test_variant(triple)
+quadruple = ['a(uuuu)', []]     # a(uuu) works fine
+# The bus disconnects us because of malformed message,
+# code 12: DBUS_INVALID_TOO_MUCH_DATA
+obj.test_variant(quadruple)

data/test/t5-report-dbus-interface.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# should report it missing on org.ruby.SampleInterface
+# (on object...) instead of on DBus::Proxy::ObjectInterface
+require "test/unit"
+require "dbus"
+
+class ErrMsgTest < Test::Unit::TestCase
+  def setup
+    session_bus = DBus::ASessionBus.new
+    svc = session_bus.service("org.ruby.service")
+    @obj = svc.object("/org/ruby/MyInstance")
+    @obj.introspect                  # necessary
+    @obj.default_iface = "org.ruby.SampleInterface"
+  end
+
+  def test_report_dbus_interface
+    begin
+      @obj.NoSuchMethod
+    # a specific exception...
+    rescue NameError => e
+      # mentioning DBus and the interface
+      assert_match(/DBus interface.*#{@obj.default_iface}/, e.to_s)
+    end
+  end
+
+  def test_report_short_struct
+    begin
+      @obj.test_variant ["(ss)", ["too few"] ]
+    rescue DBus::TypeException => e
+      assert_match(/1 elements but type info for 2/, e.to_s)
+    end
+  end
+
+  def test_report_long_struct
+    begin
+      @obj.test_variant ["(ss)", ["a", "b", "too many"] ]
+    rescue DBus::TypeException => e
+      assert_match(/3 elements but type info for 2/, e.to_s)
+    end
+  end
+
+  def test_report_nil
+    nils = [
+            ["(s)", [nil] ],    # would get disconnected
+            ["i", nil ],
+            ["a{ss}", {"foo" => nil} ],
+           ]
+    nils.each do |has_nil|
+      begin
+        @obj.test_variant has_nil
+      rescue DBus::TypeException => e
+        # TODO want backtrace from the perspective of the caller:
+        # rescue/reraise in send_sync?
+        assert_match(/Cannot send nil/, e.to_s)
+      end
+    end
+  end
+end