/**
* Test connecting an output and several input pipes to a merging tee.
*/
public function testConnectingIOPipes()
{
// create input pipe
$output1 = new Pipe();
// create input pipes 1, 2, 3 and 4
$pipe1 = new Pipe();
$pipe2 = new Pipe();
$pipe3 = new Pipe();
$pipe4 = new Pipe();
// create splitting tee (args are first two input fittings of tee)
$teeMerge = new TeeMerge($pipe1, $pipe2);
// connect 2 extra inputs for a total of 4
$connectedExtra1 = $teeMerge->connectInput($pipe3);
$connectedExtra2 = $teeMerge->connectInput($pipe4);
// connect the single output
$connected = $output1->connect($teeMerge);
// test assertions
$this->assertTrue($output1 instanceof Pipe, "Expecting \$output1 instanceof Pipe");
$this->assertTrue($pipe1 instanceof Pipe, "Expecting \$pipe1 instanceof Pipe");
$this->assertTrue($pipe2 instanceof Pipe, "Expecting \$pipe2 instanceof Pipe");
$this->assertTrue($pipe3 instanceof Pipe, "Expecting \$pipe2 instanceof Pipe");
$this->assertTrue($pipe4 instanceof Pipe, "Expecting \$pipe2 instanceof Pipe");
$this->assertTrue($teeMerge instanceof TeeMerge, "Expecting \$teeMerge instanceof TeeMerge");
$this->assertTrue($connectedExtra1, "Expecting connected extra input 1");
$this->assertTrue($connectedExtra2, "Expecting connected extra input 2");
}
/**
* Test attempting to connect a pipe to a pipe with an output already connected.
*/
public function testConnectingToAConnectedPipe()
{
// create two pipes
$pipe1 = new Pipe();
$pipe2 = new Pipe();
$pipe3 = new Pipe();
// connect them
$success = $pipe1->connect($pipe2);
// test assertions
$this->assertTrue($success, "Expecting connected pipe1 to pipe2");
$this->assertTrue($pipe1->connect($pipe3) == false, "Expecting can't connect pipe3 to pipe1");
}
/**
* Test connecting input and output pipes to a queue.
*/
public function testConnectingIOPipes()
{
// create output pipes 1
$pipe1 = new Pipe();
$pipe2 = new Pipe();
// create queue
$queue = new Queue();
// connect input fitting
$connectedInput = $pipe1->connect($queue);
// connect output fitting
$connectedOutput = $queue->connect($pipe2);
// test assertions
$this->assertTrue($pipe1 instanceof Pipe, "Expecting \$pipe1 instanceof Pipe");
$this->assertTrue($pipe2 instanceof Pipe, "Expecting \$pipe2 instanceof Pipe");
$this->assertTrue($queue instanceof Queue, "Expecting \$queue instanceof Queue");
$this->assertTrue($connectedInput, "Expecting connected input");
$this->assertTrue($connectedOutput, "Expecting connected output");
}
/**
* Test receiving a message from a pipe using a PipeListener.
*/
public function testReceiveMessageViaPipeListener()
{
// create a message with complete constructor args
$messageToSend = new Message(Message::NORMAL, (object) array('testProp' => 'testval'), simplexml_load_string('<testMessage testAtt="Hello" testAtt2="world"/>'), Message::PRIORITY_HIGH);
// create pipe and listener
$pipe = new Pipe();
$listener = new PipeListener($this, 'callBackMethod');
// connect the listener to the pipe and write the message
$connected = $pipe->connect($listener);
$written = $pipe->write($messageToSend);
// test assertions
$this->assertTrue($pipe instanceof Pipe, "Expecting pipe is Pipe");
$this->assertTrue($connected, "Expecting successfully connected listener to pipe");
$this->assertTrue($written, "Expecting wrote message to pipe");
$this->assertTrue($this->messagesReceived instanceof Message, "Expecting \$this->messagesReceived instance of Message");
$this->assertTrue($this->messagesReceived->getType() == Message::NORMAL, "Expecting \$this->messagesReceived->getType() == Message::NORMAL");
$this->assertTrue($this->messagesReceived->getHeader()->testProp == 'testval', "Expecting \$this->messagesReceived->getHeader()->testProp == 'testval'");
$this->assertTrue($this->messagesReceived->getBody()->attributes()->testAtt == 'Hello', "Expecting \$this->messagesReceived->getBody()->attributes()->testAtt == 'Hello'");
$this->assertTrue($this->messagesReceived->getPriority() == Message::PRIORITY_HIGH, "Expecting \$this->messagesReceived->getPriority() == Message::PRIORITY_HIGH");
}
/**
* Test connecting input and output pipes to a filter as well as disconnecting the output.
*/
public function testConnectingAndDisconnectingIOPipes()
{
// create output pipes 1
$pipe1 = new Pipe();
$pipe2 = new Pipe();
// create filter
$filter = new Filter('TestFilter');
// connect input fitting
$connectedInput = $pipe1->connect($filter);
// connect output fitting
$connectedOutput = $filter->connect($pipe2);
// test assertions
$this->assertTrue($pipe1 instanceof Pipe, "Expecting pipe1 instanceof Pipe");
$this->assertTrue($pipe2 instanceof Pipe, "Expecting pipe2 instanceof Pipe");
$this->assertTrue($filter instanceof Filter, "Expecting filter instanceof Filter");
$this->assertTrue($connectedInput, "Expecting connected input");
$this->assertTrue($connectedOutput, "Expecting connected output");
// disconnect pipe 2 from filter
$disconnectedPipe = $filter->disconnect();
$this->assertTrue($disconnectedPipe === $pipe2, "Expecting disconnected pipe2 from filter");
}
/**
* Test receiving messages from two pipes using a TeeMerge.
*/
public function testReceiveMessagesFromTwoTeeSplitOutputs()
{
$this->messagesReceived = array();
// create a message to send on pipe 1
$message = new Message(Message::NORMAL, array('testProp' => 1));
// create output pipes 1 and 2
$pipe1 = new Pipe();
$pipe2 = new Pipe();
// create and connect anonymous listeners
$connected1 = $pipe1->connect(new PipeListener($this, 'callBackMethod'));
$connected2 = $pipe2->connect(new PipeListener($this, 'callBackMethod'));
// create splitting tee (args are first two output fittings of tee)
$teeSplit = new TeeSplit($pipe1, $pipe2);
// write messages to their respective pipes
$written = $teeSplit->write($message);
// test $this->assertions
$this->assertTrue($message instanceof IPipeMessage, "Expecting \$message instanceof IPipeMessage");
$this->assertTrue($pipe1 instanceof Pipe, "Expecting \$pipe1 instanceof Pipe");
$this->assertTrue($pipe2 instanceof Pipe, "Expecting \$pipe2 instanceof Pipe");
$this->assertTrue($teeSplit instanceof TeeSplit, "Expecting \$teeSplit instanceof TeeSplit");
$this->assertTrue($connected1, "Expecting connected anonymous listener to pipe 1");
$this->assertTrue($connected2, "Expecting connected anonymous listener to pipe 2");
$this->assertTrue($written, "Expecting wrote single message to tee");
// test that both messages were received, then test
// FIFO order by inspecting the messages themselves
$this->assertTrue(count($this->messagesReceived) == 2, "Expecting received 2 messages");
// test message 1 $this->assertions
$message1 = array_shift($this->messagesReceived);
$this->assertTrue($message1 instanceof IPipeMessage, "Expecting \$message1 instanceof IPipeMessage");
$this->assertTrue($message1 === $message, "Expecting \$message1 === \$pipe1Message");
// object equality
// test message 2 $this->assertions
$message2 = array_shift($this->messagesReceived);
$this->assertTrue($message2 instanceof IPipeMessage, "Expecting \$message1 instanceof IPipeMessage");
$this->assertTrue($message2 === $message, "Expecting \$message1 === \$pipe1Message");
// object equality
}
/**
* Test using sendMessage on an OUTPUT pipe.
* <P>
* Creates a Pipe, Junction and Message.
* Adds the PipeListener to the Pipe.
* Adds the Pipe to the Junction as an OUTPUT pipe.
* uses the Junction's sendMessage method to send
* the Message, then checks that it was received.</P>
*/
public function testSendMessageOnAnOutputPipe()
{
// create pipe
$pipe = new Pipe();
// add a PipeListener manually
$listenerAdded = $pipe->connect(new PipeListener($this, 'callBackMethod'));
// create junction
$junction = new Junction();
// create test message
$message = new Message(Message::NORMAL, array('testVal' => 1));
// register the pipe with the junction, giving it a name and direction
$registered = $junction->registerPipe('testOutputPipe', Junction::OUTPUT, $pipe);
// send the message using the Junction's method
// it should show up in messageReceived property via the pipeListener
$sent = $junction->sendMessage('testOutputPipe', $message);
// test assertions
$this->assertTrue($pipe instanceof Pipe, "Expecting \$pipe instanceof Pipe");
$this->assertTrue($junction instanceof Junction, "Expecting \$junction instanceof Junction");
$this->assertTrue($registered, "Expecting regsitered pipe");
$this->assertTrue($listenerAdded, "Expecting added pipeListener");
$this->assertTrue($sent, "Expecting successful write to pipe");
$this->assertTrue(count($this->messagesReceived) == 1, "Expecting received 1 messages");
$this->assertTrue(array_pop($this->messagesReceived) === $message, "Expecting received message was same instance sent");
//object equality
}
