PHP Prophet::checkPredictions方法代碼示例

 protected function tearDown()
 {
     if ($this->prophet) {
         $this->prophet->checkPredictions();
     }
     parent::tearDown();
 }

 function it_should_be_able_to_run_processes()
 {
     $prophet = new Prophet();
     $processes = [];
     for ($i = 0; $i < 20; $i++) {
         $process = $prophet->prophesize(Process::class);
         $process->started = false;
         $process->terminated = false;
         $process->start()->will(function () use($process) {
             $process->started = true;
         })->shouldBeCalledTimes(1);
         $process->isTerminated()->will(function () use($process) {
             if (!$process->terminated) {
                 $process->terminated = true;
                 return false;
             }
             return true;
         })->shouldBeCalledTimes(2);
         // The number of times isStarted() is called starts at 3
         // and increases by 2 after each chunk of five processes.
         $process->isStarted()->will(function () use($process) {
             return $process->started;
         })->shouldBeCalledTimes(floor($i / 5) * 2 + 3);
         $processes[] = $process->reveal();
     }
     $this->run($processes);
     $prophet->checkPredictions();
 }

 protected function verifyMockObjects()
 {
     parent::verifyMockObjects();
     if (null === $this->prophet) {
         return;
     }
     try {
         $this->prophet->checkPredictions();
     } catch (\Exception $e) {
         /** Intentionally left empty */
     }
     $this->countProphecyAssertions();
     if (isset($e)) {
         throw $e;
     }
 }

 /**
  * Calling no optional parameter
  *
  * @test
  * @see https://github.com/php-mock/php-mock-prophecy/issues/1
  */
 public function expectingWithoutOptionalParameter()
 {
     $prophet = new Prophet();
     $prophecy = $prophet->prophesize(OptionalParameterHolder::class);
     $prophecy->call("arg1")->willReturn("mocked");
     $mock = $prophecy->reveal();
     $this->assertEquals("mocked", $mock->call("arg1"));
     $prophet->checkPredictions();
 }

 /**
  * {@inheritdoc}
  */
 protected function verifyMockObjects()
 {
     parent::verifyMockObjects();
     if ($this->prophet !== null) {
         try {
             $this->prophet->checkPredictions();
         } catch (\Exception $e) {
             /** Intentionally left empty */
         }
         foreach ($this->prophet->getProphecies() as $objectProphecy) {
             foreach ($objectProphecy->getMethodProphecies() as $methodProphecies) {
                 foreach ($methodProphecies as $methodProphecy) {
                     $this->addToAssertionCount(count($methodProphecy->getCheckedPredictions()));
                 }
             }
         }
         if (isset($e)) {
             throw $e;
         }
     }
 }

 public function testOnNewAccountCreated()
 {
     $userName = 'tester';
     $userEmail = 'tester@example.com';
     $messageBody = 'Body';
     $messageSubject = 'Subject';
     $template = $this->prophet->prophesize('Twig_Template');
     $event = $this->prophet->prophesize('Smoovio\\Bundle\\CoreBundle\\Event\\NewAccountCreatedEvent');
     $user = $this->prophet->prophesize('Smoovio\\Bundle\\CoreBundle\\Entity\\User');
     $this->templating->loadTemplate($this->templateName)->willReturn($template->reveal())->shouldBeCalled();
     $template->renderBlock('subject', [])->willReturn('Subject');
     $event->getUser()->willReturn($user);
     $user->getUsername()->willReturn($userName);
     $user->getEmail()->willReturn($userEmail);
     $template->renderBlock('body', ['username' => $userName])->willReturn($messageBody)->shouldBeCalled();
     $this->mailer->send(Argument::that(function (\Swift_Message $message) use($userEmail, $messageBody, $messageSubject) {
         $this->assertSame($this->sender, $message->getSender());
         $this->assertSame($userEmail, $message->getTo());
         $this->assertSame($messageSubject, $message->getSubject());
         $this->assertSame($messageBody, $message->getBody());
     }));
     $this->listener->onNewAccountCreated($event->reveal());
     $this->prophet->checkPredictions();
 }

 public function testManagerCreatesUserSuccessfulWithProphecy()
 {
     $prophet = new Prophet();
     $manager = $prophet->prophesize('Doctrine\\Common\\Persistence\\ObjectManager');
     $encoderFactory = $prophet->prophesize('Symfony\\Component\\Security\\Core\\Encoder\\EncoderFactoryInterface');
     $encoder = $prophet->prophesize('Symfony\\Component\\Security\\Core\\Encoder\\PasswordEncoderInterface');
     $dispatcher = $prophet->prophesize('Symfony\\Component\\Eventdispatcher\\EventDispatcherInterface');
     $user = $prophet->prophesize('Smoovio\\Bundle\\CoreBundle\\Entity\\User');
     $encoderFactory->getEncoder($user->reveal())->willReturn($encoder)->shouldBeCalled();
     $user->encodePassword($encoder->reveal())->shouldBeCalled();
     $manager->persist($user)->shouldBeCalled();
     $manager->flush()->shouldBeCalled();
     $dispatcher->dispatch(CoreEvents::NEW_ACCOUNT_CREATED, Argument::that(function ($event) use($user) {
         return $event instanceof NewAccountCreatedEvent && $event->getUser() === $user;
     }));
     $userManager = new UserManager($manager->reveal(), $encoderFactory->reveal(), $dispatcher->reveal());
     $userManager->createUser($user->reveal());
     $prophet->checkPredictions();
 }

 function it_should_return_messages_to_given_recipient(ConnectionInterface $connection, ArrayToMessageTransformer $messageTransformer)
 {
     $rawMessages = array(array('id' => 4, 'recipients' => array('john.doe@example.com')), array('id' => 2, 'recipients' => array('demo@example.com', 'john.doe@example.com')), array('id' => 1, 'recipients' => array('john@example.com')));
     $prophet = new Prophet();
     $mockMessages = array($prophet->prophesize('Kibao\\MailCatcher\\Message\\MessageInterface'), $prophet->prophesize('Kibao\\MailCatcher\\Message\\MessageInterface'), $prophet->prophesize('Kibao\\MailCatcher\\Message\\MessageInterface'));
     for ($i = 0; $i < 3; $i++) {
         $rawMessage = $rawMessages[$i];
         $recipients = array();
         foreach ($rawMessage['recipients'] as $email) {
             $recipient = $prophet->prophesize('Kibao\\MailCatcher\\Address\\AddressInterface');
             $recipient->getEmail()->willReturn($email);
             $recipients[] = $recipient;
         }
         $mockMessages[$i]->getRecipients()->willReturn($recipients);
         $messageTransformer->transform($rawMessage)->willReturn($mockMessages[$i]);
         $connection->getMessage($rawMessage['id'])->willReturn($rawMessage);
     }
     $connection->getMessages()->willReturn($rawMessages);
     $this->getMessagesTo('john.doe@example.com')->shouldReturn(array($mockMessages[0], $mockMessages[1]));
     $prophet->checkPredictions();
 }

 /**
  * Verifies the mock object expectations.
  *
  * @since Method available since Release 3.5.0
  */
 protected function verifyMockObjects()
 {
     foreach ($this->mockObjects as $mockObject) {
         if ($mockObject->__phpunit_hasMatchers()) {
             $this->numAssertions++;
         }
         $mockObject->__phpunit_verify();
     }
     if ($this->prophet !== null) {
         try {
             $this->prophet->checkPredictions();
         } catch (Exception $e) {
             /** Intentionally left empty */
         }
         foreach ($this->prophet->getProphecies() as $objectProphecy) {
             foreach ($objectProphecy->getMethodProphecies() as $methodProphecies) {
                 foreach ($methodProphecies as $methodProphecy) {
                     $this->numAssertions += count($methodProphecy->getCheckedPredictions());
                 }
             }
         }
         if (isset($e)) {
             throw $e;
         }
     }
 }

 public function tearDown()
 {
     $this->prophet->checkPredictions();
 }

 /**
  * @param ExampleNode            $example
  * @param SpecificationInterface $context
  * @param MatcherManager         $matchers
  * @param CollaboratorManager    $collaborators
  */
 public function teardown(ExampleNode $example, SpecificationInterface $context, MatcherManager $matchers, CollaboratorManager $collaborators)
 {
     $this->prophet->checkPredictions();
 }

 public function letgo()
 {
     $this->prophet->checkPredictions();
 }

 protected function tearDown()
 {
     $prophet = new Prophet();
     $prophet->checkPredictions();
 }

 /**
  * {@inheridoc}.
  */
 protected function tearDown()
 {
     $this->prophet->checkPredictions();
 }

 protected function assertPostConditions()
 {
     if ($this->prophet) {
         $this->prophet->checkPredictions();
     }
 }