Skip to content
Snippets Groups Projects
Commit 0b724181 authored by Jess's avatar Jess
Browse files

Revert "Issue #2870458 by Lendude, jibran, alexpott, vijaycs85, Wim Leers,... 

Revert "Issue #2870458 by Lendude, jibran, alexpott, vijaycs85, Wim Leers, dawehner, larowlan: Convert web tests to browser tests for quickedit module"

This reverts commit a9745363.
parent 34aa8307
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 808 additions and 586 deletions
core/modules/quickedit/tests/src/FunctionalJavascript/QuickEditAutocompleteTermTest.php → core/modules/quickedit/src/Tests/QuickEditAutocompleteTermTest.php
+ 215
− 0
View file @ 0b724181
<?php
namespace Drupal\Tests\quickedit\FunctionalJavascript;
namespace Drupal\quickedit\Tests;
use Drupal\Component\Serialization\Json;
use Drupal\Core\EventSubscriber\MainContentViewSubscriber;
use Drupal\Core\Field\FieldStorageDefinitionInterface;
use Drupal\Core\Language\LanguageInterface;
use Drupal\FunctionalJavascriptTests\WebDriverTestBase;
use Drupal\simpletest\WebTestBase;
use Drupal\taxonomy\Entity\Vocabulary;
use Drupal\taxonomy\Entity\Term;
use Drupal\Tests\contextual\FunctionalJavascript\ContextualLinkClickTrait;
use Drupal\Tests\field\Traits\EntityReferenceTestTrait;
/**
......@@ -15,21 +16,16 @@
*
* @group quickedit
*/
class QuickEditAutocompleteTermTest extends WebDriverTestBase {
class QuickEditAutocompleteTermTest extends WebTestBase {
use EntityReferenceTestTrait;
use ContextualLinkClickTrait;
/**
* {@inheritdoc}
* Modules to enable.
*
* @var array
*/
public static $modules = [
'node',
'taxonomy',
'quickedit',
'contextual',
'ckeditor',
];
public static $modules = ['node', 'taxonomy', 'quickedit'];
/**
* Stores the node used for the tests.
......@@ -73,15 +69,13 @@ class QuickEditAutocompleteTermTest extends WebDriverTestBase {
*/
protected $editorUser;
/**
* {@inheritdoc}
*/
protected function setUp() {
parent::setUp();
$this->drupalCreateContentType([
'type' => 'article',
]);
// Create the vocabulary for the tag field.
$this->vocabulary = Vocabulary::create([
'name' => 'quickedit testing tags',
'vid' => 'quickedit_testing_tags',
......@@ -126,65 +120,82 @@ protected function setUp() {
$node[$this->fieldName][]['target_id'] = $this->term2->id();
$this->node = $this->drupalCreateNode($node);
$this->editorUser = $this->drupalCreateUser([
'access content',
'create article content',
'edit any article content',
'administer nodes',
'access contextual links',
'access in-place editing',
]);
$this->editorUser = $this->drupalCreateUser(['access content', 'create article content', 'edit any article content', 'access in-place editing']);
}
/**
* Tests Quick Edit autocomplete term behavior.
*/
public function testAutocompleteQuickEdit() {
$page = $this->getSession()->getPage();
$assert = $this->assertSession();
$this->drupalLogin($this->editorUser);
$this->drupalGet('node/' . $this->node->id());
// Wait "Quick edit" button for node.
$assert->waitForElement('css', '[data-quickedit-entity-id="node/' . $this->node->id() . '"] .contextual .quickedit');
// Click by "Quick edit".
$this->clickContextualLink('[data-quickedit-entity-id="node/' . $this->node->id() . '"]', 'Quick edit');
// Switch to body field.
$page->find('css', '[data-quickedit-field-id="node/' . $this->node->id() . '/' . $this->fieldName . '/' . $this->node->language()->getId() . '/full"]')->click();
// Open Quick Edit.
$quickedit_field_locator = '[name="field_quickedit_testing_tags[target_id]"]';
$tag_field = $assert->waitForElementVisible('css', $quickedit_field_locator);
$tag_field->focus();
$tags = $tag_field->getValue();
// Check existing terms.
$this->assertTrue(strpos($tags, $this->term1->label()) !== FALSE);
$this->assertTrue(strpos($tags, $this->term2->label()) !== FALSE);
// Add new term.
$new_tag = $this->randomMachineName();
$tags .= ', ' . $new_tag;
$assert->waitForElementVisible('css', $quickedit_field_locator)->setValue($tags);
$assert->waitOnAutocomplete();
// Wait and click by "Save" button after body field was changed.
$assert->waitForElementVisible('css', '.quickedit-toolgroup.ops [type="submit"][aria-hidden="false"]')->click();
$assert->waitOnAutocomplete();
// Reload the page and check new term.
$this->drupalGet('node/' . $this->node->id());
$link = $assert->waitForLink($new_tag);
$this->assertNotEmpty($link);
$quickedit_uri = 'quickedit/form/node/' . $this->node->id() . '/' . $this->fieldName . '/' . $this->node->language()->getId() . '/full';
$post = ['nocssjs' => 'true'] + $this->getAjaxPageStatePostData();
$response = $this->drupalPost($quickedit_uri, '', $post, ['query' => [MainContentViewSubscriber::WRAPPER_FORMAT => 'drupal_ajax']]);
$ajax_commands = Json::decode($response);
// Prepare form values for submission. drupalPostAJAX() is not suitable for
// handling pages with JSON responses, so we need our own solution here.
$form_tokens_found = preg_match('/\sname="form_token" value="([^"]+)"/', $ajax_commands[0]['data'], $token_match) && preg_match('/\sname="form_build_id" value="([^"]+)"/', $ajax_commands[0]['data'], $build_id_match);
$this->assertTrue($form_tokens_found, 'Form tokens found in output.');
if ($form_tokens_found) {
$post = [
'form_id' => 'quickedit_field_form',
'form_token' => $token_match[1],
'form_build_id' => $build_id_match[1],
$this->fieldName . '[target_id]' => implode(', ', [$this->term1->getName(), 'new term', $this->term2->getName()]),
'op' => t('Save'),
];
// Submit field form and check response. Should render back all the terms.
$response = $this->drupalPost($quickedit_uri, '', $post, ['query' => [MainContentViewSubscriber::WRAPPER_FORMAT => 'drupal_ajax']]);
$this->assertResponse(200);
$ajax_commands = Json::decode($response);
$this->setRawContent($ajax_commands[0]['data']);
$this->assertLink($this->term1->getName());
$this->assertLink($this->term2->getName());
$this->assertText('new term');
$this->assertNoLink('new term');
// Load the form again, which should now get it back from
// PrivateTempStore.
$quickedit_uri = 'quickedit/form/node/' . $this->node->id() . '/' . $this->fieldName . '/' . $this->node->language()->getId() . '/full';
$post = ['nocssjs' => 'true'] + $this->getAjaxPageStatePostData();
$response = $this->drupalPost($quickedit_uri, '', $post, ['query' => [MainContentViewSubscriber::WRAPPER_FORMAT => 'drupal_ajax']]);
$ajax_commands = Json::decode($response);
// The AjaxResponse's first command is an InsertCommand which contains
// the form to edit the taxonomy term field, it should contain all three
// taxonomy terms, including the one that has just been newly created and
// which is not yet stored.
$this->setRawContent($ajax_commands[0]['data']);
$expected = [
$this->term1->getName() . ' (' . $this->term1->id() . ')',
'new term',
$this->term2->getName() . ' (' . $this->term2->id() . ')',
];
$this->assertFieldByName($this->fieldName . '[target_id]', implode(', ', $expected));
// Save the entity.
$post = ['nocssjs' => 'true'];
$response = $this->drupalPostWithFormat('quickedit/entity/node/' . $this->node->id(), 'json', $post);
$this->assertResponse(200);
// The full node display should now link to all entities, with the new
// one created in the database as well.
$this->drupalGet('node/' . $this->node->id());
$this->assertLink($this->term1->getName());
$this->assertLink($this->term2->getName());
$this->assertLink('new term');
}
}
/**
* Returns a new term with random name and description in $this->vocabulary.
*
* @return \Drupal\Core\Entity\EntityInterface|\Drupal\taxonomy\Entity\Term
* @return \Drupal\taxonomy\TermInterface
* The created taxonomy term.
*
* @throws \Drupal\Core\Entity\EntityStorageException
*/
protected function createTerm() {
$filter_formats = filter_formats();
......
core/modules/quickedit/src/Tests/QuickEditLoadingTest.php 0 → 100644
+ 593
− 0
View file @ 0b724181
This diff is collapsed.
core/modules/quickedit/tests/src/Functional/QuickEditCustomPipelineTest.php deleted 100644 → 0
+ 0
− 102
View file @ 34aa8307
<?php
namespace Drupal\Tests\quickedit\Functional;
use Drupal\Component\Serialization\Json;
use Drupal\Core\EventSubscriber\MainContentViewSubscriber;
use Drupal\Tests\BrowserTestBase;
/**
* Tests using a custom pipeline with Quick Edit.
*
* @group quickedit
*/
class QuickEditCustomPipelineTest extends BrowserTestBase {
/**
* {@inheritdoc}
*/
protected static $modules = [
'quickedit',
'quickedit_test',
'node',
];
/**
* Tests that Quick Edit works with custom render pipelines.
*/
public function testCustomPipeline() {
// Create a node type.
$this->drupalCreateContentType([
'type' => 'article',
'name' => 'Article',
]);
$node = $this->createNode(['type' => 'article']);
$editor_user = $this->drupalCreateUser([
'access content',
'create article content',
'edit any article content',
'access in-place editing',
]);
$this->drupalLogin($editor_user);
$custom_render_url = $this->buildUrl('quickedit/form/node/' . $node->id() . '/body/en/quickedit_test-custom-render-data');
$client = $this->getHttpClient();
$post = ['nocssjs' => 'true'];
$response = $client->post($custom_render_url, [
'body' => http_build_query($post),
'query' => [MainContentViewSubscriber::WRAPPER_FORMAT => 'drupal_ajax'],
'cookies' => $this->getSessionCookies(),
'headers' => [
'Accept' => 'application/json',
'Content-Type' => 'application/x-www-form-urlencoded',
],
'http_errors' => FALSE,
]);
$this->assertEquals(200, $response->getStatusCode());
$ajax_commands = Json::decode($response->getBody());
// Request editing to render results with the custom render pipeline.
// Prepare form values for submission. drupalPostAJAX() is not suitable for
// handling pages with JSON responses, so we need our own solution here.
$form_tokens_found = preg_match('/\sname="form_token" value="([^"]+)"/', $ajax_commands[0]['data'], $token_match) && preg_match('/\sname="form_build_id" value="([^"]+)"/', $ajax_commands[0]['data'], $build_id_match);
$this->assertTrue($form_tokens_found, 'Form tokens found in output.');
$post = [
'form_id' => 'quickedit_field_form',
'form_token' => $token_match[1],
'form_build_id' => $build_id_match[1],
'body[0][summary]' => '',
'body[0][value]' => '<p>Fine thanks.</p>',
'body[0][format]' => 'filtered_html',
'op' => t('Save'),
];
// Assume there is another field on this page, which doesn't use a custom
// render pipeline, but the default one, and it uses the "full" view mode.
$post += ['other_view_modes[]' => 'full'];
// Submit field form and check response. Should render with the custom
// render pipeline.
$response = $client->post($custom_render_url, [
'body' => http_build_query($post),
'query' => [MainContentViewSubscriber::WRAPPER_FORMAT => 'drupal_ajax'],
'cookies' => $this->getSessionCookies(),
'headers' => [
'Accept' => 'application/json',
'Content-Type' => 'application/x-www-form-urlencoded',
],
'http_errors' => FALSE,
]);
$ajax_commands = Json::decode($response->getBody());
$this->assertIdentical(1, count($ajax_commands), 'The field form HTTP request results in one AJAX command.');
$this->assertIdentical('quickeditFieldFormSaved', $ajax_commands[0]['command'], 'The first AJAX command is a quickeditFieldFormSaved command.');
$this->assertTrue(strpos($ajax_commands[0]['data'], 'Fine thanks.'), 'Form value saved and printed back.');
$this->assertTrue(strpos($ajax_commands[0]['data'], '<div class="quickedit-test-wrapper">') !== FALSE, 'Custom render pipeline used to render the value.');
$this->assertIdentical(array_keys($ajax_commands[0]['other_view_modes']), ['full'], 'Field was also rendered in the "full" view mode.');
$this->assertTrue(strpos($ajax_commands[0]['other_view_modes']['full'], 'Fine thanks.'), '"full" version of field contains the form value.');
}
}
core/modules/quickedit/tests/src/Functional/QuickEditEndPointAccessTest.php deleted 100644 → 0
+ 0
− 96
View file @ 34aa8307
<?php
namespace Drupal\Tests\quickedit\Functional;
use Drupal\Component\Serialization\Json;
use Drupal\Core\EventSubscriber\MainContentViewSubscriber;
use Drupal\Tests\BrowserTestBase;
use GuzzleHttp\RequestOptions;
/**
* Tests accessing the Quick Edit endpoints.
*
* @group quickedit
*/
class QuickEditEndPointAccessTest extends BrowserTestBase {
/**
* {@inheritdoc}
*/
protected static $modules = [
'quickedit',
'node',
];
/**
* {@inheritdoc}
*/
protected function setUp() {
parent::setUp();
$this->drupalCreateContentType([
'type' => 'article',
'name' => 'Article',
]);
}
/**
* Tests that Quick Edit endpoints are protected from anonymous requests.
*/
public function testEndPointAccess() {
// Quick Edit's JavaScript would never hit these endpoints, but we need to
// make sure that malicious users aren't able to use any of the other
// endpoints either.
$url = $this->buildUrl('/quickedit/attachments');
$post = ['editors[0]' => 'form'];
$this->assertAccessIsBlocked($url, $post);
$node = $this->createNode(['type' => 'article']);
$url = $this->buildUrl('quickedit/form/node/' . $node->id() . '/body/en/full');
$post = ['nocssjs' => 'true'];
$this->assertAccessIsBlocked($url, $post);
$edit = [];
$edit['form_id'] = 'quickedit_field_form';
$edit['form_token'] = 'xIOzMjuc-PULKsRn_KxFn7xzNk5Bx7XKXLfQfw1qOnA';
$edit['form_build_id'] = 'form-kVmovBpyX-SJfTT5kY0pjTV35TV-znor--a64dEnMR8';
$edit['body[0][summary]'] = '';
$edit['body[0][value]'] = '<p>Malicious content.</p>';
$edit['body[0][format]'] = 'filtered_html';
$edit['op'] = t('Save');
$this->assertAccessIsBlocked($url, $edit);
$post = ['nocssjs' => 'true'];
$url = $this->buildUrl('quickedit/entity/node/' . $node->id());
$this->assertAccessIsBlocked($url, $post);
}
/**
* Asserts that access to the passed URL is blocked.
*
* @param string $url
* The URL to check.
* @param array $body
* The payload to send with the request.
*/
protected function assertAccessIsBlocked($url, array $body) {
$client = $this->getHttpClient();
$message = ['message' => "The 'access in-place editing' permission is required."];
$response = $client->post($url, [
RequestOptions::BODY => http_build_query($body),
RequestOptions::QUERY => [MainContentViewSubscriber::WRAPPER_FORMAT => 'drupal_ajax'],
RequestOptions::COOKIES => $this->getSessionCookies(),
RequestOptions::HEADERS => [
'Accept' => 'application/json',
'Content-Type' => 'application/x-www-form-urlencoded',
],
RequestOptions::HTTP_ERRORS => FALSE,
]);
$this->assertEquals(403, $response->getStatusCode());
$response_message = Json::decode($response->getBody());
$this->assertSame($message, $response_message);
}
}
core/modules/quickedit/tests/src/FunctionalJavascript/QuickEditLoadingTest.php deleted 100644 → 0
+ 0
− 388
View file @ 34aa8307
<?php
namespace Drupal\Tests\quickedit\FunctionalJavascript;
use Behat\Mink\Session;
use Drupal\block_content\Entity\BlockContent;
use Drupal\Core\Entity\Entity\EntityViewDisplay;
use Drupal\field\Entity\FieldConfig;
use Drupal\field\Entity\FieldStorageConfig;
use Drupal\FunctionalJavascriptTests\WebDriverTestBase;
use Drupal\node\Entity\Node;
use Drupal\node\Entity\NodeType;
use Drupal\filter\Entity\FilterFormat;
use Drupal\Tests\contextual\FunctionalJavascript\ContextualLinkClickTrait;
use Drupal\Tests\TestFileCreationTrait;
/**
* Tests loading of in-place editing functionality and lazy loading of its
* in-place editors.
*
* @group quickedit
*/
class QuickEditLoadingTest extends WebDriverTestBase {
use ContextualLinkClickTrait;
use TestFileCreationTrait {
getTestFiles as drupalGetTestFiles;
}
/**
* Modules to enable.
*
* @var array
*/
public static $modules = [
'contextual',
'quickedit',
'filter',
'node',
'image',
];
/**
* An user with permissions to create and edit articles.
*
* @var \Drupal\user\UserInterface
*/
protected $authorUser;
/**
* A test node.
*
* @var \Drupal\node\NodeInterface
*/
protected $testNode;
/**
* A author user with permissions to access in-place editor.
*
* @var \Drupal\user\UserInterface
*/
protected $editorUser;
/**
* {@inheritdoc}
*/
protected function setUp() {
parent::setUp();
// Create a text format.
$filtered_html_format = FilterFormat::create([
'format' => 'filtered_html',
'name' => 'Filtered HTML',
'weight' => 0,
'filters' => [],
]);
$filtered_html_format->save();
// Create a node type.
$this->drupalCreateContentType([
'type' => 'article',
'name' => 'Article',
]);
// Set the node type to initially not have revisions.
// Testing with revisions will be done later.
$node_type = NodeType::load('article');
$node_type->setNewRevision(FALSE);
$node_type->save();
// Create one node of the above node type using the above text format.
$this->testNode = $this->drupalCreateNode([
'type' => 'article',
'body' => [
0 => [
'value' => '<p>How are you?</p>',
'format' => 'filtered_html',
],
],
'revision_log' => $this->randomString(),
]);
// Create 2 users, the only difference being the ability to use in-place
// editing
$basic_permissions = [
'access content',
'create article content',
'edit any article content',
'use text format filtered_html',
'access contextual links',
];
$this->authorUser = $this->drupalCreateUser($basic_permissions);
$this->editorUser = $this->drupalCreateUser(array_merge($basic_permissions, ['access in-place editing']));
}
/**
* Test the loading of Quick Edit with different permissions.
*/
public function testUserPermissions() {
$assert = $this->assertSession();
$this->drupalLogin($this->authorUser);
$this->drupalGet('node/1');
// Library and in-place editors.
$this->assertNoRaw('core/modules/quickedit/js/quickedit.js', 'Quick Edit library not loaded.');
$this->assertNoRaw('core/modules/quickedit/js/editors/formEditor.js', "'form' in-place editor not loaded.");
// HTML annotation and title class does not exist for users without
// permission to in-place edit.
$this->assertNoRaw('data-quickedit-entity-id="node/1"');
$this->assertNoRaw('data-quickedit-field-id="node/1/body/en/full"');
$this->assertNoFieldByXPath('//h1[contains(@class, "js-quickedit-page-title")]');
$assert->linkNotExists('Quick edit');
// Tests the loading of Quick Edit when a user does have access to it.
// Also ensures lazy loading of in-place editors works.
$nid = $this->testNode->id();
// There should be only one revision so far.
$node = Node::load($nid);
$vids = \Drupal::entityManager()->getStorage('node')->revisionIds($node);
$this->assertCount(1, $vids, 'The node has only one revision.');
$original_log = $node->revision_log->value;
$this->drupalLogin($this->editorUser);
$this->drupalGet('node/' . $nid);
$page = $this->getSession()->getPage();
// Wait "Quick edit" button for node.
$assert->waitForElement('css', '[data-quickedit-entity-id="node/' . $nid . '"] .contextual .quickedit');
// Click by "Quick edit".
$this->clickContextualLink('[data-quickedit-entity-id="node/' . $nid . '"]', 'Quick edit');
// Switch to body field.
$page->find('css', '[data-quickedit-field-id="node/' . $nid . '/body/en/full"]')->click();
$assert->assertWaitOnAjaxRequest();
// Wait and update body field.
$body_field_locator = '[name="body[0][value]"]';
$body_text = 'Fine thanks.';
$assert->waitForElementVisible('css', $body_field_locator)->setValue('<p>' . $body_text . '</p>');
// Wait and click by "Save" button after body field was changed.
$assert->waitForElementVisible('css', '.quickedit-toolgroup.ops [type="submit"][aria-hidden="false"]')->click();
$assert->assertWaitOnAjaxRequest();
$node = Node::load($nid);
$vids = \Drupal::entityManager()->getStorage('node')->revisionIds($node);
$this->assertCount(1, $vids, 'The node has only one revision.');
$this->assertSame($original_log, $node->revision_log->value, 'The revision log message is unchanged.');
// Ensure that the changes take effect.
$assert->responseMatches("|\s*$body_text\s*|");
// Reload the page and check for updated body.
$this->drupalGet('node/' . $nid);
$assert->pageTextContains($body_text);
}
/**
* Test Quick Edit does not appear for entities with pending revisions.
*/
public function testWithPendingRevision() {
$this->drupalLogin($this->editorUser);
// Verify that the preview is loaded correctly.
$this->drupalPostForm('node/add/article', ['title[0][value]' => 'foo'], 'Preview');
// Verify that quickedit is not active on preview.
$this->assertNoRaw('data-quickedit-entity-id="node/' . $this->testNode->id() . '"');
$this->assertNoRaw('data-quickedit-field-id="node/' . $this->testNode->id() . '/title/' . $this->testNode->language()->getId() . '/full"');
$this->drupalGet('node/' . $this->testNode->id());
$this->assertRaw('data-quickedit-entity-id="node/' . $this->testNode->id() . '"');
$this->assertRaw('data-quickedit-field-id="node/' . $this->testNode->id() . '/title/' . $this->testNode->language()->getId() . '/full"');
$this->testNode->title = 'Updated node';
$this->testNode->setNewRevision(TRUE);
$this->testNode->isDefaultRevision(FALSE);
$this->testNode->save();
$this->drupalGet('node/' . $this->testNode->id());
$this->assertNoRaw('data-quickedit-entity-id="node/' . $this->testNode->id() . '"');
$this->assertNoRaw('data-quickedit-field-id="node/' . $this->testNode->id() . '/title/' . $this->testNode->language()->getId() . '/full"');
}
/**
* Tests the loading of Quick Edit for the title base field.
*/
public function testTitleBaseField() {
$page = $this->getSession()->getPage();
$assert = $this->assertSession();
$nid = $this->testNode->id();
$this->drupalLogin($this->editorUser);
$this->drupalGet('node/' . $nid);
// Wait "Quick edit" button for node.
$assert->waitForElement('css', '[data-quickedit-entity-id="node/' . $nid . '"] .contextual .quickedit');
// Click by "Quick edit".
$this->clickContextualLink('[data-quickedit-entity-id="node/' . $nid . '"]', 'Quick edit');
// Switch to title field.
$page->find('css', '[data-quickedit-field-id="node/' . $nid . '/title/en/full"]')->click();
$assert->assertWaitOnAjaxRequest();
// Wait and update title field.
$field_locator = '.field--name-title';
$text_new = 'Obligatory question';
$assert->waitForElementVisible('css', $field_locator)->setValue($text_new);
// Wait and click by "Save" button after title field was changed.
$this->assertSession()->waitForElementVisible('css', '.quickedit-toolgroup.ops [type="submit"][aria-hidden="false"]')->click();
$assert->assertWaitOnAjaxRequest();
// Ensure that the changes take effect.
$assert->responseMatches("|\s*$text_new\s*|");
// Reload the page and check for updated title.
$this->drupalGet('node/' . $nid);
$assert->pageTextContains($text_new);
}
/**
* Tests that Quick Edit doesn't make fields rendered with display options
* editable.
*/
public function testDisplayOptions() {
$node = Node::load('1');
$display_settings = [
'label' => 'inline',
];
$build = $node->body->view($display_settings);
$output = \Drupal::service('renderer')->renderRoot($build);
$this->assertFalse(strpos($output, 'data-quickedit-field-id'), 'data-quickedit-field-id attribute not added when rendering field using dynamic display options.');
}
/**
* Tests Quick Edit on a node that was concurrently edited on the full node
* form.
*/
public function testConcurrentEdit() {
$nid = $this->testNode->id();
$this->drupalLogin($this->authorUser);
// Open the edit page in the default session.
$this->drupalGet('node/' . $nid . '/edit');
// Switch to a concurrent session and save a quick edit change.
// We need to do some bookkeeping to keep track of the logged in user.
$logged_in_user = $this->loggedInUser;
$this->loggedInUser = FALSE;
// Register a session to preform concurrent editing.
$driver = $this->getDefaultDriverInstance();
$session = new Session($driver);
$this->mink->registerSession('concurrent', $session);
$this->mink->setDefaultSessionName('concurrent');
$this->initFrontPage();
$this->drupalLogin($this->editorUser);
$this->drupalGet('node/' . $nid);
$assert = $this->assertSession();
$page = $this->getSession()->getPage();
// Wait "Quick edit" button for node.
$assert->waitForElement('css', '[data-quickedit-entity-id="node/' . $nid . '"] .contextual .quickedit');
// Click by "Quick edit".
$this->clickContextualLink('[data-quickedit-entity-id="node/' . $nid . '"]', 'Quick edit');
// Switch to body field.
$page->find('css', '[data-quickedit-field-id="node/' . $nid . '/body/en/full"]')->click();
$assert->assertWaitOnAjaxRequest();
// Wait and update body field.
$body_field_locator = '[name="body[0][value]"]';
$body_text = 'Fine thanks.';
$assert->waitForElementVisible('css', $body_field_locator)->setValue('<p>' . $body_text . '</p>');
// Wait and click by "Save" button after body field was changed.
$assert->waitForElementVisible('css', '.quickedit-toolgroup.ops [type="submit"][aria-hidden="false"]')->click();
$assert->assertWaitOnAjaxRequest();
// Ensure that the changes take effect.
$assert->responseMatches("|\s*$body_text\s*|");
// Switch back to the default session.
$this->mink->setDefaultSessionName('default');
$this->loggedInUser = $logged_in_user;
// Ensure different save timestamps for field editing.
sleep(2);
$this->drupalPostForm(NULL, ['body[0][value]' => '<p>Concurrent edit!</p>'], 'Save');
$this->getSession()->getPage()->hasContent('The content has either been modified by another user, or you have already submitted modifications. As a result, your changes cannot be saved.');
}
/**
* Tests that Quick Edit's data- attributes are present for content blocks.
*/
public function testContentBlock() {
\Drupal::service('module_installer')->install(['block_content']);
// Create and place a content_block block.
$block = BlockContent::create([
'info' => $this->randomMachineName(),
'type' => 'basic',
'langcode' => 'en',
]);
$block->save();
$this->drupalPlaceBlock('block_content:' . $block->uuid());
// Check that the data- attribute is present.
$this->drupalLogin($this->editorUser);
$this->drupalGet('');
$this->assertRaw('data-quickedit-entity-id="block_content/1"');
}
/**
* Tests that Quick Edit can handle an image field.
*/
public function testImageField() {
$page = $this->getSession()->getPage();
$assert = $this->assertSession();
// Add an image field to the content type.
FieldStorageConfig::create([
'field_name' => 'field_image',
'type' => 'image',
'entity_type' => 'node',
])->save();
FieldConfig::create([
'field_name' => 'field_image',
'field_type' => 'image',
'label' => t('Image'),
'entity_type' => 'node',
'bundle' => 'article',
])->save();
entity_get_form_display('node', 'article', 'default')
->setComponent('field_image', [
'type' => 'image_image',
])
->save();
$display = EntityViewDisplay::load('node.article.default');
$display->setComponent('field_image', [
'type' => 'image',
])->save();
// Add an image to the node.
$this->drupalLogin($this->editorUser);
$this->drupalGet('node/1/edit');
$image = $this->drupalGetTestFiles('image')[0];
$image_path = $this->container->get('file_system')->realpath($image->uri);
$page->attachFileToField('files[field_image_0]', $image_path);
$alt_field = $assert->waitForField('field_image[0][alt]');
$this->assertNotEmpty($alt_field);
$this->drupalPostForm(NULL, [
'field_image[0][alt]' => 'Vivamus aliquet elit',
], t('Save'));
// The image field form should load normally.
// Wait "Quick edit" button for node.
$assert->waitForElement('css', '[data-quickedit-entity-id="node/1"] .contextual .quickedit');
// Click by "Quick edit".
$this->clickContextualLink('[data-quickedit-entity-id="node/1"]', 'Quick edit');
// Switch to body field.
$assert->waitForElement('css', '[data-quickedit-field-id="node/1/field_image/en/full"]')->click();
$assert->assertWaitOnAjaxRequest();
$field_locator = '.field--name-field-image';
$assert->waitForElementVisible('css', $field_locator);
}
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment