MergeTest.php in Drupal 8

Namespace

Drupal\KernelTests\Core\Database

File

core/tests/Drupal/KernelTests/Core/Database/MergeTest.php

<?php

namespace Drupal\KernelTests\Core\Database;

use Drupal\Core\Database\Query\Merge;
use Drupal\Core\Database\Query\InvalidMergeQueryException;

/**
 * Tests the MERGE query builder.
 *
 * @group Database
 */
class MergeTest extends DatabaseTestBase {

  /**
   * Confirms that we can merge-insert a record successfully.
   */
  public function testMergeInsert() {
    $num_records_before = $this->connection
      ->query('SELECT COUNT(*) FROM {test_people}')
      ->fetchField();
    $result = $this->connection
      ->merge('test_people')
      ->key('job', 'Presenter')
      ->fields([
      'age' => 31,
      'name' => 'Tiffany',
    ])
      ->execute();
    $this
      ->assertEqual($result, Merge::STATUS_INSERT, 'Insert status returned.');
    $num_records_after = $this->connection
      ->query('SELECT COUNT(*) FROM {test_people}')
      ->fetchField();
    $this
      ->assertEqual($num_records_before + 1, $num_records_after, 'Merge inserted properly.');
    $person = $this->connection
      ->query('SELECT * FROM {test_people} WHERE job = :job', [
      ':job' => 'Presenter',
    ])
      ->fetch();
    $this
      ->assertEqual($person->name, 'Tiffany', 'Name set correctly.');
    $this
      ->assertEqual($person->age, 31, 'Age set correctly.');
    $this
      ->assertEqual($person->job, 'Presenter', 'Job set correctly.');
  }

  /**
   * Confirms that we can merge-update a record successfully.
   */
  public function testMergeUpdate() {
    $num_records_before = $this->connection
      ->query('SELECT COUNT(*) FROM {test_people}')
      ->fetchField();
    $result = $this->connection
      ->merge('test_people')
      ->key('job', 'Speaker')
      ->fields([
      'age' => 31,
      'name' => 'Tiffany',
    ])
      ->execute();
    $this
      ->assertEqual($result, Merge::STATUS_UPDATE, 'Update status returned.');
    $num_records_after = $this->connection
      ->query('SELECT COUNT(*) FROM {test_people}')
      ->fetchField();
    $this
      ->assertEqual($num_records_before, $num_records_after, 'Merge updated properly.');
    $person = $this->connection
      ->query('SELECT * FROM {test_people} WHERE job = :job', [
      ':job' => 'Speaker',
    ])
      ->fetch();
    $this
      ->assertEqual($person->name, 'Tiffany', 'Name set correctly.');
    $this
      ->assertEqual($person->age, 31, 'Age set correctly.');
    $this
      ->assertEqual($person->job, 'Speaker', 'Job set correctly.');
  }

  /**
   * Confirms that we can merge-update a record successfully.
   *
   * This test varies from the previous test because it manually defines which
   * fields are inserted, and which fields are updated.
   */
  public function testMergeUpdateExcept() {
    $num_records_before = $this->connection
      ->query('SELECT COUNT(*) FROM {test_people}')
      ->fetchField();
    $this->connection
      ->merge('test_people')
      ->key('job', 'Speaker')
      ->insertFields([
      'age' => 31,
    ])
      ->updateFields([
      'name' => 'Tiffany',
    ])
      ->execute();
    $num_records_after = $this->connection
      ->query('SELECT COUNT(*) FROM {test_people}')
      ->fetchField();
    $this
      ->assertEqual($num_records_before, $num_records_after, 'Merge updated properly.');
    $person = $this->connection
      ->query('SELECT * FROM {test_people} WHERE job = :job', [
      ':job' => 'Speaker',
    ])
      ->fetch();
    $this
      ->assertEqual($person->name, 'Tiffany', 'Name set correctly.');
    $this
      ->assertEqual($person->age, 30, 'Age skipped correctly.');
    $this
      ->assertEqual($person->job, 'Speaker', 'Job set correctly.');
  }

  /**
   * Confirms that we can merge-update a record, with alternate replacement.
   */
  public function testMergeUpdateExplicit() {
    $num_records_before = $this->connection
      ->query('SELECT COUNT(*) FROM {test_people}')
      ->fetchField();
    $this->connection
      ->merge('test_people')
      ->key('job', 'Speaker')
      ->insertFields([
      'age' => 31,
      'name' => 'Tiffany',
    ])
      ->updateFields([
      'name' => 'Joe',
    ])
      ->execute();
    $num_records_after = $this->connection
      ->query('SELECT COUNT(*) FROM {test_people}')
      ->fetchField();
    $this
      ->assertEqual($num_records_before, $num_records_after, 'Merge updated properly.');
    $person = $this->connection
      ->query('SELECT * FROM {test_people} WHERE job = :job', [
      ':job' => 'Speaker',
    ])
      ->fetch();
    $this
      ->assertEqual($person->name, 'Joe', 'Name set correctly.');
    $this
      ->assertEqual($person->age, 30, 'Age skipped correctly.');
    $this
      ->assertEqual($person->job, 'Speaker', 'Job set correctly.');
  }

  /**
   * Confirms that we can merge-update a record successfully, with expressions.
   */
  public function testMergeUpdateExpression() {
    $num_records_before = $this->connection
      ->query('SELECT COUNT(*) FROM {test_people}')
      ->fetchField();
    $age_before = $this->connection
      ->query('SELECT age FROM {test_people} WHERE job = :job', [
      ':job' => 'Speaker',
    ])
      ->fetchField();

    // This is a very contrived example, as I have no idea why you'd want to
    // change age this way, but that's beside the point.
    // Note that we are also double-setting age here, once as a literal and
    // once as an expression. This test will only pass if the expression wins,
    // which is what is supposed to happen.
    $this->connection
      ->merge('test_people')
      ->key('job', 'Speaker')
      ->fields([
      'name' => 'Tiffany',
    ])
      ->insertFields([
      'age' => 31,
    ])
      ->expression('age', 'age + :age', [
      ':age' => 4,
    ])
      ->execute();
    $num_records_after = $this->connection
      ->query('SELECT COUNT(*) FROM {test_people}')
      ->fetchField();
    $this
      ->assertEqual($num_records_before, $num_records_after, 'Merge updated properly.');
    $person = $this->connection
      ->query('SELECT * FROM {test_people} WHERE job = :job', [
      ':job' => 'Speaker',
    ])
      ->fetch();
    $this
      ->assertEqual($person->name, 'Tiffany', 'Name set correctly.');
    $this
      ->assertEqual($person->age, $age_before + 4, 'Age updated correctly.');
    $this
      ->assertEqual($person->job, 'Speaker', 'Job set correctly.');
  }

  /**
   * Tests that we can merge-insert without any update fields.
   */
  public function testMergeInsertWithoutUpdate() {
    $num_records_before = $this->connection
      ->query('SELECT COUNT(*) FROM {test_people}')
      ->fetchField();
    $this->connection
      ->merge('test_people')
      ->key('job', 'Presenter')
      ->execute();
    $num_records_after = $this->connection
      ->query('SELECT COUNT(*) FROM {test_people}')
      ->fetchField();
    $this
      ->assertEqual($num_records_before + 1, $num_records_after, 'Merge inserted properly.');
    $person = $this->connection
      ->query('SELECT * FROM {test_people} WHERE job = :job', [
      ':job' => 'Presenter',
    ])
      ->fetch();
    $this
      ->assertEqual($person->name, '', 'Name set correctly.');
    $this
      ->assertEqual($person->age, 0, 'Age set correctly.');
    $this
      ->assertEqual($person->job, 'Presenter', 'Job set correctly.');
  }

  /**
   * Confirms that we can merge-update without any update fields.
   */
  public function testMergeUpdateWithoutUpdate() {
    $num_records_before = $this->connection
      ->query('SELECT COUNT(*) FROM {test_people}')
      ->fetchField();
    $this->connection
      ->merge('test_people')
      ->key('job', 'Speaker')
      ->execute();
    $num_records_after = $this->connection
      ->query('SELECT COUNT(*) FROM {test_people}')
      ->fetchField();
    $this
      ->assertEqual($num_records_before, $num_records_after, 'Merge skipped properly.');
    $person = $this->connection
      ->query('SELECT * FROM {test_people} WHERE job = :job', [
      ':job' => 'Speaker',
    ])
      ->fetch();
    $this
      ->assertEqual($person->name, 'Meredith', 'Name skipped correctly.');
    $this
      ->assertEqual($person->age, 30, 'Age skipped correctly.');
    $this
      ->assertEqual($person->job, 'Speaker', 'Job skipped correctly.');
    $this->connection
      ->merge('test_people')
      ->key('job', 'Speaker')
      ->insertFields([
      'age' => 31,
    ])
      ->execute();
    $num_records_after = $this->connection
      ->query('SELECT COUNT(*) FROM {test_people}')
      ->fetchField();
    $this
      ->assertEqual($num_records_before, $num_records_after, 'Merge skipped properly.');
    $person = $this->connection
      ->query('SELECT * FROM {test_people} WHERE job = :job', [
      ':job' => 'Speaker',
    ])
      ->fetch();
    $this
      ->assertEqual($person->name, 'Meredith', 'Name skipped correctly.');
    $this
      ->assertEqual($person->age, 30, 'Age skipped correctly.');
    $this
      ->assertEqual($person->job, 'Speaker', 'Job skipped correctly.');
  }

  /**
   * Tests that an invalid merge query throws an exception.
   */
  public function testInvalidMerge() {
    try {

      // This query will fail because there is no key field specified.
      // Normally it would throw an exception but we are suppressing it with
      // the throw_exception option.
      $options['throw_exception'] = FALSE;
      $this->connection
        ->merge('test_people', $options)
        ->fields([
        'age' => 31,
        'name' => 'Tiffany',
      ])
        ->execute();
    } catch (InvalidMergeQueryException $e) {
      $this
        ->fail('$options[\'throw_exception\'] is FALSE, but InvalidMergeQueryException thrown for invalid query.');
    }
    try {

      // This query will fail because there is no key field specified.
      $this->connection
        ->merge('test_people')
        ->fields([
        'age' => 31,
        'name' => 'Tiffany',
      ])
        ->execute();
      $this
        ->fail('InvalidMergeQueryException should be thrown.');
    } catch (\Exception $e) {
      $this
        ->assertInstanceOf(InvalidMergeQueryException::class, $e);
    }
  }

}

Classes

Name	Description
MergeTest	Tests the MERGE query builder.