em-ruby-dbus 0.11.0

data/test/introspect_xml_parser_spec.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env rspec
+require_relative "spec_helper"
+require "dbus"
+
+describe "IntrospectXMLParserTest" do
+  it "tests split interfaces" do
+    xml = <<EOS
+<node>
+   <interface name="org.example.Foo">
+     <method name="Dwim"/>
+   </interface>
+   <interface name="org.example.Bar">
+     <method name="Drink"/>
+   </interface>
+   <interface name="org.example.Foo">
+     <method name="Smurf"/>
+   </interface>
+</node>
+EOS
+
+    interfaces, _ = DBus::IntrospectXMLParser.new(xml).parse
+
+    foo = interfaces.find {|i| i.name == "org.example.Foo" }
+    expect(foo.methods.keys.size).to eq(2)
+  end
+end

data/test/introspection_spec.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env rspec
+require_relative "spec_helper"
+require "dbus"
+
+describe "IntrospectionTest" do
+  before(:each) do
+    session_bus = DBus::ASessionBus.new
+    svc = session_bus.service("org.ruby.service")
+    @obj = svc.object("/org/ruby/MyInstance")
+    @obj.introspect
+    @obj.default_iface = "org.ruby.SampleInterface"
+  end
+
+  it "tests wrong number of arguments" do
+    expect { @obj.test_variant "too","many","args" }.to raise_error(ArgumentError)
+    # not enough
+    expect { @obj.test_variant }.to raise_error(ArgumentError)
+  end
+
+  it "tests shortcut methods" do
+    @obj.default_iface = nil
+    expect(@obj.bounce_variant("varargs")).to eq(["varargs"])
+    # test for a duplicated method name
+    expect { @obj.the_answer }.to raise_error(NoMethodError)
+    # ensure istance methods of ProxyObject aren't overwritten by remote
+    # methods
+    expect { @obj.interfaces }.not_to raise_error
+
+    @obj.default_iface = "org.ruby.SampleInterface"
+    expect(@obj.the_answer).to eq([42])
+  end
+end

data/test/main_loop_spec.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env rspec
+# Test the main loop
+require_relative "spec_helper"
+require "dbus"
+
+describe "MainLoopTest" do
+  before(:each) do
+    @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
+
+  # Hack the library internals so that there is a delay between
+  # sending a DBus call and listening for its reply, so that
+  # the bus has a chance to join the server messages and a race is reproducible
+  def call_lazily
+    class << @session_bus
+      alias :wait_for_message_orig :wait_for_message
+      def wait_for_message_lazy
+        DBus.logger.debug "I am so lazy"
+        sleep 1    # Give the server+bus a chance to join the messages
+        wait_for_message_orig
+      end
+      alias :wait_for_message :wait_for_message_lazy
+    end
+
+    yield
+
+    # undo
+    class << @session_bus
+      remove_method :wait_for_message
+      remove_method :wait_for_message_lazy
+      alias :wait_for_message :wait_for_message_orig
+    end
+  end
+
+  def test_loop_quit(delay)
+    @obj.on_signal "LongTaskEnd" do
+      DBus.logger.debug "Telling loop to quit"
+      @loop.quit
+    end
+
+    call_lazily do
+      # The method will sleep the requested amount of seconds
+      # (in another thread)  before signalling LongTaskEnd
+      @obj.LongTaskBegin delay
+    end
+
+    # this thread will make the test fail if @loop.run does not return
+    dynamite = Thread.new do
+      DBus.logger.debug "Dynamite burning"
+      sleep 2
+      DBus.logger.debug "Dynamite explodes"
+      # We need to raise in the main thread.
+      # Simply raising here means the exception is ignored
+      # (until dynamite.join which we don't call) or
+      # (if abort_on_exception is set) it terminates the whole script.
+      Thread.main.raise RuntimeError, "The main loop did not quit in time"
+    end
+
+    @loop.run
+    DBus.logger.debug "Defusing dynamite"
+    # if we get here, defuse the bomb
+    dynamite.exit
+    # remove signal handler
+    @obj.on_signal "LongTaskEnd"
+  end
+
+  it "tests loop quit" do
+    test_loop_quit 1
+  end
+
+  # https://bugzilla.novell.com/show_bug.cgi?id=537401
+  it "tests loop drained socket" do
+    test_loop_quit 0
+  end
+end

data/test/property_spec.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env rspec
+require_relative "spec_helper"
+require "dbus"
+
+describe "PropertyTest" do
+  before(:each) do
+    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
+
+  it "tests property reading" do
+    expect(@iface["ReadMe"]).to eq("READ ME")
+  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")
+  end
+
+  # https://github.com/mvidner/ruby-dbus/pull/19
+  it "tests service select timeout" do
+    @iface["ReadOrWriteMe"] = "VALUE"
+    expect(@iface["ReadOrWriteMe"]).to eq("VALUE")
+    # wait for the service to become idle
+    sleep 6
+    # fail:  "Property value changed; perhaps the service died and got restarted"
+    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"])
+  end
+
+  it "tests unknown property reading" do
+    expect { @iface["Spoon"] }.to raise_error(DBus::Error, /not found/)
+  end
+
+  it "tests unknown property writing" do
+    expect { @iface["Spoon"] = "FPRK" }.to raise_error(DBus::Error, /not found/)
+  end
+end

data/test/server_robustness_spec.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env rspec
+# Test that a server survives various error cases
+require_relative "spec_helper"
+require "dbus"
+
+describe "ServerRobustnessTest" do
+  before(:each) do
+    @bus = DBus::ASessionBus.new
+    @svc = @bus.service("org.ruby.service")
+  end
+
+  # https://trac.luon.net/ruby-dbus/ticket/31
+  # the server should not crash
+  it "tests no such path with introspection" do
+    obj = @svc.object "/org/ruby/NotMyInstance"
+    expect { obj.introspect }.to raise_error(DBus::Error) do |e|
+      expect(e).to_not match(/timeout/)
+    end
+  end
+
+  it "tests no such path without introspection" do
+    obj = @svc.object "/org/ruby/NotMyInstance"
+    ifc = DBus::ProxyObjectInterface.new(obj, "org.ruby.SampleInterface")
+    ifc.define_method("the_answer", "out n:i")
+    expect { ifc.the_answer }.to raise_error(DBus::Error) do |e|
+      expect(e).to_not match(/timeout/)
+    end
+  end
+
+  it "tests a method that raises" do
+    obj = @svc.object "/org/ruby/MyInstance"
+    obj.introspect
+    obj.default_iface = "org.ruby.SampleInterface"
+    expect { obj.will_raise }.to raise_error(DBus::Error) do |e|
+      expect(e).to_not match(/timeout/)
+    end
+  end
+
+  it "tests a method that raises name error" do
+    obj = @svc.object "/org/ruby/MyInstance"
+    obj.introspect
+    obj.default_iface = "org.ruby.SampleInterface"
+    expect { obj.will_raise_name_error }.to raise_error(DBus::Error) do |e|
+      expect(e).to_not match(/timeout/)
+    end
+  end
+
+  # https://trac.luon.net/ruby-dbus/ticket/31#comment:3
+  it "tests no such method without introspection" do
+    obj = @svc.object "/org/ruby/MyInstance"
+    ifc = DBus::ProxyObjectInterface.new(obj, "org.ruby.SampleInterface")
+    ifc.define_method("not_the_answer", "out n:i")
+    expect { ifc.not_the_answer }.to raise_error(DBus::Error) do |e|
+      expect(e).to_not match(/timeout/)
+    end
+  end
+
+  it "tests no such interface without introspection" do
+    obj = @svc.object "/org/ruby/MyInstance"
+    ifc = DBus::ProxyObjectInterface.new(obj, "org.ruby.NoSuchInterface")
+    ifc.define_method("the_answer", "out n:i")
+    expect { ifc.the_answer }.to raise_error(DBus::Error) do |e|
+      expect(e).to_not match(/timeout/)
+    end
+  end
+end

data/test/server_spec.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env rspec
+# Test that a server survives various error cases
+require_relative "spec_helper"
+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
+  # 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
+
+describe "ServerTest" do
+  before(:each) do
+    @bus = DBus::ASessionBus.new
+    @svc = @bus.request_service "org.ruby.server-test"
+  end
+
+  after(:each) do
+    @bus.proxy.ReleaseName "org.ruby.server-test"
+  end
+
+  it "tests unexporting an object" do
+    obj = Foo.new "/org/ruby/Foo"
+    @svc.export obj
+    expect(@svc.unexport(obj)).to be_true
+  end
+
+  it "tests unexporting an object not exported" do
+    obj = Foo.new "/org/ruby/Foo"
+    expect(@svc.unexport(obj)).to be_false
+  end
+
+  it "tests emiting signals" do
+    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,217 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require_relative "spec_helper"
+SimpleCov.command_name "Service Tests" if Object.const_defined? "SimpleCov"
+# find the library without external help
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'dbus'
+
+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|
+      DBus.logger.debug variant.inspect
+    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_method :mirror_byte_array, "in bytes:ay, out mirrored:ay" do |bytes|
+      [bytes]
+    end
+  end
+
+  # closing and reopening the same interface
+  dbus_interface INTERFACE do
+    dbus_method :multibyte_string, "out string:s" do
+      "あいうえお"
+    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
+      [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.Duplicates" do
+    dbus_method :the_answer, "out answer:i" do
+      [0]
+    end
+    dbus_method :interfaces, "out answer:i" do
+      raise "This DBus method is currently shadowed by ProxyObject#interfaces"
+    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
+      self.LongTaskStart
+      DBus.logger.debug "Long task began"
+      task = Thread.new do
+        DBus.logger.debug "Long task thread started (#{delay}s)"
+        sleep delay
+        DBus.logger.debug "Long task will signal end"
+        self.LongTaskEnd
+      end
+      task.abort_on_exception = true # protect from test case bugs
+    end
+
+    dbus_signal :LongTaskStart
+    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?
+    DBus.logger.debug "RRRING #{new_unique_name}"
+    bus.introspect_data(new_unique_name, "/") do
+      # ignore the result
+    end
+  end
+end
+
+puts "listening, with ruby-#{RUBY_VERSION}"
+main = DBus::Main.new
+main << bus
+begin
+  main.run
+rescue SystemCallError
+  # the test driver will kill the bus, that's OK
+end
+