circus-deployment 0.0.1

data/vendor/ruby-dbus/test/Makefile

@@ -0,0 +1,4 @@
+check:
+	./test_all
+test: check
+.PHONY: test check

data/vendor/ruby-dbus/test/bus_driver_test.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# Test the methods of the bus driver
+require "test/unit"
+require "dbus"
+
+def d(msg)
+  puts msg if $DEBUG
+end
+
+class BusDriverTest < Test::Unit::TestCase
+  def setup
+    @bus = DBus::SessionBus.instance
+    @svc = @bus.service("org.ruby.service")
+  end
+
+  def test_exists
+    assert @svc.exists?
+    nonsvc = @bus.service "org.ruby.nosuchservice"
+    assert ! nonsvc.exists?
+  end
+end

data/vendor/ruby-dbus/test/server_robustness_test.rb

@@ -0,0 +1,41 @@
+#!/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::SessionBus.instance
+    @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)
+  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)
+  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)
+  end
+end

data/vendor/ruby-dbus/test/server_test.rb

@@ -0,0 +1,44 @@
+#!/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 ServerTest < Test::Unit::TestCase
+  def setup
+    @bus = DBus::SessionBus.instance
+    @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/vendor/ruby-dbus/test/service_newapi.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+
+require 'dbus'
+
+def d(msg)
+  puts "#{$$} #{msg}" if $DEBUG
+end
+
+class Test < DBus::Object
+  # Create an interface aggregating all upcoming dbus_method defines.
+  dbus_interface "org.ruby.SampleInterface" 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_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
+end
+
+bus = DBus::SessionBus.instance
+service = bus.request_service("org.ruby.service")
+myobj = Test.new("/org/ruby/MyInstance")
+service.export(myobj)
+
+# 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?
+    # puts "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
+main.run
+

data/vendor/ruby-dbus/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::SessionBus.instance
+    @svc = @bus.service("org.freedesktop.DBus")
+  end
+
+  def test_connection
+    assert @svc.exists?
+  end
+end

data/vendor/ruby-dbus/test/signal_test.rb

@@ -0,0 +1,57 @@
+#!/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::SessionBus.instance
+    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
+
+  def teardown
+    # workaround for nonexisting remove_match
+    @session_bus.instance_variable_set(:@signal_matchrules, [])
+  end
+
+  # testing for commit 017c83 (kkaempf)
+  def test_calling_both_handlers
+    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 11, counter
+  end
+end

data/vendor/ruby-dbus/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/vendor/ruby-dbus/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::SessionBus.instance
+    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/vendor/ruby-dbus/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::SessionBus.instance
+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/vendor/ruby-dbus/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::SessionBus.instance
+    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

data/vendor/ruby-dbus/test/t6-loop.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+# Test the main loop
+require "test/unit"
+require "dbus"
+
+def d(msg)
+  puts "#{$$} #{msg}" if $DEBUG
+end
+
+class MainLoopTest < Test::Unit::TestCase
+  def setup
+    @session_bus = DBus::SessionBus.instance
+    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
+
+  def teardown
+    # workaround for nonexisting remove_match
+    @session_bus.instance_variable_set(:@signal_matchrules, [])
+  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
+        d "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 = 1)
+    @obj.on_signal "LongTaskEnd" do
+      d "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
+      d "Dynamite burning"
+      sleep 2
+      d "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
+    d "Defusing dynamite"
+    # if we get here, defuse the bomb
+    dynamite.exit
+  end
+
+  # https://bugzilla.novell.com/show_bug.cgi?id=537401
+  def test_loop_drained_socket
+    test_loop_quit 0
+  end
+end

data/vendor/ruby-dbus/test/test_all

@@ -0,0 +1,26 @@
+#! /bin/bash
+# run all applicable test cases with proper setup
+# $0 [-a: all, even failing]
+# $0 ./a_single_testcase
+if [ "$1" = "" ]; then
+  : ${CASES:=./t[01234-9]* ./*_test.rb}
+elif [ "$1" = "-a" ]; then
+  : ${CASES:=./t? ./t*-* ./*_test.rb}
+  OPTS=-k
+else
+  : ${CASES:=$@}
+fi
+CASES_A=($CASES)		 # make array
+CASES_A=(${CASES_A[@]/*~/})	 # exclude backup files
+if ! which python >/dev/null; then
+  echo >&2 "Python not found, skipping those tests"
+  CASES_A=(${CASES_A[@]/*.py/})	 # exclude python files
+fi
+
+#export DBUS_VERBOSE=1
+#export RUBYOPT="-d"
+export RUBYOPT="$RUBYOPT -w"
+RUBYLIB=../lib ./test_server $OPTS \
+	./service_newapi.rb \
+	-- \
+	${CASES_A[@]}

data/vendor/ruby-dbus/test/test_server

@@ -0,0 +1,74 @@
+#! /bin/sh
+# A wrapper for DBus tests
+# Sets up a private session bus and calls all its arguments in turn
+# exiting on first failure
+# $0 server [-k] [arg1 arg2...] -- test1 test2...
+set -o errexit
+
+KEEP_GOING=false
+if [ "$1" = "-k" ]; then
+    KEEP_GOING=true
+    shift
+fi
+
+while [ "$1" != "--" ]; do
+  SERVER="$SERVER $1"
+  shift
+done
+shift # --
+
+# 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 --session --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 &
+}
+
+setup_activation () {
+    SDIR=$XDG_DATA_DIRS/dbus-1/services
+    mkdir -p $SDIR
+    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"
+my_dbus_launch
+setup_activation
+#run_server
+
+# Clean up at exit. This will also kill the server.
+trap "kill \$KILLS; rm -rf \$RM_FILES" EXIT TERM INT
+
+while [ -n "$1" ]; do
+  echo Running $1
+  $1 || $KEEP_GOING
+  shift
+done
+
+echo Done

data/vendor/ruby-dbus/test/variant_test.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+# Test marshalling variants according to ruby types
+require "test/unit"
+require "dbus"
+
+class VariantTest < Test::Unit::TestCase
+  def setup
+    @bus = DBus::SessionBus.instance
+    @svc = @bus.service("org.ruby.service")
+  end
+
+  def make_variant(a)
+    DBus::PacketMarshaller.make_variant(a)
+  end
+
+  def test_make_variant_scalar
+    # special case: do not fail immediately, marshaller will do that
+    assert_equal ["b", nil], make_variant(nil)
+
+    assert_equal ["b", true], make_variant(true)
+    # Integers
+    # no byte
+    assert_equal ["i", 42], make_variant(42)
+    # 3_000_000_000 can be u or x.
+    # less specific test: just run it thru a loopback
+    assert_equal ["x", 3_000_000_000], make_variant(3_000_000_000)
+    assert_equal ["x", 5_000_000_000], make_variant(5_000_000_000)
+ 
+    assert_equal ["d", 3.14], make_variant(3.14)
+
+    assert_equal ["s", "foo"], make_variant("foo")
+    assert_equal ["s", "bar"], make_variant(: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
+
+  def test_make_variant_array
+    ai = [1, 2, 3]
+#    as = ["one", "two", "three"]
+   # which?
+#    assert_equal ["ai", [1, 2, 3]], make_variant(ai)
+    assert_equal ["av", [["i", 1],
+                         ["i", 2],
+                         ["i", 3]]], make_variant(ai)
+    a0 = []
+    assert_equal ["av", []], make_variant(a0)
+
+  end
+
+  def test_make_variant_hash
+    h = {"k1" => "v1", "k2" => "v2"}
+    assert_equal ["a{sv}", {
+                    "k1" => ["s", "v1"],
+                    "k2" => ["s", "v2"],
+                  }], make_variant(h)
+    h0 = {}
+    assert_equal ["a{sv}", {}], make_variant(h0)
+  end
+end