PHP TableNode::getColumnsHash方法代码示例

 /**
  * Checks that the given select field doesn't have the listed options.
  *
  * @Then I should not have the following options for :select:
  */
 public function assertNoSelectOptions($select, TableNode $options)
 {
     // Retrieve the specified field.
     if (!($field = $this->getSession()->getPage()->findField($select))) {
         throw new ExpectationException("Field '{$select}' not found.", $this->getSession());
     }
     // Check that the specified field is a <select> field.
     $this->assertElementType($field, 'select');
     // Retrieve the options table from the test scenario and flatten it.
     $expected_options = $options->getColumnsHash();
     array_walk($expected_options, function (&$value) {
         $value = reset($value);
     });
     // Retrieve the actual options that are shown in the page.
     $actual_options = $field->findAll('css', 'option');
     // Convert into a flat list of option text strings.
     array_walk($actual_options, function (&$value) {
         $value = $value->getText();
     });
     // Check that none of the expected options are present.
     foreach ($expected_options as $expected_option) {
         if (in_array($expected_option, $actual_options)) {
             throw new ExpectationException("Option '{$expected_option}' is unexpectedly found in select list '{$select}'.", $this->getSession());
         }
     }
 }

 /**
  * @Given /^I should see the row in the table "(?P<element>[^"]*)":$/
  *
  * @param string    $element
  * @param TableNode $table
  *
  * @throws \Exception
  */
 public function iShouldSeeTheRow($element, TableNode $table)
 {
     // Check that the (html) table exists
     $this->assertNumElements(1, $element);
     // Get the (html) table rows
     $headerNodeElements = $this->getSession()->getPage()->findAll('css', sprintf('%s thead > tr > th', $element));
     $rowNodeElements = $this->getSession()->getPage()->findAll('css', sprintf('%s > tbody > tr', $element));
     foreach ($table->getColumnsHash() as $rowIndex => $row) {
         // At this point, we want to check that $rowNodeElements contains a rows matching $row
         $rowMatches = false;
         foreach ($rowNodeElements as $rowNodeElement) {
             /* @var NodeElement $rowNodeElement */
             try {
                 // Get the row cells
                 $cellNodeElements = $rowNodeElement->findAll('css', 'td');
                 // Check that for each cells of $row, we got a matching value
                 foreach ($row as $columnText => $cellValue) {
                     $this->assertNodeElementContainsText($cellNodeElements[$this->findTableIndex($headerNodeElements, $columnText)], $cellValue);
                 }
                 // At this point the row match otherwise an exception would have been thrown
                 $rowMatches = true;
                 continue;
             } catch (\Exception $exception) {
                 // Exception thrown because the row was not matching
                 // Do nothing and pass to the next row
             }
         }
         PHPUnit::assertTrue($rowMatches, sprintf('Expected to find at least one row matching row #%d', $rowIndex));
     }
 }

 /**
  * @Given order events exists:
  */
 public function orderEventsExists(TableNode $table)
 {
     foreach ($table->getColumnsHash() as $eventData) {
         $event = $this->getContainer()->get('crm.customer_event.factory')->createOrder(['value' => (double) $eventData['Value'], 'valueCurrency' => $eventData['Currency'], 'customerId' => $eventData['Customer ID'], 'time' => new \DateTime($eventData['Time'])]);
         $this->getContainer()->get('crm.customer_event.repository')->add($event);
     }
 }

 /**
  * @Given the following people exist:
  */
 public function theFollowingPeopleExist(TableNode $table)
 {
     $data = new Sample();
     $values = $table->getColumnsHash();
     foreach ($values as $val) {
         $data->set($val['name'], $val['id']);
     }
 }

 /**
  * @Given the following roles exist:
  */
 public function theFollowingRolesExist(TableNode $roles)
 {
     $roleData = $roles->getColumnsHash();
     foreach ($roleData as $roleDatum) {
         $this->getOrCreateRole($roleDatum['name'], $roleDatum['system']);
     }
     $this->getEntityManager()->flush();
 }

 /**
  * @Given users and permissions:
  */
 public function usersAndPermissions(TableNode $table)
 {
     $permission = array();
     foreach ($table->getColumnsHash() as $userInfo) {
         $permission[$userInfo['user']] = explode(',', $userInfo['resource']);
     }
     $this->userPermission = new \Dgafka\Fixtures\IBAC\SimpleACL($permission);
 }

 /**
  * @Given There are the following responses:
  */
 public function thereAreTheFollowingResponses(TableNode $table)
 {
     $em = $this->getManager();
     $applicationRepository = $em->getRepository('JSONMockBundle:Application');
     foreach ($table->getColumnsHash() as $row) {
         $response = new \JSONMockBundle\Entity\Response();
         $response->setName($row['Name']);
         $response->setUrl($row['Url']);
         $response->setValue(json_decode($row['Value']));
         $response->setMethod($row['Method']);
         $response->setStatusCode($row['Status_code']);
         $application = $applicationRepository->find($row['APP_ID']);
         $response->setApplication($application);
         $this->getManager()->persist($response);
     }
     $this->getManager()->flush();
     $this->getManager()->clear();
 }

 /**
  * @Given /^User "([^"]*)" exists with:$/
  */
 public function userExistsWith($username, TableNode $table)
 {
     $entity = new User($username, 'password');
     foreach ($table->getColumnsHash() as $row) {
         $value = $row['Value'];
         if ('Roles' === $row['Property']) {
             $roles = $entity->getRoles();
             if (!in_array($value, $roles)) {
                 $roles[] = $value;
             }
             $entity->setRoles($roles);
             continue;
         }
         $setter = 'set' . $row['Property'];
         $entity->{$setter}($value);
     }
     $this->getParameterBag()->set('user', $entity);
     $em = $this->getEntityManager();
     $em->persist($entity);
     $em->flush();
 }

 /**
  * @Given /^it should contain the following set of labels, and input fields of the following types:$/
  */
 public function itShouldContainTheFollowingSetOfLabelsAndInputFieldsTypes(TableNode $table)
 {
     $fieldsExpectations = $table->getColumnsHash();
     $inputNodeElements = $this->getSession()->getPage()->findAll('css', sprintf('div.ezfield-identifier-%s fieldset input', self::$fieldIdentifier));
     /** @var NodeElement $nodeElement */
     foreach ($inputNodeElements as $nodeElement) {
         foreach ($fieldsExpectations as $expectationId => $fieldExpectation) {
             if ($fieldExpectation['type'] === $nodeElement->getAttribute('type')) {
                 $inputId = $nodeElement->getAttribute('id');
                 $this->assertSession()->elementExists('css', "label[for={$inputId}]");
                 $this->assertSession()->elementTextContains('css', "label[for={$inputId}]", $fieldExpectation['label']);
                 unset($fieldsExpectations[$expectationId]);
                 reset($fieldsExpectations);
                 break;
             }
         }
     }
     Assertion::assertEmpty($fieldsExpectations, 'The following input fields were not found:' . implode(', ', array_map(function ($v) {
         return $v['label'];
     }, $fieldsExpectations)));
 }

 /**
  * @Then the JSON response should have the following nodes:
  *
  * @param TableNode $table
  */
 public function theJSONResponseIsComposedOf(TableNode $table)
 {
     $count = 0;
     foreach ($table->getColumnsHash() as $row) {
         ++$count;
         $expectedValue = $row['value'];
         // Check for null value
         // The `~` is used to specify null value (like in YAML) unless the type is explicitly set to string
         // in which case will be processed as the string '~'.
         if ('~' === $expectedValue && (false === array_key_exists('type', $row) || 'string' !== $row['type'])) {
             $this->theJsonNodeShouldBeNull($row['node']);
             continue;
         }
         // Default type is set to string
         $expectedValueType = 'string';
         if (array_key_exists('type', $row)) {
             // Trim the expected value type of all spaces before using its value
             $_expectedValueType = str_replace(' ', '', $row['type']);
             if (false === empty($_expectedValueType)) {
                 $expectedValueType = $_expectedValueType;
             }
             unset($_expectedValueType);
         }
         $expectedValue = $this->normalizeValue($row['value'], $expectedValueType);
         if (true === is_bool($expectedValue) || true === is_int($expectedValue)) {
             PHPUnit::assertEquals($expectedValue, $this->inspector->evaluate($this->getJson(), $row['node']));
             continue;
         }
         if ('array' === $expectedValueType) {
             $this->theJsonNodeShouldBeAnArray($row['node']);
             continue;
         }
         if ('object' === $expectedValueType) {
             $this->theJsonNodeShouldBeAnObject($row['node']);
             continue;
         }
         // If want to compare to an empty string, the value must be `""` in the table
         // Otherwise an empty string means no check on the value
         if ('""' === $expectedValue) {
             $this->theJsonNodeShouldBeEqualTo($row['node'], '');
             continue;
         }
         if ('' === $expectedValue) {
             $this->theJsonNodeShouldExist($row['node']);
             continue;
         }
         $this->theJsonNodeShouldBeEqualTo($row['node'], $expectedValue);
     }
     $nbrOfNodes = $this->getNumberOfNodes($this->getJson()->getContent());
     PHPUnit::assertEquals($nbrOfNodes, $count, sprintf('Expected to find %d nodes. Found %d instead', $nbrOfNodes, $count));
 }

 /**
  * @Given the following pages exist:
  */
 public function theFollowingPagesExist(TableNode $table)
 {
     $data = $table->getColumnsHash();
     $this->createStructures('page', $data);
 }

 /**
  * @Transform table:article_id
  *
  * @param TableNode $articleIds
  *
  * @return array
  */
 public function castArticleIds(TableNode $articleIds)
 {
     return array_column($articleIds->getColumnsHash(), 'article_id');
 }

 /**
  * @Then I should get:
  */
 public function iShouldGet(TableNode $table)
 {
     if (isset($this->response["error"])) {
         throw new \Exception($this->response["error"]);
     }
     $result = array_map(function ($item) {
         return ['Name' => $item["name"]];
     }, $this->response["completion"]);
     expect($table->getColumnsHash())->to->be->equal($result);
 }