PHP PyStringNode::getLines方法代码示例

 /**
  * @param string       $code
  * @param PyStringNode $csv
  *
  * @Then /^exported file of "([^"]*)" should contain:$/
  *
  * @throws ExpectationException
  * @throws \Exception
  */
 public function exportedFileOfShouldContain($code, PyStringNode $csv)
 {
     $config = $this->getFixturesContext()->getJobInstance($code)->getRawConfiguration();
     $path = $this->getMainContext()->getSubcontext('job')->getJobInstancePath($code);
     if (!is_file($path)) {
         throw $this->getMainContext()->createExpectationException(sprintf('File "%s" doesn\'t exist', $path));
     }
     $delimiter = isset($config['delimiter']) ? $config['delimiter'] : ';';
     $enclosure = isset($config['enclosure']) ? $config['enclosure'] : '"';
     $escape = isset($config['escape']) ? $config['escape'] : '\\';
     $csvFile = new \SplFileObject($path);
     $csvFile->setFlags(\SplFileObject::READ_CSV | \SplFileObject::READ_AHEAD | \SplFileObject::SKIP_EMPTY | \SplFileObject::DROP_NEW_LINE);
     $csvFile->setCsvControl($delimiter, $enclosure, $escape);
     $expectedLines = [];
     foreach ($csv->getLines() as $line) {
         if (!empty($line)) {
             $expectedLines[] = explode($delimiter, str_replace($enclosure, '', $line));
         }
     }
     $actualLines = [];
     while ($data = $csvFile->fgetcsv()) {
         if (!empty($data)) {
             $actualLines[] = array_map(function ($item) use($enclosure) {
                 return str_replace($enclosure, '', $item);
             }, $data);
         }
     }
     $expectedCount = count($expectedLines);
     $actualCount = count($actualLines);
     assertSame($expectedCount, $actualCount, sprintf('Expecting to see %d rows, found %d', $expectedCount, $actualCount));
     if (md5(json_encode($actualLines[0])) !== md5(json_encode($expectedLines[0]))) {
         throw new \Exception(sprintf('Header in the file %s does not match expected one: %s', $path, implode(' | ', $actualLines[0])));
     }
     unset($actualLines[0]);
     unset($expectedLines[0]);
     foreach ($expectedLines as $expectedLine) {
         $originalExpectedLine = $expectedLine;
         $found = false;
         foreach ($actualLines as $index => $actualLine) {
             // Order of columns is not ensured
             // Sorting the line values allows to have two identical lines
             // with values in different orders
             sort($expectedLine);
             sort($actualLine);
             // Same thing for the rows
             // Order of the rows is not reliable
             // So we generate a hash for the current line and ensured that
             // the generated file contains a line with the same hash
             if (md5(json_encode($actualLine)) === md5(json_encode($expectedLine))) {
                 $found = true;
                 // Unset line to prevent comparing it twice
                 unset($actualLines[$index]);
                 break;
             }
         }
         if (!$found) {
             throw new \Exception(sprintf('Could not find a line containing "%s" in %s', implode(' | ', $originalExpectedLine), $path));
         }
     }
 }

 /**
  * @Then /^the console output should have lines ending in:$/
  */
 public function theConsoleOutputShouldHaveLinesEndingIn(PyStringNode $string)
 {
     $stdOutLines = explode(PHP_EOL, $this->lastBehatStdOut);
     $expectedLines = $string->getLines();
     \PHPUnit_Framework_Assert::assertCount(count($expectedLines), $stdOutLines);
     foreach ($stdOutLines as $idx => $stdOutLine) {
         $suffix = isset($expectedLines[$idx]) ? $expectedLines[$idx] : '(NONE)';
         $constraint = \PHPUnit_Framework_Assert::stringEndsWith($suffix);
         $constraint->evaluate($stdOutLine);
     }
 }

 /**
  * @Then /^I should see:$/
  */
 public function iShouldSee(PyStringNode $string)
 {
     $page = $this->session->getPage();
     $html = $page->getText();
     $lines = $string->getLines();
     foreach ($lines as $line) {
         if (strpos($html, $line) === false) {
             throw new Exception($line . ' not found on page');
         }
     }
 }

 /**
  * @Given /^Unpack files to the same directory:$/
  */
 public function unpackFilesToTheSameDirectory(PyStringNode $string)
 {
     $expectedFiles = $string->getLines();
     $this->pagesDir = $this->package->unpack($expectedFiles);
     assertFileExists($this->pagesDir);
     chdir($this->pagesDir);
     $foundFiles = array_flip(glob('*.html'));
     assertCount(count($expectedFiles), $foundFiles);
     foreach ($expectedFiles as $file) {
         assertArrayHasKey($file, $foundFiles);
     }
 }

 /**
  * @param PyStringNode $behatData
  * @param array        $config
  *
  * @return array
  */
 protected function getExpectedLines(PyStringNode $behatData, $config)
 {
     $delimiter = isset($config['delimiter']) ? $config['delimiter'] : ';';
     $enclosure = isset($config['enclosure']) ? $config['enclosure'] : '';
     $expectedLines = [];
     foreach ($behatData->getLines() as $line) {
         if (!empty($line)) {
             $expectedLines[] = explode($delimiter, str_replace($enclosure, '', $line));
         }
     }
     return $expectedLines;
 }

 /**
  * @param $fieldName
  * @param $string
  *
  * @throws ExpectationException
  *
  * @return bool
  *
  *
  * @Then /^the field "([^"]*)" should have the following options:$/
  */
 public function theFieldShouldHaveTheFollowingOptions($fieldName, PyStringNode $string)
 {
     $field = $this->getCurrentPage()->findField($fieldName);
     $id = $field->getAttribute('id');
     if ('select' === $field->getTagName()) {
         $options = $field->findAll('css', 'option');
     } elseif ('input' === $field->getTagName() && 0 === strpos($id, 's2id_')) {
         $options = $field->getParent()->getParent()->findAll('css', 'option');
     } else {
         throw $this->createExpectationException(sprintf('"%s" field is not a select field, can\'t have options.', $fieldName));
     }
     $availableOptions = [];
     foreach ($options as $option) {
         $optionValue = trim($option->getText());
         if ($optionValue) {
             $availableOptions[] = $optionValue;
         }
     }
     if (count(array_intersect($string->getLines(), $availableOptions)) === count($string->getLines())) {
         return true;
     }
     throw $this->createExpectationException(sprintf('"%s" field have these options (%s), but expected following options (%s).', $fieldName, implode(', ', $availableOptions), implode(', ', $string->getLines())));
 }

 /**
  * @Given /^the following response headers should be present:$/
  */
 public function assertExistingHeaders(PyStringNode $list)
 {
     $headers = $list->getLines();
     foreach ($headers as $header) {
         assertTrue($this->getLastResponse()->hasHeader($header), 'Header "' . $header . '" should be present');
     }
 }

 /**
  * Accepts YAML fixture definitions similar to the ones used in SilverStripe unit testing.
  * 
  * Example: Given there are the following member records:
  *  member1:
  *    Email: member1@test.com
  *  member2:
  *    Email: member2@test.com
  * 
  * @Given /^there are the following ([^\s]*) records$/
  */
 public function stepThereAreTheFollowingRecords($dataObject, PyStringNode $string)
 {
     $yaml = array_merge(array($dataObject . ':'), $string->getLines());
     $yaml = implode("\n  ", $yaml);
     // Save fixtures into database
     // TODO Run prepareAsset() for each File and Folder record
     $yamlFixture = new \YamlFixture($yaml);
     $yamlFixture->writeInto($this->getFixtureFactory());
 }

 /**
  * Converts a PyStringObject to a normal stringObject with intents
  *
  * @param PyStringNode $pynode
  *
  * @return string
  */
 public function convertPyStringToNormalString(PyStringNode $pynode)
 {
     $intent = " ";
     $intentedPyNodeText = "";
     foreach ($pynode->getLines() as $pynodeLine) {
         $intentedPyNodeText .= $intent . $pynodeLine . "\n";
     }
     return sprintf("{$intent}\"\"\"\n%s{$intent}\"\"\"", $intentedPyNodeText);
 }

 /**
  * @Then /^the Adapter should report the scenario "([^"]*)" with following steps:$/
  */
 public function theAdapterShouldReportTheScenarioWithSteps($scenarioName, PyStringNode $expected_steps)
 {
     Phake::verify($this->_mockedClient, Phake::atLeast(1))->startScenario($scenarioName);
     // some steptext might be more than once in the result array
     $timesOccured = array_count_values($expected_steps->getLines());
     foreach ($expected_steps->getLines() as $steptext) {
         $times_expected = $timesOccured[$steptext];
         Phake::verify($this->_mockedClient, Phake::times($times_expected))->addStepToBuffer($steptext, null);
     }
     $this->_cntScenariosToBeStopped++;
     Phake::verify($this->_mockedClient, Phake::atLeast($this->_cntScenariosToBeStopped))->stopScenario();
 }

 /**
  * @Given /^a new "([^"]*)" document with:$/
  */
 public function aNewDocumentWith($collection, PyStringNode $string)
 {
     $database = $this->mongoDatabase;
     $obj = json_decode(trim(implode($string->getLines())), true);
     $this->mongoClient->{$database}->{$collection}->insert($obj);
 }

 /**
  * @Then /^I should get:$/
  */
 public function getResult(PyStringNode $expected)
 {
     $tmp = substr($this->tmp, 0, -1);
     if (!function_exists('normalize')) {
         function normalize($str)
         {
             return str_replace('\\', '/', $str);
         }
     }
     // expected
     $lines = array_slice($expected->getLines(), 2);
     $expectedFiles = array_map(function ($line) {
         // remove everything before the filepath
         return normalize(trim(preg_replace('/\\d\\s*/', '', $line)));
     }, $lines);
     // actual
     $display = array_slice($this->display, 3);
     $actualFiles = array_map(function ($line) {
         // remove everything before the filepath
         return normalize(trim(preg_replace('/\\d\\s*/', '', $line)));
     }, $display);
     // compare
     if (0 === count($lines) && 0 !== count($display)) {
         throw new \Exception('Failed asserting that there are no suspects');
     }
     foreach ($expectedFiles as $expected) {
         if (false !== ($key = array_search($expected, $actualFiles))) {
             unset($actualFiles[$key]);
         } else {
             throw new \Exception(sprintf('Failed asserting that file "%s" is a suspect', $expected));
         }
     }
     if (0 !== count($actualFiles)) {
         throw new \Exception(sprintf('The file(s) "%s" are suspects too', implode('", "', $actualFiles)));
     }
 }

 /**
  * @Given /^I specify the following transformations:$/
  */
 public function applyTransformations(PyStringNode $transformations)
 {
     foreach ($transformations->getLines() as $t) {
         $this->client->getEventDispatcher()->addListener('request.before_send', function ($event) use($t) {
             $event['request']->getQuery()->add('t', $t);
         });
     }
 }

 /**
  * @Given /^I test the exposed resources:$/
  */
 public function iTestTheExposedResources(PyStringNode $resources)
 {
     foreach ($resources->getLines() as $line) {
         $this->getClient()->get($this->locatePath($line));
     }
 }

 /**
  * treat payload as json data and try to decode it
  *
  * @var PyStringNode $node
  *
  * @return mixed
  */
 private function getJsonFromPyStringNode(PyStringNode $node)
 {
     return \GuzzleHttp\json_decode(implode('', $node->getLines()), true);
 }