em-ruby-dbus 0.11.0

data/test/session_bus_spec_manual.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env rspec
+require_relative "spec_helper"
+require "dbus"
+
+describe DBus::ASessionBus do
+  context "when DBUS_SESSION_BUS_ADDRESS is unset in ENV (Issue#4)" do
+    ENV.delete "DBUS_SESSION_BUS_ADDRESS"
+
+    it "can connect" do
+      bus = DBus::ASessionBus.new
+      svc = bus.service("org.freedesktop.DBus")
+      expect(svc.exists?).to be_true
+    end
+  end
+end

data/test/signal_spec.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env rspec
+# Test the signal handlers
+require_relative "spec_helper"
+require "dbus"
+
+describe "SignalHandlerTest" 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"
+    @intf = @obj["org.ruby.Loop"]
+
+    @loop = DBus::Main.new
+    @loop << @session_bus
+  end
+
+  # testing for commit 017c83 (kkaempf)
+  it "tests overriding a handler" do
+    DBus.logger.debug "Inside test_overriding_a_handler"
+    counter = 0
+
+    @obj.on_signal "LongTaskEnd" do
+      DBus.logger.debug "+10"
+      counter += 10
+    end
+    @obj.on_signal "LongTaskEnd" do
+      DBus.logger.debug "+1"
+      counter += 1
+    end
+
+    DBus.logger.debug "will begin"
+    @obj.LongTaskBegin 3
+
+    quitter = Thread.new do
+      DBus.logger.debug "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
+      DBus.logger.debug "will quit"
+      @loop.quit
+    end
+    @loop.run
+    quitter.join
+
+    expect(counter).to eq(1)
+  end
+
+  it "tests on signal overload" do
+    DBus.logger.debug "Inside test_on_signal_overload"
+    counter = 0
+    started = false
+    @intf.on_signal "LongTaskStart" do
+      started = true
+    end
+    # Same as intf.on_signal("LongTaskEnd"), just the old way
+    @intf.on_signal @obj.bus, "LongTaskEnd" do
+      counter += 1
+    end
+    @obj.LongTaskBegin 3
+    quitter = Thread.new do
+      DBus.logger.debug "sleep before quit"
+      sleep 1
+      DBus.logger.debug "will quit"
+      @loop.quit
+    end
+    @loop.run
+    quitter.join
+
+    expect(started).to eq(true)
+    expect(counter).to eq(1)
+    expect { @intf.on_signal }.to raise_error(ArgumentError) # not enough
+    expect { @intf.on_signal 'to', 'many', 'yarrrrr!' }.to raise_error(ArgumentError)
+  end
+
+  it "tests too many rules" do
+    100.times do
+      @obj.on_signal "Whichever" do
+        puts "not called"
+      end
+    end
+  end
+
+  it "tests removing a nonexistent rule" do
+    @obj.on_signal "DoesNotExist"
+  end
+end

data/test/spec_helper.rb

@@ -0,0 +1,33 @@
+if ENV["COVERAGE"]
+  coverage = ENV["COVERAGE"] == "true"
+else
+  # heuristics: enable for interactive builds (but not in OBS) or in Travis
+  coverage = !!ENV["DISPLAY"] || ENV["TRAVIS"]
+end
+
+if coverage
+  require "simplecov"
+  SimpleCov.root File.expand_path("../..", __FILE__)
+
+  # do not cover specs
+  SimpleCov.add_filter "_spec.rb"
+  # do not cover the activesupport helpers
+  SimpleCov.add_filter "/core_ext/"
+
+  # use coveralls for on-line code coverage reporting at Travis CI
+  if ENV["TRAVIS"]
+    require "coveralls"
+  end
+  SimpleCov.start
+end
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+if Object.const_defined? "RSpec"
+  # http://betterspecs.org/#expect
+  RSpec.configure do |config|
+    config.expect_with :rspec do |c|
+      c.syntax = :expect
+    end
+  end
+end

data/test/thread_safety_spec.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env rspec
+# Test thread safety
+require_relative "spec_helper"
+require "dbus"
+
+describe "ThreadSafetyTest" do
+  it "tests thread competition" do
+    print "Thread competition: "
+    jobs = []
+    5.times do
+      jobs << Thread.new do
+        Thread.current.abort_on_exception = true
+
+        # use separate connections to avoid races
+        bus = DBus::ASessionBus.new
+        svc = bus.service("org.ruby.service")
+        obj = svc.object("/org/ruby/MyInstance")
+        obj.introspect
+        obj.default_iface = "org.ruby.SampleInterface"
+
+        10.times do |i|
+          print "#{i} "
+          $stdout.flush
+          expect(obj.the_answer[0]).to eq(42)
+          sleep 0.1 * rand
+        end
+      end
+    end
+    jobs.each do |thread| thread.join end
+  end
+end

data/test/tools/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/tools/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=127.0.0.1</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/tools/test_env

@@ -0,0 +1,13 @@
+#! /bin/bash
+# test_env: set up the environment needed to run tests:
+# - set up a private bus
+# - run a test server on it
+
+#export DBUS_VERBOSE=1
+#export RUBYOPT="-d"
+export RUBYOPT="$RUBYOPT -w"
+./test_server \
+	../service_newapi.rb \
+	-- \
+	./dbus-launch-simple \
+	"$@"

data/test/tools/test_server

@@ -0,0 +1,39 @@
+#! /bin/sh
+# A wrapper for DBus tests
+# Run a server (directly or by dbus activation) and then the test
+# $0 server [args...] -- test [args...]
+set -o errexit
+
+while [ "$1" != "--" ]; do
+  SERVER="$SERVER $1"
+  shift
+done
+shift # --
+
+setup_activation () {
+    SDIR=$XDG_DATA_DIRS/dbus-1/services
+    mkdir -p $SDIR
+    # FIXME Name is hardcoded
+    cat <<EOF > $SDIR/test.service
+[D-BUS Service]
+Name=org.ruby.service
+Exec=$SERVER
+EOF
+}
+
+run_server () {
+    echo -n "Hey, server, get on da bus... "
+    # start the server
+    $SERVER & sleep 3
+    echo "off we go!"
+}
+
+export XDG_DATA_DIRS=`mktemp -d dbus.activation.XXXXXX`
+RM_FILES="$RM_FILES $XDG_DATA_DIRS"
+setup_activation
+#run_server
+
+# Clean up at exit.
+trap "rm -rf \$RM_FILES" EXIT TERM INT
+
+"$@"

data/test/type_spec.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env rspec
+require_relative "spec_helper"
+require "dbus"
+
+describe DBus do
+  describe ".type" do
+    %w{i ai a(ii) aai}.each do |s|
+      it "parses some type #{s}" do
+        expect(DBus::type(s).to_s).to be_eql s
+      end
+    end
+
+    %w{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
+      end
+    end
+  end
+end

data/test/value_spec.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env rspec
+# -*- coding: utf-8 -*-
+require_relative "spec_helper"
+require "dbus"
+
+describe "ValueTest" 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.SampleInterface"
+  end
+
+  it "tests passing an array of structs through a variant" do
+    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)
+  end
+
+  it "tests passing an array through a variant" do
+    # 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
+
+  it "tests bouncing a variant" do
+    expect(@obj.bounce_variant("cuckoo")[0]).to eq("cuckoo")
+    expect(@obj.bounce_variant(["coucou", "kuku"])[0]).to eq(["coucou", "kuku"])
+    expect(@obj.bounce_variant([])[0]).to eq([])
+    empty_hash = {}
+    expect(@obj.bounce_variant(empty_hash)[0]).to eq(empty_hash)
+  end
+  
+  # these are ambiguous
+  it "tests pairs with a string" do
+    
+    # deprecated
+    expect(@obj.bounce_variant(["s", "foo"])[0]).to eq("foo")
+    
+    expect(@obj.bounce_variant(DBus.variant("s", "foo"))[0]).to eq("foo")
+    expect(@obj.bounce_variant([DBus.type("s"), "foo"])[0]).to eq("foo")
+
+    # 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
+    expect(@obj.variant_size(["s", "four"])[0]).to eq(4)
+    # "av" is the simplest thing that will work,
+    # shifting the heuristic from a pair to the individual items
+    expect(@obj.variant_size(["av", ["s", "four"]])[0]).to eq(2)
+  end
+
+  it "tests marshalling an array of variants" do
+    # 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
+    expect(@obj.Sybilla(choices)[0]).to eq("Do Plan A")
+    # automatic typing
+    expect(@obj.Sybilla(["Plan A", "Plan B"])[0]).to eq("Do Plan A")
+  end
+
+  it "tests service returning nonarray" do
+    # "warning: default `to_a' will be obsolete"
+    @obj.the_answer
+  end
+
+  it "tests multibyte string" do
+    str = @obj.multibyte_string[0]
+    expect(str).to eq("あいうえお")
+  end
+end

data/test/variant_spec.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env rspec
+# Test marshalling variants according to ruby types
+require_relative "spec_helper"
+require "dbus"
+
+describe "VariantTest" do
+  before(:each) do
+    @bus = DBus::ASessionBus.new
+    @svc = @bus.service("org.ruby.service")
+  end
+
+  def make_variant(a)
+    DBus::PacketMarshaller.make_variant(a)
+  end
+
+  it "tests make variant scalar" do
+    # special case: do not fail immediately, marshaller will do that
+    expect(make_variant(nil)).to eq(["b", nil])
+
+    expect(make_variant(true)).to eq(["b", true])
+    # Integers
+    # no byte
+    expect(make_variant(42)).to eq(["i", 42])
+    # 3_000_000_000 can be u or x.
+    # less specific test: just run it thru a loopback
+    expect(make_variant(3_000_000_000)).to eq(["x", 3_000_000_000])
+    expect(make_variant(5_000_000_000)).to eq(["x", 5_000_000_000])
+ 
+    expect(make_variant(3.14)).to eq(["d", 3.14])
+
+    expect(make_variant("foo")).to eq(["s", "foo"])
+    expect(make_variant(:bar)).to eq(["s", "bar"])
+
+    # left: strruct, array, dict
+    # object path: detect exported objects?, signature
+
+#    # by Ruby types
+#    class Foo
+#    end
+#    make_variant(Foo.new)
+# if we don;t understand a class, the error should be informative -> new exception
+  end
+
+  it "tests make variant array" do
+    ai = [1, 2, 3]
+#    as = ["one", "two", "three"]
+   # which?
+#    expect(make_variant(ai)).to eq(["ai", [1, 2, 3]])
+    expect(make_variant(ai)).to eq(["av", [["i", 1],
+                         ["i", 2],
+                         ["i", 3]]])
+    a0 = []
+    expect(make_variant(a0)).to eq(["av", []])
+
+  end
+
+  it "tests make variant hash" do
+    h = {"k1" => "v1", "k2" => "v2"}
+    expect(make_variant(h)).to eq(["a{sv}", {
+                    "k1" => ["s", "v1"],
+                    "k2" => ["s", "v2"],
+                  }])
+    h0 = {}
+    expect(make_variant(h0)).to eq(["a{sv}", {}])
+  end
+end