opdavies/drupalcampbristol
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update Composer, update everything

Browse source
This commit is contained in:
Oliver Davies 2018-11-23 12:29:20 +00:00
parent ea3e94409f
commit dda5c284b6
19527 changed files with 1135420 additions and 351004 deletions
Download patch file Download diff file Expand all files Collapse all files

19
web/core/modules/dblog/tests/fixtures/update/dblog-2851293.php vendored Normal file
View file

@ -0,0 +1,19 @@
<?php
/**
* @file
* Test fixture.
*/
use Drupal\Core\Database\Database;
use Drupal\Core\Serialization\Yaml;
$connection = Database::getConnection();
$connection->insert('config')
->fields([
'collection' => '',
'name' => 'views.view.dblog_2851293',
'data' => serialize(Yaml::decode(file_get_contents('core/modules/dblog/tests/modules/dblog_test_views/test_views/views.view.dblog_2851293.yml'))),
])
->execute();

4
web/core/modules/dblog/tests/modules/dblog_test_views/dblog_test_views.info.yml
View file

@ -5,5 +5,5 @@ package: Testing
version: VERSION
core: 8.x
dependencies:
- dblog
- views
- drupal:dblog
- drupal:views

148
web/core/modules/dblog/tests/modules/dblog_test_views/test_views/views.view.dblog_2851293.yml Normal file
View file

@ -0,0 +1,148 @@
langcode: en
status: true
dependencies:
module:
- user
id: dblog_2851293
label: dblog_2851293
module: views
description: 'Base view to test upgrade from issue #2851293'
tag: ''
base_table: watchdog
base_field: wid
core: 8.x
display:
default:
display_plugin: default
id: default
display_title: Master
position: 0
display_options:
access:
type: perm
options:
perm: 'access site reports'
cache:
type: none
options: { }
query:
type: views_query
options:
disable_sql_rewrite: false
distinct: false
replica: false
query_comment: ''
query_tags: { }
exposed_form:
type: basic
options:
submit_button: Filter
reset_button: false
reset_button_label: Reset
exposed_sorts_label: 'Sort by'
expose_sort_order: true
sort_asc_label: Asc
sort_desc_label: Desc
pager:
type: some
options:
items_per_page: 10
offset: 0
style:
type: default
options:
grouping: { }
row_class: ''
default_row_class: true
uses_fields: false
row:
type: fields
options:
inline: { }
separator: ''
hide_empty: false
default_field_elements: true
fields:
wid:
table: watchdog
field: wid
id: wid
entity_type: null
entity_field: null
plugin_id: numeric
relationship: none
group_type: group
admin_label: ''
label: ''
exclude: false
empty: ''
hide_empty: false
empty_zero: false
hide_alter_empty: true
set_precision: false
precision: 0
decimal: .
separator: ','
format_plural: false
format_plural_string: "1\x03@count"
prefix: ''
suffix: ''
uid:
id: uid
table: watchdog
field: uid
relationship: none
group_type: group
admin_label: ''
label: ''
exclude: false
empty: ''
hide_empty: false
empty_zero: false
hide_alter_empty: true
set_precision: false
precision: 0
decimal: .
separator: ','
format_plural: false
format_plural_string: "1\x03@count"
prefix: ''
suffix: ''
plugin_id: numeric
filters:
type:
id: type
table: watchdog
field: type
relationship: none
group_type: group
admin_label: ''
operator: in
value: { }
group: 1
exposed: true
expose:
operator_id: type_op
label: Type
description: ''
use_operator: false
operator: type_op
identifier: type
required: false
remember: false
multiple: true
reduce: false
plugin_id: in_operator
sorts: { }
header: { }
footer: { }
empty: { }
relationships: { }
arguments: { }
display_extenders: { }
cache_metadata:
max-age: -1
contexts:
- 'languages:language_interface'
- user.permissions
tags: { }

505
web/core/modules/dblog/tests/modules/dblog_test_views/test_views/views.view.dblog_integration_test.yml Normal file
View file

@ -0,0 +1,505 @@
langcode: en
status: true
dependencies:
module:
- dblog
- user
id: dblog_integration_test
label: dblog_integration_test
module: views
description: ''
tag: ''
base_table: watchdog
base_field: wid
core: 8.x
display:
default:
display_plugin: default
id: default
display_title: Master
position: 0
display_options:
access:
type: perm
options:
perm: 'access site reports'
cache:
type: tag
options: { }
query:
type: views_query
options:
disable_sql_rewrite: false
distinct: false
replica: false
query_comment: ''
query_tags: { }
exposed_form:
type: basic
options:
submit_button: Filter
reset_button: false
reset_button_label: Reset
exposed_sorts_label: 'Sort by'
expose_sort_order: true
sort_asc_label: Asc
sort_desc_label: Desc
pager:
type: mini
options:
items_per_page: 10
offset: 0
id: 0
total_pages: null
expose:
items_per_page: false
items_per_page_label: 'Items per page'
items_per_page_options: '5, 10, 25, 50'
items_per_page_options_all: false
items_per_page_options_all_label: '- All -'
offset: false
offset_label: Offset
tags:
previous: ‹‹
next: ››
style:
type: default
row:
type: fields
fields:
wid:
table: watchdog
field: wid
id: wid
entity_type: null
entity_field: null
plugin_id: standard
relationship: none
group_type: group
admin_label: ''
label: ''
exclude: false
alter:
alter_text: false
text: ''
make_link: false
path: ''
absolute: false
external: false
replace_spaces: false
path_case: none
trim_whitespace: false
alt: ''
rel: ''
link_class: ''
prefix: ''
suffix: ''
target: ''
nl2br: false
max_length: 0
word_boundary: true
ellipsis: true
more_link: false
more_link_text: ''
more_link_path: ''
strip_tags: false
trim: false
preserve_tags: ''
html: false
element_type: ''
element_class: ''
element_label_type: ''
element_label_class: ''
element_label_colon: true
element_wrapper_type: ''
element_wrapper_class: ''
element_default_classes: true
empty: ''
hide_empty: false
empty_zero: false
hide_alter_empty: true
message:
id: message
table: watchdog
field: message
relationship: none
group_type: group
admin_label: ''
label: ''
exclude: false
alter:
alter_text: false
text: ''
make_link: false
path: ''
absolute: false
external: false
replace_spaces: false
path_case: none
trim_whitespace: false
alt: ''
rel: ''
link_class: ''
prefix: ''
suffix: ''
target: ''
nl2br: false
max_length: 0
word_boundary: true
ellipsis: true
more_link: false
more_link_text: ''
more_link_path: ''
strip_tags: false
trim: false
preserve_tags: ''
html: false
element_type: ''
element_class: ''
element_label_type: ''
element_label_class: ''
element_label_colon: false
element_wrapper_type: ''
element_wrapper_class: ''
element_default_classes: true
empty: ''
hide_empty: false
empty_zero: false
hide_alter_empty: true
replace_variables: true
plugin_id: dblog_message
link:
id: link
table: watchdog
field: link
relationship: none
group_type: group
admin_label: ''
label: ''
exclude: false
alter:
alter_text: false
text: ''
make_link: false
path: ''
absolute: false
external: false
replace_spaces: false
path_case: none
trim_whitespace: false
alt: ''
rel: ''
link_class: ''
prefix: ''
suffix: ''
target: ''
nl2br: false
max_length: 0
word_boundary: true
ellipsis: true
more_link: false
more_link_text: ''
more_link_path: ''
strip_tags: false
trim: false
preserve_tags: ''
html: false
element_type: ''
element_class: ''
element_label_type: ''
element_label_class: ''
element_label_colon: false
element_wrapper_type: ''
element_wrapper_class: ''
element_default_classes: true
empty: ''
hide_empty: false
empty_zero: false
hide_alter_empty: true
plugin_id: dblog_operations
severity:
id: severity
table: watchdog
field: severity
relationship: none
group_type: group
admin_label: ''
label: ''
exclude: false
alter:
alter_text: false
text: ''
make_link: false
path: ''
absolute: false
external: false
replace_spaces: false
path_case: none
trim_whitespace: false
alt: ''
rel: ''
link_class: ''
prefix: ''
suffix: ''
target: ''
nl2br: false
max_length: 0
word_boundary: true
ellipsis: true
more_link: false
more_link_text: ''
more_link_path: ''
strip_tags: false
trim: false
preserve_tags: ''
html: false
element_type: ''
element_class: ''
element_label_type: ''
element_label_class: ''
element_label_colon: false
element_wrapper_type: ''
element_wrapper_class: ''
element_default_classes: true
empty: ''
hide_empty: false
empty_zero: false
hide_alter_empty: true
machine_name: false
plugin_id: machine_name
type:
id: type
table: watchdog
field: type
relationship: none
group_type: group
admin_label: ''
label: ''
exclude: false
alter:
alter_text: false
text: ''
make_link: false
path: ''
absolute: false
external: false
replace_spaces: false
path_case: none
trim_whitespace: false
alt: ''
rel: ''
link_class: ''
prefix: ''
suffix: ''
target: ''
nl2br: false
max_length: 0
word_boundary: true
ellipsis: true
more_link: false
more_link_text: ''
more_link_path: ''
strip_tags: false
trim: false
preserve_tags: ''
html: false
element_type: ''
element_class: ''
element_label_type: ''
element_label_class: ''
element_label_colon: false
element_wrapper_type: ''
element_wrapper_class: ''
element_default_classes: true
empty: ''
hide_empty: false
empty_zero: false
hide_alter_empty: true
plugin_id: standard
name:
id: name
table: users_field_data
field: name
relationship: uid
group_type: group
admin_label: ''
label: ''
exclude: false
alter:
alter_text: false
text: ''
make_link: false
path: ''
absolute: false
external: false
replace_spaces: false
path_case: none
trim_whitespace: false
alt: ''
rel: ''
link_class: ''
prefix: ''
suffix: ''
target: ''
nl2br: false
max_length: 0
word_boundary: true
ellipsis: true
more_link: false
more_link_text: ''
more_link_path: ''
strip_tags: false
trim: false
preserve_tags: ''
html: false
element_type: ''
element_class: ''
element_label_type: ''
element_label_class: ''
element_label_colon: false
element_wrapper_type: ''
element_wrapper_class: ''
element_default_classes: true
empty: ''
hide_empty: false
empty_zero: false
hide_alter_empty: true
click_sort_column: value
type: user_name
settings:
link_to_entity: true
group_column: value
group_columns: { }
group_rows: true
delta_limit: 0
delta_offset: 0
delta_reversed: false
delta_first_last: false
multi_type: separator
separator: ', '
field_api_classes: false
entity_type: user
entity_field: name
plugin_id: field
filters:
severity:
id: severity
table: watchdog
field: severity
relationship: none
group_type: group
admin_label: ''
operator: in
value: { }
group: 1
exposed: true
expose:
operator_id: severity_op
label: 'Severity level'
description: ''
use_operator: false
operator: severity_op
identifier: severity
required: false
remember: false
multiple: true
remember_roles:
authenticated: authenticated
anonymous: '0'
administrator: '0'
reduce: false
is_grouped: false
group_info:
label: ''
description: ''
identifier: ''
optional: true
widget: select
multiple: false
remember: false
default_group: All
default_group_multiple: { }
group_items: { }
plugin_id: in_operator
type:
id: type
table: watchdog
field: type
relationship: none
group_type: group
admin_label: ''
operator: in
value: { }
group: 1
exposed: true
expose:
operator_id: type_op
label: Type
description: ''
use_operator: false
operator: type_op
identifier: type
required: false
remember: false
multiple: true
remember_roles:
authenticated: authenticated
anonymous: '0'
administrator: '0'
reduce: false
is_grouped: false
group_info:
label: ''
description: ''
identifier: ''
optional: true
widget: select
multiple: false
remember: false
default_group: All
default_group_multiple: { }
group_items: { }
plugin_id: dblog_types
sorts: { }
title: dblog_integration_test
header: { }
footer: { }
empty: { }
relationships:
uid:
id: uid
table: watchdog
field: uid
relationship: none
group_type: group
admin_label: uid
required: false
plugin_id: standard
arguments: { }
display_extenders: { }
cache_metadata:
max-age: -1
contexts:
- 'languages:language_content'
- 'languages:language_interface'
- url
- url.query_args
- user.permissions
tags: { }
page_1:
display_plugin: page
id: page_1
display_title: Page
position: 1
display_options:
display_extenders: { }
path: dblog-integration-test
cache_metadata:
max-age: -1
contexts:
- 'languages:language_content'
- 'languages:language_interface'
- url
- url.query_args
- user.permissions
tags: { }

127
web/core/modules/dblog/tests/src/Functional/DbLogResourceTest.php Normal file
View file

@ -0,0 +1,127 @@
<?php
namespace Drupal\Tests\dblog\Functional;
use Drupal\Component\Serialization\Json;
use Drupal\Core\Url;
use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
use Drupal\Tests\rest\Functional\ResourceTestBase;
/**
* Tests the watchdog database log resource.
*
* @group dblog
*/
class DbLogResourceTest extends ResourceTestBase {
use CookieResourceTestTrait;
/**
* {@inheritdoc}
*/
protected static $format = 'hal_json';
/**
* {@inheritdoc}
*/
protected static $mimeType = 'application/hal+json';
/**
* {@inheritdoc}
*/
protected static $auth = 'cookie';
/**
* {@inheritdoc}
*/
protected static $resourceConfigId = 'dblog';
/**
* {@inheritdoc}
*/
public static $modules = ['hal', 'dblog'];
/**
* {@inheritdoc}
*/
public function setUp() {
parent::setUp();
$auth = isset(static::$auth) ? [static::$auth] : [];
$this->provisionResource([static::$format], $auth);
}
/**
* Writes a log messages and retrieves it via the REST API.
*/
public function testWatchdog() {
// Write a log message to the DB.
$this->container->get('logger.channel.rest')->notice('Test message');
// Get the ID of the written message.
$id = db_query_range("SELECT wid FROM {watchdog} WHERE type = :type ORDER BY wid DESC", 0, 1, [':type' => 'rest'])
->fetchField();
$this->initAuthentication();
$url = Url::fromRoute('rest.dblog.GET', ['id' => $id, '_format' => static::$format]);
$request_options = $this->getAuthenticationRequestOptions('GET');
$response = $this->request('GET', $url, $request_options);
$this->assertResourceErrorResponse(403, "The 'restful get dblog' permission is required.", $response);
// Create a user account that has the required permissions to read
// the watchdog resource via the REST API.
$this->setUpAuthorization('GET');
$response = $this->request('GET', $url, $request_options);
$this->assertResourceResponse(200, FALSE, $response, ['config:rest.resource.dblog', 'config:rest.settings', 'http_response'], ['user.permissions'], FALSE, 'MISS');
$log = Json::decode((string) $response->getBody());
$this->assertEqual($log['wid'], $id, 'Log ID is correct.');
$this->assertEqual($log['type'], 'rest', 'Type of log message is correct.');
$this->assertEqual($log['message'], 'Test message', 'Log message text is correct.');
// Request an unknown log entry.
$url->setRouteParameter('id', 9999);
$response = $this->request('GET', $url, $request_options);
$this->assertResourceErrorResponse(404, 'Log entry with ID 9999 was not found', $response);
// Make a bad request (a true malformed request would never be a route match).
$url->setRouteParameter('id', 0);
$response = $this->request('GET', $url, $request_options);
$this->assertResourceErrorResponse(400, 'No log entry ID was provided', $response);
}
/**
* {@inheritdoc}
*/
protected function setUpAuthorization($method) {
switch ($method) {
case 'GET':
$this->grantPermissionsToTestedRole(['restful get dblog']);
break;
default:
throw new \UnexpectedValueException();
}
}
/**
* {@inheritdoc}
*/
protected function assertNormalizationEdgeCases($method, Url $url, array $request_options) {}
/**
* {@inheritdoc}
*/
protected function getExpectedUnauthorizedAccessMessage($method) {}
/**
* {@inheritdoc}
*/
protected function getExpectedBcUnauthorizedAccessMessage($method) {}
/**
* {@inheritdoc}
*/
protected function getExpectedUnauthorizedAccessCacheability() {}
}

740
web/core/modules/dblog/tests/src/Functional/DbLogTest.php Normal file
View file

@ -0,0 +1,740 @@
<?php
namespace Drupal\Tests\dblog\Functional;
use Drupal\Component\Utility\Html;
use Drupal\Component\Utility\Unicode;
use Drupal\Core\Logger\RfcLogLevel;
use Drupal\Core\Url;
use Drupal\dblog\Controller\DbLogController;
use Drupal\Tests\BrowserTestBase;
/**
* Generate events and verify dblog entries; verify user access to log reports
* based on permissions.
*
* @group dblog
*/
class DbLogTest extends BrowserTestBase {
use FakeLogEntries;
/**
* Modules to enable.
*
* @var array
*/
public static $modules = ['dblog', 'node', 'forum', 'help', 'block'];
/**
* A user with some relevant administrative permissions.
*
* @var \Drupal\user\UserInterface
*/
protected $adminUser;
/**
* A user without any permissions.
*
* @var \Drupal\user\UserInterface
*/
protected $webUser;
/**
* {@inheritdoc}
*/
protected function setUp() {
parent::setUp();
$this->drupalPlaceBlock('system_breadcrumb_block');
$this->drupalPlaceBlock('page_title_block');
// Create users with specific permissions.
$this->adminUser = $this->drupalCreateUser(['administer site configuration', 'access administration pages', 'access site reports', 'administer users']);
$this->webUser = $this->drupalCreateUser([]);
}
/**
* Tests Database Logging module functionality through interfaces.
*
* First logs in users, then creates database log events, and finally tests
* Database Logging module functionality through both the admin and user
* interfaces.
*/
public function testDbLog() {
// Log in the admin user.
$this->drupalLogin($this->adminUser);
$row_limit = 100;
$this->verifyRowLimit($row_limit);
$this->verifyEvents();
$this->verifyReports();
$this->verifyBreadcrumbs();
$this->verifyLinkEscaping();
// Verify the overview table sorting.
$orders = ['Date', 'Type', 'User'];
$sorts = ['asc', 'desc'];
foreach ($orders as $order) {
foreach ($sorts as $sort) {
$this->verifySort($sort, $order);
}
}
// Log in the regular user.
$this->drupalLogin($this->webUser);
$this->verifyReports(403);
}
/**
* Test individual log event page.
*/
public function testLogEventPage() {
// Login the admin user.
$this->drupalLogin($this->adminUser);
// Since referrer and location links vary by how the tests are run, inject
// fake log data to test these.
$context = [
'request_uri' => 'http://example.com?dblog=1',
'referer' => 'http://example.org?dblog=2',
'uid' => 0,
'channel' => 'testing',
'link' => 'foo/bar',
'ip' => '0.0.1.0',
'timestamp' => REQUEST_TIME,
];
\Drupal::service('logger.dblog')->log(RfcLogLevel::NOTICE, 'Test message', $context);
$wid = db_query('SELECT MAX(wid) FROM {watchdog}')->fetchField();
// Verify the links appear correctly.
$this->drupalGet('admin/reports/dblog/event/' . $wid);
$this->assertLinkByHref($context['request_uri']);
$this->assertLinkByHref($context['referer']);
// Verify hostname.
$this->assertRaw($context['ip'], 'Found hostname on the detail page.');
// Verify severity.
$this->assertText('Notice', 'The severity was properly displayed on the detail page.');
}
/**
* Verifies setting of the database log row limit.
*
* @param int $row_limit
* The row limit.
*/
private function verifyRowLimit($row_limit) {
// Change the database log row limit.
$edit = [];
$edit['dblog_row_limit'] = $row_limit;
$this->drupalPostForm('admin/config/development/logging', $edit, t('Save configuration'));
$this->assertResponse(200);
// Check row limit variable.
$current_limit = $this->config('dblog.settings')->get('row_limit');
$this->assertTrue($current_limit == $row_limit, format_string('[Cache] Row limit variable of @count equals row limit of @limit', ['@count' => $current_limit, '@limit' => $row_limit]));
}
/**
* Clear the entry logs by clicking on 'Clear log messages' button.
*/
protected function clearLogsEntries() {
$this->drupalGet(Url::fromRoute('dblog.confirm'));
}
/**
* Filters the logs according to the specific severity and log entry type.
*
* @param string $type
* (optional) The log entry type.
* @param string $severity
* (optional) The log entry severity.
*/
protected function filterLogsEntries($type = NULL, $severity = NULL) {
$edit = [];
if (isset($type)) {
$edit['type[]'] = $type;
}
if (isset($severity)) {
$edit['severity[]'] = $severity;
}
$this->drupalPostForm(NULL, $edit, t('Filter'));
}
/**
* Confirms that database log reports are displayed at the correct paths.
*
* @param int $response
* (optional) HTTP response code. Defaults to 200.
*/
private function verifyReports($response = 200) {
// View the database log help page.
$this->drupalGet('admin/help/dblog');
$this->assertResponse($response);
if ($response == 200) {
$this->assertText(t('Database Logging'), 'DBLog help was displayed');
}
// View the database log report page.
$this->drupalGet('admin/reports/dblog');
$this->assertResponse($response);
if ($response == 200) {
$this->assertText(t('Recent log messages'), 'DBLog report was displayed');
}
$this->drupalGet('admin/reports/dblog/confirm');
$this->assertResponse($response);
if ($response == 200) {
$this->assertText(t('Are you sure you want to delete the recent logs?'), 'DBLog clear logs form was displayed');
}
// View the database log page-not-found report page.
$this->drupalGet('admin/reports/page-not-found');
$this->assertResponse($response);
if ($response == 200) {
$this->assertText("Top 'page not found' errors", 'DBLog page-not-found report was displayed');
}
// View the database log access-denied report page.
$this->drupalGet('admin/reports/access-denied');
$this->assertResponse($response);
if ($response == 200) {
$this->assertText("Top 'access denied' errors", 'DBLog access-denied report was displayed');
}
// View the database log event page.
$wid = db_query('SELECT MIN(wid) FROM {watchdog}')->fetchField();
$this->drupalGet('admin/reports/dblog/event/' . $wid);
$this->assertResponse($response);
if ($response == 200) {
$this->assertText(t('Details'), 'DBLog event node was displayed');
}
}
/**
* Generates and then verifies breadcrumbs.
*/
private function verifyBreadcrumbs() {
// View the database log event page.
$wid = db_query('SELECT MIN(wid) FROM {watchdog}')->fetchField();
$this->drupalGet('admin/reports/dblog/event/' . $wid);
$xpath = '//nav[@class="breadcrumb"]/ol/li[last()]/a';
$this->assertEqual(current($this->xpath($xpath))->getText(), 'Recent log messages', 'DBLogs link displayed at breadcrumb in event page.');
}
/**
* Generates and then verifies various types of events.
*/
private function verifyEvents() {
// Invoke events.
$this->doUser();
$this->drupalCreateContentType(['type' => 'article', 'name' => t('Article')]);
$this->drupalCreateContentType(['type' => 'page', 'name' => t('Basic page')]);
$this->doNode('article');
$this->doNode('page');
$this->doNode('forum');
// When a user account is canceled, any content they created remains but the
// uid = 0. Records in the watchdog table related to that user have the uid
// set to zero.
}
/**
* Verifies the sorting functionality of the database logging reports table.
*
* @param string $sort
* The sort direction.
* @param string $order
* The order by which the table should be sorted.
*/
public function verifySort($sort = 'asc', $order = 'Date') {
$this->drupalGet('admin/reports/dblog', ['query' => ['sort' => $sort, 'order' => $order]]);
$this->assertResponse(200);
$this->assertText(t('Recent log messages'), 'DBLog report was displayed correctly and sorting went fine.');
}
/**
* Tests the escaping of links in the operation row of a database log detail
* page.
*/
private function verifyLinkEscaping() {
$link = \Drupal::l('View', Url::fromRoute('entity.node.canonical', ['node' => 1]));
$message = 'Log entry added to do the verifyLinkEscaping test.';
$this->generateLogEntries(1, [
'message' => $message,
'link' => $link,
]);
$result = db_query_range('SELECT wid FROM {watchdog} ORDER BY wid DESC', 0, 1);
$this->drupalGet('admin/reports/dblog/event/' . $result->fetchField());
// Check if the link exists (unescaped).
$this->assertRaw($link);
}
/**
* Generates and then verifies some user events.
*/
private function doUser() {
// Set user variables.
$name = $this->randomMachineName();
$pass = user_password();
// Add a user using the form to generate an add user event (which is not
// triggered by drupalCreateUser).
$edit = [];
$edit['name'] = $name;
$edit['mail'] = $name . '@example.com';
$edit['pass[pass1]'] = $pass;
$edit['pass[pass2]'] = $pass;
$edit['status'] = 1;
$this->drupalPostForm('admin/people/create', $edit, t('Create new account'));
$this->assertResponse(200);
// Retrieve the user object.
$user = user_load_by_name($name);
$this->assertTrue($user != NULL, format_string('User @name was loaded', ['@name' => $name]));
// pass_raw property is needed by drupalLogin.
$user->passRaw = $pass;
// Log in user.
$this->drupalLogin($user);
// Log out user.
$this->drupalLogout();
// Fetch the row IDs in watchdog that relate to the user.
$result = db_query('SELECT wid FROM {watchdog} WHERE uid = :uid', [':uid' => $user->id()]);
foreach ($result as $row) {
$ids[] = $row->wid;
}
$count_before = (isset($ids)) ? count($ids) : 0;
$this->assertTrue($count_before > 0, format_string('DBLog contains @count records for @name', ['@count' => $count_before, '@name' => $user->getUsername()]));
// Log in the admin user.
$this->drupalLogin($this->adminUser);
// Delete the user created at the start of this test.
// We need to POST here to invoke batch_process() in the internal browser.
$this->drupalPostForm('user/' . $user->id() . '/cancel', ['user_cancel_method' => 'user_cancel_reassign'], t('Cancel account'));
// View the database log report.
$this->drupalGet('admin/reports/dblog');
$this->assertResponse(200);
// Verify that the expected events were recorded.
// Add user.
// Default display includes name and email address; if too long, the email
// address is replaced by three periods.
$this->assertLogMessage(t('New user: %name %email.', ['%name' => $name, '%email' => '<' . $user->getEmail() . '>']), 'DBLog event was recorded: [add user]');
// Log in user.
$this->assertLogMessage(t('Session opened for %name.', ['%name' => $name]), 'DBLog event was recorded: [login user]');
// Log out user.
$this->assertLogMessage(t('Session closed for %name.', ['%name' => $name]), 'DBLog event was recorded: [logout user]');
// Delete user.
$message = t('Deleted user: %name %email.', ['%name' => $name, '%email' => '<' . $user->getEmail() . '>']);
$message_text = Unicode::truncate(Html::decodeEntities(strip_tags($message)), 56, TRUE, TRUE);
// Verify that the full message displays on the details page.
$link = FALSE;
if ($links = $this->xpath('//a[text()="' . $message_text . '"]')) {
// Found link with the message text.
$links = array_shift($links);
$value = $links->getAttribute('href');
// Extract link to details page.
$link = mb_substr($value, strpos($value, 'admin/reports/dblog/event/'));
$this->drupalGet($link);
// Check for full message text on the details page.
$this->assertRaw($message, 'DBLog event details was found: [delete user]');
}
$this->assertTrue($link, 'DBLog event was recorded: [delete user]');
// Visit random URL (to generate page not found event).
$not_found_url = $this->randomMachineName(60);
$this->drupalGet($not_found_url);
$this->assertResponse(404);
// View the database log page-not-found report page.
$this->drupalGet('admin/reports/page-not-found');
$this->assertResponse(200);
// Check that full-length URL displayed.
$this->assertText($not_found_url, 'DBLog event was recorded: [page not found]');
}
/**
* Generates and then verifies some node events.
*
* @param string $type
* A node type (e.g., 'article', 'page' or 'forum').
*/
private function doNode($type) {
// Create user.
$perm = ['create ' . $type . ' content', 'edit own ' . $type . ' content', 'delete own ' . $type . ' content'];
$user = $this->drupalCreateUser($perm);
// Log in user.
$this->drupalLogin($user);
// Create a node using the form in order to generate an add content event
// (which is not triggered by drupalCreateNode).
$edit = $this->getContent($type);
$title = $edit['title[0][value]'];
$this->drupalPostForm('node/add/' . $type, $edit, t('Save'));
$this->assertResponse(200);
// Retrieve the node object.
$node = $this->drupalGetNodeByTitle($title);
$this->assertTrue($node != NULL, format_string('Node @title was loaded', ['@title' => $title]));
// Edit the node.
$edit = $this->getContentUpdate($type);
$this->drupalPostForm('node/' . $node->id() . '/edit', $edit, t('Save'));
$this->assertResponse(200);
// Delete the node.
$this->drupalPostForm('node/' . $node->id() . '/delete', [], t('Delete'));
$this->assertResponse(200);
// View the node (to generate page not found event).
$this->drupalGet('node/' . $node->id());
$this->assertResponse(404);
// View the database log report (to generate access denied event).
$this->drupalGet('admin/reports/dblog');
$this->assertResponse(403);
// Log in the admin user.
$this->drupalLogin($this->adminUser);
// View the database log report.
$this->drupalGet('admin/reports/dblog');
$this->assertResponse(200);
// Verify that node events were recorded.
// Was node content added?
$this->assertLogMessage(t('@type: added %title.', ['@type' => $type, '%title' => $title]), 'DBLog event was recorded: [content added]');
// Was node content updated?
$this->assertLogMessage(t('@type: updated %title.', ['@type' => $type, '%title' => $title]), 'DBLog event was recorded: [content updated]');
// Was node content deleted?
$this->assertLogMessage(t('@type: deleted %title.', ['@type' => $type, '%title' => $title]), 'DBLog event was recorded: [content deleted]');
// View the database log access-denied report page.
$this->drupalGet('admin/reports/access-denied');
$this->assertResponse(200);
// Verify that the 'access denied' event was recorded.
$this->assertText('admin/reports/dblog', 'DBLog event was recorded: [access denied]');
// View the database log page-not-found report page.
$this->drupalGet('admin/reports/page-not-found');
$this->assertResponse(200);
// Verify that the 'page not found' event was recorded.
$this->assertText('node/' . $node->id(), 'DBLog event was recorded: [page not found]');
}
/**
* Creates random content based on node content type.
*
* @param string $type
* Node content type (e.g., 'article').
*
* @return array
* Random content needed by various node types.
*/
private function getContent($type) {
switch ($type) {
case 'forum':
$content = [
'title[0][value]' => $this->randomMachineName(8),
'taxonomy_forums' => 1,
'body[0][value]' => $this->randomMachineName(32),
];
break;
default:
$content = [
'title[0][value]' => $this->randomMachineName(8),
'body[0][value]' => $this->randomMachineName(32),
];
break;
}
return $content;
}
/**
* Creates random content as an update based on node content type.
*
* @param string $type
* Node content type (e.g., 'article').
*
* @return array
* Random content needed by various node types.
*/
private function getContentUpdate($type) {
$content = [
'body[0][value]' => $this->randomMachineName(32),
];
return $content;
}
/**
* Tests the addition and clearing of log events through the admin interface.
*
* Logs in the admin user, creates a database log event, and tests the
* functionality of clearing the database log through the admin interface.
*/
public function testDBLogAddAndClear() {
global $base_root;
// Get a count of how many watchdog entries already exist.
$count = db_query('SELECT COUNT(*) FROM {watchdog}')->fetchField();
$log = [
'channel' => 'system',
'message' => 'Log entry added to test the doClearTest clear down.',
'variables' => [],
'severity' => RfcLogLevel::NOTICE,
'link' => NULL,
'user' => $this->adminUser,
'uid' => $this->adminUser->id(),
'request_uri' => $base_root . \Drupal::request()->getRequestUri(),
'referer' => \Drupal::request()->server->get('HTTP_REFERER'),
'ip' => '127.0.0.1',
'timestamp' => REQUEST_TIME,
];
// Add a watchdog entry.
$this->container->get('logger.dblog')->log($log['severity'], $log['message'], $log);
// Make sure the table count has actually been incremented.
$this->assertEqual($count + 1, db_query('SELECT COUNT(*) FROM {watchdog}')->fetchField(), format_string('\Drupal\dblog\Logger\DbLog->log() added an entry to the dblog :count', [':count' => $count]));
// Log in the admin user.
$this->drupalLogin($this->adminUser);
// Post in order to clear the database table.
$this->clearLogsEntries();
// Confirm that the logs should be cleared.
$this->drupalPostForm(NULL, [], 'Confirm');
// Count the rows in watchdog that previously related to the deleted user.
$count = db_query('SELECT COUNT(*) FROM {watchdog}')->fetchField();
$this->assertEqual($count, 0, format_string('DBLog contains :count records after a clear.', [':count' => $count]));
}
/**
* Tests the database log filter functionality at admin/reports/dblog.
*/
public function testFilter() {
$this->drupalLogin($this->adminUser);
// Clear the log to ensure that only generated entries will be found.
db_delete('watchdog')->execute();
// Generate 9 random watchdog entries.
$type_names = [];
$types = [];
for ($i = 0; $i < 3; $i++) {
$type_names[] = $type_name = $this->randomMachineName();
$severity = RfcLogLevel::EMERGENCY;
for ($j = 0; $j < 3; $j++) {
$types[] = $type = [
'count' => $j + 1,
'type' => $type_name,
'severity' => $severity++,
];
$this->generateLogEntries($type['count'], [
'channel' => $type['type'],
'severity' => $type['severity'],
]);
}
}
// View the database log page.
$this->drupalGet('admin/reports/dblog');
// Confirm that all the entries are displayed.
$count = $this->getTypeCount($types);
foreach ($types as $key => $type) {
$this->assertEqual($count[$key], $type['count'], 'Count matched');
}
// Filter by each type and confirm that entries with various severities are
// displayed.
foreach ($type_names as $type_name) {
$this->filterLogsEntries($type_name);
// Count the number of entries of this type.
$type_count = 0;
foreach ($types as $type) {
if ($type['type'] == $type_name) {
$type_count += $type['count'];
}
}
$count = $this->getTypeCount($types);
$this->assertEqual(array_sum($count), $type_count, 'Count matched');
}
// Set the filter to match each of the two filter-type attributes and
// confirm the correct number of entries are displayed.
foreach ($types as $type) {
$this->filterLogsEntries($type['type'], $type['severity']);
$count = $this->getTypeCount($types);
$this->assertEqual(array_sum($count), $type['count'], 'Count matched');
}
$this->drupalGet('admin/reports/dblog', ['query' => ['order' => 'Type']]);
$this->assertResponse(200);
$this->assertText(t('Operations'), 'Operations text found');
// Clear all logs and make sure the confirmation message is found.
$this->clearLogsEntries();
// Confirm that the logs should be cleared.
$this->drupalPostForm(NULL, [], 'Confirm');
$this->assertText(t('Database log cleared.'), 'Confirmation message found');
}
/**
* Gets the database log event information from the browser page.
*
* @return array
* List of log events where each event is an array with following keys:
* - severity: (int) A database log severity constant.
* - type: (string) The type of database log event.
* - message: (string) The message for this database log event.
* - user: (string) The user associated with this database log event.
*/
protected function getLogEntries() {
$entries = [];
if ($table = $this->getLogsEntriesTable()) {
foreach ($table as $row) {
$cells = $row->findAll('css', 'td');
$entries[] = [
'severity' => $this->getSeverityConstant($row->getAttribute('class')),
'type' => $cells[1]->getText(),
'message' => $cells[3]->getText(),
'user' => $cells[4]->getText(),
];
}
}
return $entries;
}
/**
* Find the Logs table in the DOM.
*
* @return \SimpleXMLElement[]
* The return value of a xpath search.
*/
protected function getLogsEntriesTable() {
return $this->xpath('.//table[@id="admin-dblog"]/tbody/tr');
}
/**
* Gets the count of database log entries by database log event type.
*
* @param array $types
* The type information to compare against.
*
* @return array
* The count of each type keyed by the key of the $types array.
*/
protected function getTypeCount(array $types) {
$entries = $this->getLogEntries();
$count = array_fill(0, count($types), 0);
foreach ($entries as $entry) {
foreach ($types as $key => $type) {
if ($entry['type'] == $type['type'] && $entry['severity'] == $type['severity']) {
$count[$key]++;
break;
}
}
}
return $count;
}
/**
* Gets the watchdog severity constant corresponding to the CSS class.
*
* @param string $class
* CSS class attribute.
*
* @return int|null
* The watchdog severity constant or NULL if not found.
*/
protected function getSeverityConstant($class) {
$map = array_flip(DbLogController::getLogLevelClassMap());
// Find the class that contains the severity.
$classes = explode(' ', $class);
foreach ($classes as $class) {
if (isset($map[$class])) {
return $map[$class];
}
}
return NULL;
}
/**
* Confirms that a log message appears on the database log overview screen.
*
* This function should only be used for the admin/reports/dblog page, because
* it checks for the message link text truncated to 56 characters. Other log
* pages have no detail links so they contain the full message text.
*
* @param string $log_message
* The database log message to check.
* @param string $message
* The message to pass to simpletest.
*/
protected function assertLogMessage($log_message, $message) {
$message_text = Unicode::truncate(Html::decodeEntities(strip_tags($log_message)), 56, TRUE, TRUE);
$this->assertLink($message_text, 0, $message);
}
/**
* Tests that the details page displays correctly for a temporary user.
*/
public function testTemporaryUser() {
// Create a temporary user.
$tempuser = $this->drupalCreateUser();
$tempuser_uid = $tempuser->id();
// Log in as the admin user.
$this->drupalLogin($this->adminUser);
// Generate a single watchdog entry.
$this->generateLogEntries(1, ['user' => $tempuser, 'uid' => $tempuser_uid]);
$wid = db_query('SELECT MAX(wid) FROM {watchdog}')->fetchField();
// Check if the full message displays on the details page.
$this->drupalGet('admin/reports/dblog/event/' . $wid);
$this->assertText('Dblog test log message');
// Delete the user.
user_delete($tempuser->id());
$this->drupalGet('user/' . $tempuser_uid);
$this->assertResponse(404);
// Check if the full message displays on the details page.
$this->drupalGet('admin/reports/dblog/event/' . $wid);
$this->assertText('Dblog test log message');
}
/**
* Make sure HTML tags are filtered out in the log overview links.
*/
public function testOverviewLinks() {
$this->drupalLogin($this->adminUser);
$this->generateLogEntries(1, ['message' => "&lt;script&gt;alert('foo');&lt;/script&gt;<strong>Lorem</strong> ipsum dolor sit amet, consectetur adipiscing & elit."]);
$this->drupalGet('admin/reports/dblog');
$this->assertResponse(200);
// Make sure HTML tags are filtered out.
$this->assertRaw('title="alert(&#039;foo&#039;);Lorem');
$this->assertNoRaw("<script>alert('foo');</script>");
// Make sure HTML tags are filtered out in admin/reports/dblog/event/ too.
$this->generateLogEntries(1, ['message' => "<script>alert('foo');</script> <strong>Lorem ipsum</strong>"]);
$wid = db_query('SELECT MAX(wid) FROM {watchdog}')->fetchField();
$this->drupalGet('admin/reports/dblog/event/' . $wid);
$this->assertNoRaw("<script>alert('foo');</script>");
$this->assertRaw("alert('foo'); <strong>Lorem ipsum</strong>");
}
/**
* Test sorting for entries with the same timestamp.
*/
public function testSameTimestampEntries() {
$this->drupalLogin($this->adminUser);
$this->generateLogEntries(1, ['timestamp' => 1498062000, 'type' => 'same_time', 'message' => 'First']);
$this->generateLogEntries(1, ['timestamp' => 1498062000, 'type' => 'same_time', 'message' => 'Second']);
$this->generateLogEntries(1, ['timestamp' => 1498062000, 'type' => 'same_time', 'message' => 'Third']);
$this->drupalGet('admin/reports/dblog');
$entries = $this->getLogEntries();
$this->assertEquals($entries[0]['message'], 'Third Entry #0');
$this->assertEquals($entries[1]['message'], 'Second Entry #0');
$this->assertEquals($entries[2]['message'], 'First Entry #0');
}
}

59
web/core/modules/dblog/tests/src/Functional/DbLogViewsTest.php Normal file
View file

@ -0,0 +1,59 @@
<?php
namespace Drupal\Tests\dblog\Functional;
use Drupal\views\Views;
/**
* Generate events and verify dblog entries; verify user access to log reports
* based on permissions. Using the dblog UI generated by a View.
*
* @see Drupal\dblog\Tests\DbLogTest
*
* @group dblog
*/
class DbLogViewsTest extends DbLogTest {
/**
* Modules to enable.
*
* @var array
*/
public static $modules = ['dblog', 'node', 'forum', 'help', 'block', 'views'];
/**
* {@inheritdoc}
*/
protected function getLogsEntriesTable() {
return $this->xpath('.//table[contains(@class, "views-view-table")]/tbody/tr');
}
/**
* {@inheritdoc}
*/
protected function filterLogsEntries($type = NULL, $severity = NULL) {
$query = [];
if (isset($type)) {
$query['type[]'] = $type;
}
if (isset($severity)) {
$query['severity[]'] = $severity;
}
$this->drupalGet('admin/reports/dblog', ['query' => $query]);
}
/**
* Tests the empty text for the watchdog view is not using an input format.
*/
public function testEmptyText() {
$view = Views::getView('watchdog');
$data = $view->storage->toArray();
$area = $data['display']['default']['display_options']['empty']['area'];
$this->assertEqual('text_custom', $area['plugin_id']);
$this->assertEqual('area_text_custom', $area['field']);
$this->assertEqual('No log messages available.', $area['content']);
}
}

66
web/core/modules/dblog/tests/src/Functional/FakeLogEntries.php Normal file
View file

@ -0,0 +1,66 @@
<?php
namespace Drupal\Tests\dblog\Functional;
use Drupal\Core\Logger\RfcLogLevel;
use Drupal\Core\Session\AnonymousUserSession;
/**
* Provides methods to generate log entries.
*
* This trait is meant to be used only by test classes.
*/
trait FakeLogEntries {
/**
* Generates a number of random database log events.
*
* @param int $count
* Number of watchdog entries to generate.
* @param array $options
* These options are used to override the defaults for the test.
* An associative array containing any of the following keys:
* - 'channel': String identifying the log channel to be output to.
* If the channel is not set, the default of 'custom' will be used.
* - 'message': String containing a message to be output to the log.
* A simple default message is used if not provided.
* - 'variables': Array of variables that match the message string.
* - 'severity': Log severity level as defined in logging_severity_levels.
* - 'link': String linking to view the result of the event.
* - 'user': String identifying the username.
* - 'uid': Int identifying the user id for the user.
* - 'request_uri': String identifying the location of the request.
* - 'referer': String identifying the referring url.
* - 'ip': String The ip address of the client machine triggering the log
* entry.
* - 'timestamp': Int unix timestamp.
*/
private function generateLogEntries($count, $options = []) {
global $base_root;
$user = !empty($this->adminUser) ? $this->adminUser : new AnonymousUserSession();
// Prepare the fields to be logged.
$log = $options + [
'channel' => 'custom',
'message' => 'Dblog test log message',
'variables' => [],
'severity' => RfcLogLevel::NOTICE,
'link' => NULL,
'user' => $user,
'uid' => $user->id(),
'request_uri' => $base_root . \Drupal::request()->getRequestUri(),
'referer' => \Drupal::request()->server->get('HTTP_REFERER'),
'ip' => '127.0.0.1',
'timestamp' => REQUEST_TIME,
];
$logger = $this->container->get('logger.dblog');
$message = $log['message'] . ' Entry #';
for ($i = 0; $i < $count; $i++) {
$log['message'] = $message . $i;
$logger->log($log['severity'], $log['message'], $log);
}
}
}

78
web/core/modules/dblog/tests/src/Functional/Update/DblogFiltersAndFieldsUpgradeTest.php Normal file
View file

@ -0,0 +1,78 @@
<?php
namespace Drupal\Tests\dblog\Functional\Update;
use Drupal\FunctionalTests\Update\UpdatePathTestBase;
use Drupal\views\Views;
use Drupal\Core\Serialization\Yaml;
/**
* Tests the upgrade path for views field and filter handlers.
*
* @see dblog_update_8400()
*
* @group Update
* @group legacy
*/
class DblogFiltersAndFieldsUpgradeTest extends UpdatePathTestBase {
/**
* {@inheritdoc}
*/
protected function setDatabaseDumpFiles() {
$this->databaseDumpFiles = [
__DIR__ . '/../../../../../system/tests/fixtures/update/drupal-8.bare.standard.php.gz',
__DIR__ . '/../../../fixtures/update/dblog-2851293.php',
];
}
/**
* Tests that field and filter handlers are updated properly.
*/
public function testDblogUpgradePath() {
$this->runUpdates();
$view = Views::getView('dblog_2851293');
$data = $view->storage->toArray();
$fields = $data['display']['default']['display_options']['fields'];
// The 'wid' and 'uid' fields should use the standard plugin now.
$this->assertEqual('standard', $fields['wid']['plugin_id']);
$this->assertEqual('standard', $fields['uid']['plugin_id']);
$filters = $data['display']['default']['display_options']['filters'];
// The 'type' filter should use the dblog_types plugin now.
$this->assertEqual('dblog_types', $filters['type']['plugin_id']);
// Now that the view had been converted, try the same approach but using
// dblog_view_presave()
$config_factory = \Drupal::configFactory();
$config_view = $config_factory->getEditable('views.view.dblog_2851293');
$config_view->setData(Yaml::decode(file_get_contents('core/modules/dblog/tests/modules/dblog_test_views/test_views/views.view.dblog_2851293.yml')));
$config_view->save();
// Make sure we have a not upgraded view.
$view = Views::getView('dblog_2851293');
$data = $view->storage->toArray();
$fields = $data['display']['default']['display_options']['fields'];
$filters = $data['display']['default']['display_options']['filters'];
$this->assertEqual('numeric', $fields['wid']['plugin_id']);
$this->assertEqual('numeric', $fields['uid']['plugin_id']);
$this->assertEqual('in_operator', $filters['type']['plugin_id']);
// Now save the view. This trigger dblog_view_presave().
$view->save();
// Finally check the same conversion process ran.
$data = $view->storage->toArray();
$fields = $data['display']['default']['display_options']['fields'];
$filters = $data['display']['default']['display_options']['filters'];
$this->assertEqual('standard', $fields['wid']['plugin_id']);
$this->assertEqual('standard', $fields['uid']['plugin_id']);
$this->assertEqual('dblog_types', $filters['type']['plugin_id']);
}
}

43
web/core/modules/dblog/tests/src/Functional/Update/DblogNoLogsAvailableUpgradeTest.php Normal file
View file

@ -0,0 +1,43 @@
<?php
namespace Drupal\Tests\dblog\Functional\Update;
use Drupal\FunctionalTests\Update\UpdatePathTestBase;
use Drupal\views\Views;
/**
* Test the upgrade path of changing the empty text area for watchdog view.
*
* @see dblog_update_8600()
*
* @group Update
* @group legacy
*/
class DblogNoLogsAvailableUpgradeTest extends UpdatePathTestBase {
/**
* {@inheritdoc}
*/
protected function setDatabaseDumpFiles() {
$this->databaseDumpFiles = [
__DIR__ . '/../../../../../system/tests/fixtures/update/drupal-8.4.0.bare.standard.php.gz',
];
}
/**
* Tests that no logs available text is now using a custom area.
*/
public function testDblogUpgradePath() {
$this->runUpdates();
$view = Views::getView('watchdog');
$data = $view->storage->toArray();
$area = $data['display']['default']['display_options']['empty']['area'];
$this->assertEqual('text_custom', $area['plugin_id']);
$this->assertEqual('area_text_custom', $area['field']);
$this->assertEqual('No log messages available.', $area['content']);
}
}

41
web/core/modules/dblog/tests/src/Functional/Update/DblogRecentLogsUsingViewsUpdateTest.php Normal file
View file

@ -0,0 +1,41 @@
<?php
namespace Drupal\Tests\dblog\Functional\Update;
use Drupal\FunctionalTests\Update\UpdatePathTestBase;
/**
* Ensures that update hook that creates the watchdog view ran successfully.
*
* @group Update
* @group legacy
*/
class DblogRecentLogsUsingViewsUpdateTest extends UpdatePathTestBase {
/**
* {@inheritdoc}
*/
protected function setDatabaseDumpFiles() {
$this->databaseDumpFiles = [
__DIR__ . '/../../../../../system/tests/fixtures/update/drupal-8.bare.standard.php.gz',
];
}
/**
* Ensures that update hook is run for dblog module.
*/
public function testUpdate() {
// Make sure the watchdog view doesn't exist before the updates.
$view = \Drupal::entityTypeManager()->getStorage('view')->load('watchdog');
$this->assertNull($view);
$this->runUpdates();
// Ensure the watchdog view is present after run updates.
$view = \Drupal::entityTypeManager()->getStorage('view')->load('watchdog');
$displays = $view->get('display');
$this->assertIdentical($displays['page']['display_options']['path'], 'admin/reports/dblog', 'Recent logs message view exists.');
}
}

40
web/core/modules/dblog/tests/src/Kernel/DbLogControllerTest.php
View file

@ -17,11 +17,49 @@ class DbLogControllerTest extends KernelTestBase {
*/
public static $modules = ['dblog', 'user'];
public function setUp() {
parent::setUp();
$this->installEntitySchema('user');
$this->installSchema('dblog', ['watchdog']);
}
/**
* Tests links with non latin characters.
*/
public function testNonLatinCharacters() {
$link = 'hello-
科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰';
\Drupal::logger('my_module')->warning('test', ['link' => $link]);
$log = \Drupal::database()
->select('watchdog', 'w')
->fields('w', ['link'])
->condition('link', '', '<>')
->execute()
->fetchField();
$this->assertEquals($log, $link);
}
/**
* Tests corrupted log entries can still display available data.
*/
public function testDbLogCorrupted() {
$this->installEntitySchema('user');
$dblog_controller = DbLogController::create($this->container);
// Check message with properly serialized data.

1
web/core/modules/dblog/tests/src/Kernel/DbLogFormInjectionTest.php
View file

@ -2,7 +2,6 @@
namespace Drupal\Tests\dblog\Kernel;
use Drupal\Core\DependencyInjection\DependencySerializationTrait;
use Drupal\Core\Form\FormInterface;
use Drupal\Core\Form\FormState;

77
web/core/modules/dblog/tests/src/Kernel/DbLogTest.php Normal file
View file

@ -0,0 +1,77 @@
<?php
namespace Drupal\Tests\dblog\Kernel;
use Drupal\KernelTests\KernelTestBase;
use Drupal\Tests\dblog\Functional\FakeLogEntries;
/**
* Generate events and verify dblog entries.
*
* @group dblog
*/
class DbLogTest extends KernelTestBase {
use FakeLogEntries;
/**
* {@inheritdoc}
*/
protected static $modules = ['dblog', 'system'];
/**
* {@inheritdoc}
*/
protected function setUp() {
parent::setUp();
$this->installSchema('dblog', ['watchdog']);
$this->installSchema('system', ['key_value_expire', 'sequences']);
$this->installConfig(['system']);
}
/**
* Tests that cron correctly applies the database log row limit.
*/
public function testDbLogCron() {
$row_limit = 100;
// Generate additional log entries.
$this->generateLogEntries($row_limit + 10);
// Verify that the database log row count exceeds the row limit.
$count = db_query('SELECT COUNT(wid) FROM {watchdog}')->fetchField();
$this->assertGreaterThan($row_limit, $count, format_string('Dblog row count of @count exceeds row limit of @limit', ['@count' => $count, '@limit' => $row_limit]));
// Get the number of enabled modules. Cron adds a log entry for each module.
$list = $this->container->get('module_handler')->getImplementations('cron');
$module_count = count($list);
$cron_detailed_count = $this->runCron();
$this->assertEquals($module_count + 2, $cron_detailed_count, format_string('Cron added @count of @expected new log entries', ['@count' => $cron_detailed_count, '@expected' => $module_count + 2]));
// Test disabling of detailed cron logging.
$this->config('system.cron')->set('logging', 0)->save();
$cron_count = $this->runCron();
$this->assertEquals(1, $cron_count, format_string('Cron added @count of @expected new log entries', ['@count' => $cron_count, '@expected' => 1]));
}
/**
* Runs cron and returns number of new log entries.
*
* @return int
* Number of new watchdog entries.
*/
private function runCron() {
// Get last ID to compare against; log entries get deleted, so we can't
// reliably add the number of newly created log entries to the current count
// to measure number of log entries created by cron.
$last_id = db_query('SELECT MAX(wid) FROM {watchdog}')->fetchField();
// Run a cron job.
$this->container->get('cron')->run();
// Get last ID after cron was run.
$current_id = db_query('SELECT MAX(wid) FROM {watchdog}')->fetchField();
return $current_id - $last_id;
}
}

187
web/core/modules/dblog/tests/src/Kernel/Views/ViewsIntegrationTest.php
View file

@ -2,7 +2,7 @@
namespace Drupal\Tests\dblog\Kernel\Views;
use Drupal\Component\Utility\SafeMarkup;
use Drupal\Component\Render\FormattableMarkup;
use Drupal\Component\Utility\Xss;
use Drupal\Core\Logger\RfcLogLevel;
use Drupal\Core\Url;
@ -18,41 +18,161 @@ use Drupal\views\Tests\ViewTestData;
class ViewsIntegrationTest extends ViewsKernelTestBase {
/**
* Views used by this test.
*
* @var array
* {@inheritdoc}
*/
public static $testViews = ['test_dblog'];
public static $testViews = ['test_dblog', 'dblog_integration_test'];
/**
* Modules to enable.
*
* @var array
* {@inheritdoc}
*/
public static $modules = ['dblog', 'dblog_test_views', 'user'];
/**
* {@inheritdoc}
*/
protected $columnMap = ['watchdog_message' => 'message'];
/**
* {@inheritdoc}
*/
protected function setUp($import_test_views = TRUE) {
parent::setUp();
// Rebuild the router, otherwise we can't generate links.
$this->container->get('router.builder')->rebuild();
$this->installEntitySchema('user');
$this->installSchema('dblog', ['watchdog']);
ViewTestData::createTestViews(get_class($this), ['dblog_test_views']);
}
/**
* Tests the integration.
* Tests the messages escaping functionality.
*/
public function testIntegration() {
public function testMessages() {
// Remove the watchdog entries added by the potential batch process.
$this->container->get('database')->truncate('watchdog')->execute();
$entries = $this->createLogEntries();
$view = Views::getView('test_dblog');
$this->executeView($view);
$view->initStyle();
foreach ($entries as $index => $entry) {
if (!isset($entry['variables'])) {
continue;
}
$this->assertEqual($view->style_plugin->getField($index, 'message'), new FormattableMarkup($entry['message'], $entry['variables']));
$link_field = $view->style_plugin->getField($index, 'link');
// The 3rd entry contains some unsafe markup that needs to get filtered.
if ($index == 2) {
// Make sure that unsafe link differs from the rendered link, so we know
// that some filtering actually happened.
$this->assertNotEqual($link_field, $entry['variables']['link']);
}
$this->assertEqual($link_field, Xss::filterAdmin($entry['variables']['link']));
}
// Disable replacing variables and check that the tokens aren't replaced.
$view->destroy();
$view->storage->invalidateCaches();
$view->initHandlers();
$this->executeView($view);
$view->initStyle();
$view->field['message']->options['replace_variables'] = FALSE;
foreach ($entries as $index => $entry) {
$this->assertEqual($view->style_plugin->getField($index, 'message'), $entry['message']);
}
}
/**
* Tests the relationship with the users_field_data table.
*/
public function testRelationship() {
$view = Views::getView('dblog_integration_test');
$view->setDisplay('page_1');
// The uid relationship should now join to the {users_field_data} table.
$tables = array_keys($view->getBaseTables());
$this->assertTrue(in_array('users_field_data', $tables));
$this->assertFalse(in_array('users', $tables));
$this->assertTrue(in_array('watchdog', $tables));
}
/**
* Test views can be filtered by severity and log type.
*/
public function testFiltering() {
// Remove the watchdog entries added by the potential batch process.
$this->container->get('database')->truncate('watchdog')->execute();
$this->createLogEntries();
$view = Views::getView('dblog_integration_test');
$filters = [
'severity' => [
'id' => 'severity',
'table' => 'watchdog',
'field' => 'severity',
'relationship' => 'none',
'group_type' => 'group',
'admin_label' => '',
'operator' => 'in',
'value' => [
RfcLogLevel::WARNING,
],
'group' => 1,
'exposed' => FALSE,
'plugin_id' => 'in_operator',
],
];
$view->setDisplay('page_1');
$view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
$view->save();
$this->executeView($view);
$resultset = [['message' => 'Warning message']];
$this->assertIdenticalResultset($view, $resultset, $this->columnMap);
$view = Views::getView('dblog_integration_test');
$filters = [
'type' => [
'id' => 'type',
'table' => 'watchdog',
'field' => 'type',
'relationship' => 'none',
'group_type' => 'group',
'admin_label' => '',
'operator' => 'in',
'value' => [
'my-module' => 'my-module',
],
'group' => '1',
'exposed' => FALSE,
'is_grouped' => FALSE,
'plugin_id' => 'dblog_types',
],
];
$view->setDisplay('page_1');
$view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
$view->save();
$this->executeView($view);
$resultset = [['message' => 'My module message']];
$this->assertIdenticalResultset($view, $resultset, $this->columnMap);
}
/**
* Create a set of log entries.
*
* @return array
* An array of data used to create the log entries.
*/
protected function createLogEntries() {
$entries = [];
// Setup a watchdog entry without tokens.
$entries[] = [
@ -76,41 +196,28 @@ class ViewsIntegrationTest extends ViewsKernelTestBase {
'link' => '<a href="' . \Drupal::url('<front>') . '"><object>Link</object></a>',
],
];
// Setup a watchdog entry with severity WARNING.
$entries[] = [
'message' => 'Warning message',
'severity' => RfcLogLevel::WARNING,
];
// Setup a watchdog entry with a different module.
$entries[] = [
'message' => 'My module message',
'severity' => RfcLogLevel::INFO,
'type' => 'my-module',
];
$logger_factory = $this->container->get('logger.factory');
foreach ($entries as $entry) {
$entry += [
'type' => 'test-views',
'severity' => RfcLogLevel::NOTICE,
'variables' => [],
];
$logger_factory->get($entry['type'])->log($entry['severity'], $entry['message'], $entry['variables']);
}
$view = Views::getView('test_dblog');
$this->executeView($view);
$view->initStyle();
foreach ($entries as $index => $entry) {
$this->assertEqual($view->style_plugin->getField($index, 'message'), SafeMarkup::format($entry['message'], $entry['variables']));
$link_field = $view->style_plugin->getField($index, 'link');
// The 3rd entry contains some unsafe markup that needs to get filtered.
if ($index == 2) {
// Make sure that unsafe link differs from the rendered link, so we know
// that some filtering actually happened.
$this->assertNotEqual($link_field, $entry['variables']['link']);
}
$this->assertEqual($link_field, Xss::filterAdmin($entry['variables']['link']));
}
// Disable replacing variables and check that the tokens aren't replaced.
$view->destroy();
$view->storage->invalidateCaches();
$view->initHandlers();
$this->executeView($view);
$view->initStyle();
$view->field['message']->options['replace_variables'] = FALSE;
foreach ($entries as $index => $entry) {
$this->assertEqual($view->style_plugin->getField($index, 'message'), $entry['message']);
}
return $entries;
}
}