コード例 #1
0
 public function testConstruct()
 {
     $message = new Message();
     $message->setContent('A message');
     $stdMessage = new ZendMessage();
     $stdMessage->setContent('A stdlib message');
     //Test array of Message, without queue in constructor
     $messages = new MessageIterator([$message, $stdMessage]);
     $this->assertEquals($message, $messages->current());
     $messages->next();
     $this->assertEquals($stdMessage, $messages->current());
     $this->assertNull($messages->getQueue());
     $this->assertNull($messages->getQueueClass());
     //Test array of array, without queue in constructor
     $messages = new MessageIterator([['content' => 'a message']]);
     $this->assertEquals('a message', $messages->current()->getContent());
     $this->assertInstanceOf($this->queue->getOptions()->getMessageClass(), $messages->current());
     //Test with queue in constructor
     $messages = new MessageIterator([$message, $stdMessage], $this->queue);
     $this->assertTrue($this->queue === $messages->getQueue());
     $this->assertEquals(get_class($this->queue), $this->messages->getQueueClass());
 }
コード例 #2
0
ファイル: Queue.php プロジェクト: stakhanovist/zf2-module
 /**
  * Create a send a message in order to dispatch another controller
  *
  * Expect that a worker will process the message using the forward strategy
  *
  * @param  string $name Controller name; either a class name or an alias used in the DI container or service locator
  * @param  null|array $params Parameters with which to seed a custom RouteMatch object for the new controller
  * @param  SendParametersInterface $sendParams
  * @return MessageInterface
  */
 public function dispatch($name, array $params = null, SendParametersInterface $sendParams = null)
 {
     $message = new Message();
     //TODO: use a custom message class?
     $message->setContent($name);
     if ($params !== null) {
         $message->setMetadata($params);
     }
     $this->getQueue()->send($message, $sendParams);
     return $message;
 }
コード例 #3
0
ファイル: AdapterTest.php プロジェクト: stakhanovist/queue
 public function testCountMessages()
 {
     $queue = $this->createQueue(__FUNCTION__);
     $adapter = $queue->getAdapter();
     // check to see if this function is supported
     if (!$adapter instanceof CountMessagesCapableInterface) {
         $this->markTestSkipped('countMessages() is not supported');
         return;
     }
     $this->checkAdapterSupport('deleteQueue');
     // for a test case, the count should be zero at first.
     $this->assertEquals($adapter->countMessages($queue), 0);
     $body = 'this is a test message';
     // send a message
     $message = new Message();
     $message->setContent($body);
     if (!$adapter->sendMessage($queue, $message)) {
         $this->fail('sendMessage() failed');
     }
     // test queue count for being 1
     /* @var $adapter CountMessagesCapableInterface */
     $this->assertEquals($adapter->countMessages($queue), 1);
     // receive the message
     $message = $adapter->receiveMessages($queue);
     /* we need to delete the messages we put in the queue before
      * counting.
      *
      * not all adapters support deleteMessage, but we should remove
      * the messages that we created if we can.
      */
     if ($adapter instanceof DeleteMessageCapableInterface) {
         foreach ($message as $msg) {
             /* @var $adapter DeleteMessageCapableInterface */
             $adapter->deleteMessage($queue, $msg);
         }
         // test the count for being 0
         $this->assertEquals($adapter->countMessages($queue), 0);
     }
     // delete the queue we created
     $adapter->deleteQueue($queue->getName());
 }
コード例 #4
0
ファイル: QueueTest.php プロジェクト: stakhanovist/queue
 public function testSampleBehavior()
 {
     // send()
     // Parameter verification
     try {
         $this->queue->send([]);
         $this->fail('send() $mesage must be a string or an instance of \\Zend\\Stdlib\\MessageInterface');
     } catch (\Exception $e) {
         $this->assertTrue(true);
     }
     $message = 'Hello world';
     $this->assertInstanceOf(MessageInterface::class, $this->queue->send($message));
     $newMessageObj = $this->queue->send(['content' => $message, 'metadata' => ['foo' => 'bar']]);
     $this->assertInstanceOf(MessageInterface::class, $newMessageObj);
     $this->assertEquals($message, $newMessageObj->getContent());
     $metadata = $newMessageObj->getMetadata();
     $this->assertArrayHasKey('__queue', $metadata);
     $this->assertArrayHasKey('foo', $metadata);
     $this->assertEquals('bar', $metadata['foo']);
     $message = new Message();
     $message->setContent('Hello world again');
     $this->assertEquals($message, $this->queue->send($message));
     // count()
     if ($this->queue->canCountMessages()) {
         $this->assertEquals($this->queue->count(), 3);
     }
     // receive()
     // Parameter verification
     try {
         $this->queue->receive([]);
         $this->fail('Method receive() $maxMessages must be a integer or null');
     } catch (\Exception $e) {
         $this->assertTrue(true);
     }
     // parameter verification
     try {
         $this->queue->receive(0);
         $this->fail('Method receive() $maxMessages must be a integer or null');
     } catch (\Exception $e) {
         $this->assertTrue(true);
     }
     $messages = $this->queue->receive();
     $this->assertTrue($messages instanceof MessageIterator);
     // deleteMessage()
     if ($this->queue->canDeleteMessage()) {
         foreach ($messages as $i => $message) {
             $this->assertTrue($message instanceof Message);
             $this->assertTrue($this->queue->delete($message));
         }
     }
 }