Net::DBus::Test::MockCUsercContributed PerNet::DBus::Test::MockConnection(3pm)
NAME
Net::DBus::Test::MockConnection - Fake a connection to the bus unit
testing
SYNOPSIS
use Net::DBus;
my $bus = Net::DBus->test
# Register a service, and the objec to be tested
use MyObject
my $service = $bus->export_service("org.example.MyService");
my $object = MyObject->new($service);
# Acquire the service & do tests
my $remote_service = $bus->get_service('org.example.MyService');
my $remote_object = $service->get_object("/org/example/MyObjct");
# This traverses the mock connection, eventually
# invoking 'testSomething' on the $object above.
$remote_object->testSomething()
DESCRIPTION
This object provides a fake implementation of the
Net::DBus::Binding::Connection enabling a pure 'in-memory' message bus
to be mocked up. This is intended to facilitate creation of unit tests
for services which would otherwise need to call out to other object on
a live message bus. It is used as a companion to the
Net::DBus::Test::MockObject module which is how fake objects are to be
provided on the fake bus.
METHODS
my $con = Net::DBus::Test::MockConnection->new()
Create a new mock connection object instance. It is not usually
necessary to create instances of this object directly, instead the
"test" method on the Net::DBus object can be used to get a handle
to a test bus.
$con->send($message)
Send a message over the mock connection. If the message is a method
call, it will be dispatched straight to any corresponding mock
object registered. If the message is an error or method return it
will be made available as a return value for the
"send_with_reply_and_block" method. If the message is a signal it
will be queued up for processing by the "dispatch" method.
$bus->request_name($service_name)
Pretend to send a request to the bus registering the well known
name specified in the $service_name parameter. In reality this is
just a no-op giving the impression that the name was successfully
registered.
my $reply = $con->send_with_reply_and_block($msg)
Send a message over the mock connection and wait for a reply. The
$msg should be an instance of
"Net::DBus::Binding::Message::MethodCall" and the return $reply
will be an instance of "Net::DBus::Binding::Message::MethodReturn".
It is also possible that an error will be thrown, with the thrown
error being blessed into the "Net::DBus::Error" class.
$con->dispatch;
Dispatches any pending messages in the incoming queue to their
message handlers. This method should be called by test suites
whenever they anticipate that there are pending signals to be dealt
with.
$con->add_filter($coderef);
Adds a filter to the connection which will be invoked whenever a
message is received. The $coderef should be a reference to a
subroutine, which returns a true value if the message should be
filtered out, or a false value if the normal message dispatch
should be performed.
$bus->add_match($rule)
Register a signal match rule with the bus controller, allowing
matching broadcast signals to routed to this client. In reality
this is just a no-op giving the impression that the match was
successfully registered.
$bus->remove_match($rule)
Unregister a signal match rule with the bus controller, preventing
further broadcast signals being routed to this client. In reality
this is just a no-op giving the impression that the match was
successfully unregistered.
$con->register_object_path($path, \&handler)
Registers a handler for messages whose path matches that specified
in the $path parameter. The supplied code reference will be invoked
with two parameters, the connection object on which the message was
received, and the message to be processed (an instance of the
"Net::DBus::Binding::Message" class).
$con->register_fallback($path, \&handler)
Registers a handler for messages whose path starts with the prefix
specified in the $path parameter. The supplied code reference will
be invoked with two parameters, the connection object on which the
message was received, and the message to be processed (an instance
of the "Net::DBus::Binding::Message" class).
$con->unregister_object_path($path)
Unregisters the handler associated with the object path $path. The
handler would previously have been registered with the
"register_object_path" or "register_fallback" methods.
my $msg = $con->make_error_message($replyto, $name, $description)
Creates a new message, representing an error which occurred during
the handling of the method call object passed in as the $replyto
parameter. The $name parameter is the formal name of the error
condition, while the $description is a short piece of text giving
more specific information on the error.
my $call = $con->make_method_call_message( $service_name, $object_path,
$interface, $method_name);
Create a message representing a call on the object located at the
path $object_path within the client owning the well-known name
given by $service_name. The method to be invoked has the name
$method_name within the interface specified by the $interface
parameter.
my $msg = $con->make_method_return_message($replyto)
Create a message representing a reply to the method call message
passed in the $replyto parameter.
my $msg = $con->make_signal_message($object_path, $interface,
$signal_name);
Creates a new message, representing a signal [to be] emitted by the
object located under the path given by the $object_path parameter.
The name of the signal is given by the $signal_name parameter, and
is scoped to the interface given by the $interface parameter.
BUGS
It doesn't completely replicate the API of
Net::DBus::Binding::Connection, merely enough to make the high level
bindings work in a test scenario.
AUTHOR
Daniel P. Berrange
COPYRIGHT
Copyright (C) 2005-2009 Daniel P. Berrange
SEE ALSO
Net::DBus, Net::DBus::Test::MockObject, Net::DBus::Binding::Connection,
<http://www.mockobjects.com/Faq.html>
perl v5.36.0 2022-12-Net::DBus::Test::MockConnection(3pm)
Generated by dwww version 1.15 on Thu Jun 20 14:23:31 CEST 2024.