PHP PyStringNode::getRaw方法代码示例

 /**
  * @Then /^(?:the )?response should be:$/
  */
 public function theResponseShouldBe(PyStringNode $content)
 {
     if ($this->getResponseHeader('Content-Type') === 'application/json') {
         $this->assertJsonStringEqualsJsonString($this->adaptContent($content->getRaw()), $this->getResponse()->getContent(), sprintf('The content of the response is not the expected'));
     } else {
         Assertions::assertEquals($content->getRaw(), $this->getResponse()->getContent(), sprintf('The content of the response is not the expected'));
     }
 }

 /**
  * @Then /^(?:the )?response should equal to json:$/
  */
 public function theResponseShouldEqualToJson(PyStringNode $jsonString)
 {
     $expected = json_decode($jsonString->getRaw(), true);
     $actual = $this->lastResponse;
     if (null === $expected) {
         throw new \RuntimeException("Can not convert etalon to json:\n" . $jsonString->getRaw());
     }
     assertEquals($expected, $actual, "Failed asserting that equals to \n" . print_r($actual, true));
 }

 /**
  * @When I send a :method request to URL :url with body:
  */
 public function iSendARequestToUrlWithBody($method, $url, PyStringNode $body)
 {
     $bodyReplace = $body->getRaw();
     $bodyReplace = $this->replaceParameters($bodyReplace);
     $body = new PyStringNode([$bodyReplace], $body->getLine());
     $this->restContext->iSendARequestToWithBody($method, $this->replaceParameters($url), $body);
 }

 /**
  * @Then the system should have the following info sms subscription low balance reminder logs:
  *
  * @param PyStringNode $body
  */
 public function theSystemShouldHaveTheFollowingOperations(PyStringNode $body)
 {
     /** @var CollectLogsTestWorker $collectLogsTestWorker */
     $collectLogsTestWorker = $this->kernel->getContainer()->get('muchacuba.info_sms.subscription.low_balance_reminder.collect_logs_test_worker');
     Assert::assertTrue((new SimpleFactory())->createMatcher()->match(iterator_to_array($collectLogsTestWorker->collect()), (array) json_decode($body->getRaw(), true)));
     $this->rootContext->ignoreState('Muchacuba\\InfoSms\\Subscription\\LowBalanceReminder\\Log');
 }

 function it_saves_behat_feature_file(PyStringNode $config, Filesystem $filesystem)
 {
     $config->getRaw()->willReturn('Feature: test');
     $filesystem->dumpFile(Argument::containingString('/features/feature.feature'), 'Feature: test')->shouldBeCalled();
     $this->createWorkingDirectory();
     $this->iHaveTheFeature($config);
 }

 /**
  * @Given the system should have the following uniquenesses:
  */
 public function theSystemShouldHaveTheFollowingUniquenesses(PyStringNode $body)
 {
     /** @var CollectUniquenessTestWorker $collectUniquenessTestWorker */
     $collectUniquenessTestWorker = $this->kernel->getContainer()->get('cubalider.unique.collect_uniqueness_test_worker');
     Assert::assertTrue((new SimpleFactory())->createMatcher()->match(iterator_to_array($collectUniquenessTestWorker->collect()), (array) json_decode($body->getRaw(), true)));
     $this->rootContext->ignoreState('Cubalider\\Uniqueness');
 }

    /**
     * @Given there exists a snippet template ":name" with the following property configuration
     */
    public function thereExistsASnippetTemplateWithTheFollowingPropertyConfiguration($name, PyStringNode $string)
    {
        $template = <<<EOT
<?xml version="1.0" ?>

<template xmlns="http://schemas.sulu.io/template/template"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://schemas.sulu.io/template/template http://schemas.sulu.io/template/template-1.0.xsd"
          >

    <key>%s</key>

    <properties>
        <property name="title" type="text_line" mandatory="true">
            <meta>
                <title lang="de">Title</title>
                <title lang="en">Title</title>
            </meta>
        </property>

%s

    </properties>
</template>
EOT;
        $template = sprintf($template, $name, $string->getRaw());
        $this->createStructureTemplate('snippet', $name, $template);
    }

 /**
  * @Given the system should have the following internet profiles:
  *
  * @param PyStringNode $body
  *
  */
 public function theSystemShouldHaveTheFollowingInternetProfiles(PyStringNode $body)
 {
     /** @var CollectProfilesTestWorker $collectProfilesTestWorker */
     $collectProfilesTestWorker = $this->kernel->getContainer()->get('muchacuba.internet.collect_profiles_test_worker');
     Assert::assertTrue((new SimpleFactory())->createMatcher()->match(iterator_to_array($collectProfilesTestWorker->collect()), (array) json_decode($body->getRaw(), true)));
     $this->rootContext->ignoreState('Muchacuba\\Internet\\Profile');
 }

 /**
  * @Then I should get the following data:
  *
  * @param PyStringNode $string
  *
  * @throws \Exception
  */
 public function iShouldGetTheFollowingData(PyStringNode $string)
 {
     $matcher = (new SimpleFactory())->createMatcher();
     if (!$matcher->match(json_decode(json_encode($this->result), true), json_decode((string) $string->getRaw(), true))) {
         throw new \Exception($matcher->getError());
     }
 }

 /**
  * @Given the system should have the following recharge card profiles debt operations
  */
 public function theSystemShouldHaveTheFollowingDebtOperations(PyStringNode $body)
 {
     /** @var CollectOperationsTestWorker $collectOperationsTestWorker */
     $collectOperationsTestWorker = $this->kernel->getContainer()->get('muchacuba.recharge_card.profile.debt.collect_operations_test_worker');
     Assert::assertTrue((new SimpleFactory())->createMatcher()->match(iterator_to_array($collectOperationsTestWorker->collect()), (array) json_decode($body->getRaw(), true)));
     $this->rootContext->ignoreState('Muchacuba\\RechargeCard\\Profile\\Debt\\Operation');
 }

 /**
  * Sends a HTTP request with a body
  *
  * @Given I send a :method request to :url with body:
  */
 public function iSendARequestToWithBody($method, $url, PyStringNode $body)
 {
     $client = $this->getSession()->getDriver()->getClient();
     // intercept redirection
     $client->followRedirects(false);
     $client->request($method, $this->locatePath($url), array(), array(), array(), $body->getRaw());
     $client->followRedirects(true);
 }

 /**
  * @Then /^it should contain:$/
  */
 public function itShouldContain(PyStringNode $string)
 {
     $sql = file_get_contents($this->workingDirectory . '/behat_table.sql');
     if (empty($sql) || !preg_match(sprintf('/%s/', preg_quote($string->getRaw())), $sql)) {
         $this->printDebug($sql);
         throw new Exception('Content not found');
     }
 }

 /**
  * @When the system has the following user accounts:
  *
  * @param PyStringNode $body
  */
 public function theSystemHasTheFollowingUserAccounts(PyStringNode $body)
 {
     /** @var CreateAccountTestWorker $createAccountTestWorker */
     $createAccountTestWorker = $this->kernel->getContainer()->get('muchacuba.user.create_account_test_worker');
     $items = json_decode($body->getRaw(), true);
     foreach ($items as $item) {
         $createAccountTestWorker->create($item['id'], $item['username'], $item['password'], $item['roles']);
     }
 }

 /**
  * @When /^I write a (?:spec|class) "([^"]*)" with following code$/
  */
 public function iWriteASpecWithFollowingCode($file, PyStringNode $codeContent)
 {
     $dirname = dirname($file);
     if (!file_exists($dirname)) {
         mkdir($dirname, 0777, true);
     }
     file_put_contents($file, $codeContent->getRaw());
     require_once $file;
 }

 /** @Then /^I should get:$/ */
 public function iShouldGet(PyStringNode $string)
 {
     //        if ((string) $string !== $this->output) {
     //            throw new Exception(
     //                "Actual output is:\n" . $this->output
     //            );
     //        }
     assertEquals($string->getRaw(), $this->output);
 }