AttributeTest.php in Ubercart 8.4

Namespace

Drupal\Tests\uc_attribute\Functional

File

uc_attribute/tests/src/Functional/AttributeTest.php

<?php

namespace Drupal\Tests\uc_attribute\Functional;

use Drupal\Tests\uc_store\Functional\UbercartBrowserTestBase;

/**
 * Tests the product attribute API.
 *
 * @group ubercart
 */
class AttributeTest extends UbercartBrowserTestBase {

  /**
   * {@inheritdoc}
   */
  protected static $modules = [
    'uc_attribute',
  ];

  /**
   * {@inheritdoc}
   */
  protected static $adminPermissions = [
    'administer attributes',
    'administer product attributes',
    'administer product options',
  ];

  /**
   * {@inheritdoc}
   */
  protected function setUp() {
    parent::setUp();

    // Need page_title_block because we test page titles.
    $this
      ->drupalPlaceBlock('page_title_block');
    $this
      ->drupalLogin($this->adminUser);
  }

  /**
   * Tests the basic attribute API.
   */
  public function testAttributeApi() {

    // Create an attribute.
    $attribute = $this
      ->createAttribute();

    // Test retrieval.
    $loaded_attribute = uc_attribute_load($attribute->aid);

    // Check the attribute integrity.
    foreach ($this
      ->attributeFieldsToTest() as $field) {
      if ($loaded_attribute->{$field} != $attribute->{$field}) {
        $this
          ->fail('Attribute integrity check failed.');
        break;
      }
    }

    // Add a product.
    $product = $this
      ->createProduct();

    // Attach the attribute to a product.
    uc_attribute_subject_save($attribute, 'product', $product
      ->id());

    // Confirm the database is correct.
    $this
      ->assertEquals($attribute->aid, \Drupal::database()
      ->query('SELECT aid FROM {uc_product_attributes} WHERE nid = :nid', [
      ':nid' => $product
        ->id(),
    ])
      ->fetchField(), 'Attribute was attached to a product properly.');
    $this
      ->assertTrue(uc_attribute_subject_exists($attribute->aid, 'product', $product
      ->id()));

    // Test retrieval.
    $loaded_attribute = uc_attribute_load($attribute->aid, $product
      ->id(), 'product');

    // Check the attribute integrity.
    foreach ($this
      ->attributeFieldsToTest('product') as $field) {
      if ($loaded_attribute->{$field} != $attribute->{$field}) {
        $this
          ->fail('Attribute integrity check failed.');
        break;
      }
    }

    // Delete it.
    uc_attribute_subject_delete($attribute->aid, 'product', $product
      ->id());

    // Confirm again.
    $this
      ->assertFalse(\Drupal::database()
      ->query('SELECT aid FROM {uc_product_attributes} WHERE nid = :nid', [
      ':nid' => $product
        ->id(),
    ])
      ->fetchField(), 'Attribute was detached from a product properly.');
    $this
      ->assertFalse(uc_attribute_subject_exists($attribute->aid, 'product', $product
      ->id()));

    // Add a product class.
    $product_class = $this
      ->createProductClass();

    // Attach the attribute to a product class.
    uc_attribute_subject_save($attribute, 'class', $product_class
      ->id());

    // Confirm the database is correct.
    $this
      ->assertEquals($attribute->aid, \Drupal::database()
      ->query('SELECT aid FROM {uc_class_attributes} WHERE pcid = :pcid', [
      ':pcid' => $product_class
        ->id(),
    ])
      ->fetchField(), 'Attribute was attached to a product class properly.');
    $this
      ->assertTrue(uc_attribute_subject_exists($attribute->aid, 'class', $product_class
      ->id()));

    // Test retrieval.
    $loaded_attribute = uc_attribute_load($attribute->aid, $product_class
      ->id(), 'class');

    // Check the attribute integrity.
    foreach ($this
      ->attributeFieldsToTest('class') as $field) {
      if ($loaded_attribute->{$field} != $attribute->{$field}) {
        $this
          ->fail('Attribute integrity check failed.');
        break;
      }
    }

    // Delete it.
    uc_attribute_subject_delete($attribute->aid, 'class', $product_class
      ->id());

    // Confirm again.
    $this
      ->assertFalse(\Drupal::database()
      ->query('SELECT aid FROM {uc_class_attributes} WHERE pcid = :pcid', [
      ':pcid' => $product_class
        ->id(),
    ])
      ->fetchField(), 'Attribute was detached from a product class properly.');
    $this
      ->assertFalse(uc_attribute_subject_exists($attribute->aid, 'class', $product_class
      ->id()));

    // Create a few more.
    for ($i = 0; $i < 5; $i++) {
      $a = $this
        ->createAttribute();
      $attributes[$a->aid] = $a;
    }

    // Add some options, organizing them by aid and oid.
    $attribute_aids = array_keys($attributes);
    $all_options = [];
    foreach ($attribute_aids as $aid) {
      for ($i = 0; $i < 3; $i++) {
        $option = $this
          ->createAttributeOption([
          'aid' => $aid,
        ]);
        $all_options[$option->aid][$option->oid] = $option;
      }
    }
    for ($i = 0; $i < 3; $i++) {
      $option = $this
        ->createAttributeOption([
        'aid' => $aid,
      ]);
      $all_options[$option->aid][$option->oid] = $option;
    }

    // Get the options.
    $attribute = uc_attribute_load($attribute->aid);

    // Load every attribute we got.
    $attributes_with_options = uc_attribute_load_multiple();

    // Make sure all the new options are on attributes correctly.
    foreach ($all_options as $aid => $options) {
      foreach ($options as $oid => $option) {
        foreach ($this
          ->attributeOptionFieldsToTest() as $field) {
          if ($option->{$field} != $attributes_with_options[$aid]->options[$oid]->{$field}) {
            $this
              ->fail('Option integrity check failed.');
            break;
          }
        }
      }
    }

    // Pick 5 keys to check at random.
    $aids = array_rand($attributes, 3);
    $aids = array_combine($aids, $aids);

    // Load the attributes back.
    $loaded_attributes = uc_attribute_load_multiple($aids);

    // Make sure we only got the attributes we asked for. No more, no less.
    $this
      ->assertSameSize($aids, $loaded_attributes, 'Verifying attribute result.');
    $this
      ->assertSameSize($aids, array_intersect_key($aids, $loaded_attributes), 'Verifying attribute result.');

    // Check the attributes' integrity.
    foreach ($loaded_attributes as $aid => $loaded_attribute) {
      foreach ($this
        ->attributeFieldsToTest() as $field) {
        if ($attributes[$aid]->{$field} != $loaded_attributes[$aid]->{$field}) {
          $this
            ->fail('Attribute integrity check failed.');
          break;
        }
      }
    }

    // Add the selected attributes to the product.
    foreach ($loaded_attributes as $loaded_attribute) {
      uc_attribute_subject_save($loaded_attribute, 'product', $product
        ->id(), TRUE);
    }

    // Test loading all product attributes. (This covers
    // uc_attribute_load_product_attributes(), as the semantics are the same).
    $loaded_product_attributes = uc_attribute_load_multiple([], 'product', $product
      ->id());

    // We'll get all in $loaded_attributes above, plus the original.
    $product_attributes = $loaded_attributes;

    // Make sure we only got the attributes we asked for. No more, no less.
    $this
      ->assertSameSize($loaded_product_attributes, $product_attributes, 'Verifying attribute result.');
    $this
      ->assertSameSize($loaded_product_attributes, array_intersect_key($loaded_product_attributes, $product_attributes), 'Verifying attribute result.');

    // Check the attributes' integrity.
    foreach ($loaded_product_attributes as $aid => $loaded_product_attribute) {
      foreach ($this
        ->attributeFieldsToTest('product') as $field) {
        if ($loaded_product_attributes[$aid]->{$field} != $product_attributes[$aid]->{$field}) {
          $this
            ->fail('Attribute integrity check failed.');
          break;
        }
      }
    }

    // Make sure all the options are on attributes correctly.
    foreach ($all_options as $aid => $options) {
      foreach ($options as $oid => $option) {
        if (empty($loaded_product_attributes[$aid]) || empty($loaded_product_attributes[$aid]->options[$oid])) {
          continue;
        }
        foreach ($this
          ->attributeOptionFieldsToTest() as $field) {
          if ($option->{$field} != $loaded_product_attributes[$aid]->options[$oid]->{$field}) {
            $this
              ->fail('Option integrity check failed.');
            break;
          }
        }
      }
    }

    // Add the selected attributes to the product.
    foreach ($loaded_attributes as $loaded_attribute) {
      uc_attribute_subject_save($loaded_attribute, 'class', $product_class
        ->id(), TRUE);
    }

    // Test loading all product attributes. (This covers
    // uc_attribute_load_product_attributes(), as the semantics are the same).
    $loaded_class_attributes = uc_attribute_load_multiple([], 'class', $product_class
      ->id());

    // We'll get all in $loaded_attributes above, plus the original.
    $class_attributes = $loaded_attributes;

    // Make sure we only got the attributes we asked for. No more, no less.
    $this
      ->assertSameSize($loaded_class_attributes, $class_attributes, 'Verifying attribute result.');
    $this
      ->assertSameSize($loaded_class_attributes, array_intersect_key($loaded_class_attributes, $class_attributes), 'Verifying attribute result.');

    // Check the attributes' integrity.
    foreach ($loaded_class_attributes as $aid => $loaded_class_attribute) {
      foreach ($this
        ->attributeFieldsToTest('class') as $field) {
        if ($loaded_class_attributes[$aid]->{$field} != $class_attributes[$aid]->{$field}) {
          $this
            ->fail('Attribute integrity check failed.');
          break;
        }
      }
    }

    // Make sure all the options are on attributes correctly.
    foreach ($all_options as $aid => $options) {
      foreach ($options as $oid => $option) {
        if (empty($loaded_class_attributes[$aid]) || empty($loaded_class_attributes[$aid]->options[$oid])) {
          continue;
        }
        foreach ($this
          ->attributeOptionFieldsToTest() as $field) {
          if ($option->{$field} != $loaded_class_attributes[$aid]->options[$oid]->{$field}) {
            $this
              ->fail('Option integrity check failed.');
            break;
          }
        }
      }
    }

    // Test deletion of base attribute.
    $options = $attribute->options;
    uc_attribute_delete($attribute->aid);
    $this
      ->assertFalse(uc_attribute_load($attribute->aid), 'Attribute was deleted properly.');

    // Sanity check!
    $this
      ->assertFalse(\Drupal::database()
      ->query('SELECT aid FROM {uc_attributes} WHERE aid = :aid', [
      ':aid' => $attribute->aid,
    ])
      ->fetchField(), 'Attribute was seriously deleted properly!');

    // Test that options were deleted properly.
    foreach ($options as $option) {
      $this
        ->assertFalse(\Drupal::database()
        ->query('SELECT oid FROM {uc_attribute_options} WHERE oid = :oid', [
        ':oid' => $option->oid,
      ])
        ->fetchField(), 'Make sure options are deleted properly.');
    }

    // Test the deletion applied to products too.
    $loaded_product_attributes = uc_attribute_load_multiple([], 'product', $product
      ->id());

    // We'll get all in $loaded_attributes above, without the original. (Which
    // has been deleted.)
    $product_attributes = $loaded_attributes;

    // Make sure we only got the attributes we asked for. No more, no less.
    $this
      ->assertSameSize($loaded_product_attributes, $product_attributes, 'Verifying attribute result.');
    $this
      ->assertSameSize($loaded_product_attributes, array_intersect_key($loaded_product_attributes, $product_attributes), 'Verifying attribute result.');

    // Test the deletion applied to classes too.
    $loaded_class_attributes = uc_attribute_load_multiple([], 'class', $product_class
      ->id());

    // We'll get all in $loaded_attributes above, without the original. (Which
    // has been deleted.)
    $class_attributes = $loaded_attributes;

    // Make sure we only got the attributes we asked for. No more, no less.
    $this
      ->assertSameSize($loaded_class_attributes, $class_attributes, 'Verifying attribute result.');
    $this
      ->assertSameSize($loaded_class_attributes, array_intersect_key($loaded_class_attributes, $class_attributes), 'Verifying attribute result.');

    // Add some adjustments.
    $this
      ->createProductAdjustment([
      'combination' => 'a:1:{i:1;s:1:"1";}',
      'nid' => 1,
    ]);
    $this
      ->createProductAdjustment([
      'combination' => 'a:1:{i:1;s:1:"2";}',
      'nid' => 1,
    ]);
    $this
      ->createProductAdjustment([
      'combination' => 'a:1:{i:1;s:1:"3";}',
      'nid' => 1,
    ]);
    $this
      ->createProductAdjustment([
      'combination' => 'a:1:{i:2;s:1:"1";}',
      'nid' => 2,
    ]);
    $this
      ->createProductAdjustment([
      'combination' => 'a:1:{i:3;s:1:"1";}',
      'nid' => 2,
    ]);
    $this
      ->createProductAdjustment([
      'combination' => 'a:1:{i:1;s:1:"2";}',
      'nid' => 3,
    ]);
    $this
      ->createProductAdjustment([
      'combination' => 'a:1:{i:1;s:1:"3";}',
      'nid' => 3,
    ]);
    $this
      ->createProductAdjustment([
      'combination' => 'a:1:{i:3;s:1:"2";}',
      'nid' => 3,
    ]);
    $this
      ->createProductAdjustment([
      'combination' => 'a:1:{i:3;s:1:"3";}',
      'nid' => 4,
    ]);

    // Test deletion by nid.
    uc_attribute_adjustments_delete([
      'nid' => 1,
    ]);
    $this
      ->assertEquals(6, \Drupal::database()
      ->query('SELECT COUNT(*) FROM {uc_product_adjustments}')
      ->fetchField());

    // Test deletion by aid.
    uc_attribute_adjustments_delete([
      'aid' => 2,
    ]);
    $this
      ->assertEquals(5, \Drupal::database()
      ->query('SELECT COUNT(*) FROM {uc_product_adjustments}')
      ->fetchField());

    // Test deletion by oid.
    uc_attribute_adjustments_delete([
      'oid' => 2,
    ]);
    $this
      ->assertEquals(3, \Drupal::database()
      ->query('SELECT COUNT(*) FROM {uc_product_adjustments}')
      ->fetchField());

    // Test deletion by aid and oid.
    uc_attribute_adjustments_delete([
      'aid' => 1,
      'oid' => 3,
    ]);
    $this
      ->assertEquals(2, \Drupal::database()
      ->query('SELECT COUNT(*) FROM {uc_product_adjustments}')
      ->fetchField());
  }

  /**
   * Tests the "add attribute" user interface.
   */
  public function testAttributeUiAddAttribute() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    $this
      ->drupalGet('admin/store/products/attributes/add');
    $assert
      ->pageTextContains('The name of the attribute used in administrative forms');
    $edit = (array) $this
      ->createAttribute([], FALSE);
    $this
      ->submitForm($edit, 'Submit');
    if ($edit['display'] != 0) {

      // We redirect to add options page ONLY for non-textfield attributes.
      $assert
        ->pageTextContains('Options for ' . $edit['name']);
      $assert
        ->pageTextContains('No options for this attribute have been added yet.');
    }
    else {

      // For textfield attributes we redirect to attribute list.
      // Check that the created attribute name and label appear.
      $assert
        ->pageTextContains($edit['name']);
      $assert
        ->pageTextContains($edit['label']);
    }
    $this
      ->drupalGet('admin/store/products/attributes');

    // Verify name, label, 'required', ordering, and display fields.
    $assert
      ->responseContains('<td>' . $edit['name'] . '</td>');
    $assert
      ->responseContains('<td>' . $edit['label'] . '</td>');
    $assert
      ->responseContains('<td>' . ($edit['required'] ? 'Yes' : 'No') . '</td>');
    $assert
      ->responseContains('<td>' . $edit['ordering'] . '</td>');
    $types = _uc_attribute_display_types();
    $assert
      ->responseContains('<td>' . $types[$edit['display']] . '</td>');
    $aid = \Drupal::database()
      ->query('SELECT aid FROM {uc_attributes} WHERE name = :name', [
      ':name' => $edit['name'],
    ])
      ->fetchField();
    $this
      ->assertTrue($aid, 'Attribute was created.');
    $attribute = uc_attribute_load($aid);
    $fields_ok = TRUE;
    foreach ($edit as $field => $value) {
      if ($attribute->{$field} != $value) {
        $this
          ->showVar($attribute);
        $this
          ->showVar($edit);
        $fields_ok = FALSE;
        break;
      }
    }
    $this
      ->assertTrue($fields_ok, 'Attribute created properly.');
  }

  /**
   * Tests the attribute settings page.
   */
  public function testAttributeUiSettings() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    $product = $this
      ->createProduct();
    $attribute = $this
      ->createAttribute([
      'display' => 1,
    ]);
    $option = $this
      ->createAttributeOption([
      'aid' => $attribute->aid,
      'price' => 30,
    ]);
    $attribute->options[$option->oid] = $option;
    uc_attribute_subject_save($attribute, 'product', $product
      ->id(), TRUE);
    $qty = $product->default_qty->value;
    if (!$qty) {
      $qty = 1;
    }
    $adjust_price = uc_currency_format($option->price * $qty);
    $total_price = uc_currency_format(($product->price->value + $option->price) * $qty);
    $raw = [
      'none' => $option->name . '</option>',
      'adjustment' => $option->name . ', +' . $adjust_price . '</option>',
      'total' => $total_price . '</option>',
    ];
    foreach ([
      'none',
      'adjustment',
      'total',
    ] as $type) {
      $edit['uc_attribute_option_price_format'] = $type;
      $this
        ->drupalGet('admin/store/config/products');
      $this
        ->submitForm($edit, 'Save configuration');
      $this
        ->drupalGet('node/' . $product
        ->id());

      // Verify attribute option pricing is correct.
      $assert
        ->responseContains($raw[$type]);
    }
  }

  /**
   * Tests the "edit attribute" user interface.
   */
  public function testAttributeUiEditAttribute() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    $attribute = $this
      ->createAttribute();
    $this
      ->drupalGet('admin/store/products/attributes/' . $attribute->aid . '/edit');
    $assert
      ->pageTextContains('Edit attribute: ' . $attribute->name);
    $edit = (array) $this
      ->createAttribute([], FALSE);
    $this
      ->submitForm($edit, 'Submit');
    $attribute = uc_attribute_load($attribute->aid);
    $fields_ok = TRUE;
    foreach ($edit as $field => $value) {
      if ($attribute->{$field} != $value) {
        $this
          ->showVar($attribute);
        $this
          ->showVar($edit);
        $fields_ok = FALSE;
        break;
      }
    }
    $this
      ->assertTrue($fields_ok, 'Attribute edited properly.');
  }

  /**
   * Tests the "delete attribute" user interface.
   */
  public function testAttributeUiDeleteAttribute() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    $attribute = $this
      ->createAttribute();
    $this
      ->drupalGet('admin/store/products/attributes/' . $attribute->aid . '/delete');
    $assert
      ->pageTextContains('Are you sure you want to delete the attribute ' . $attribute->name . '?');
    $this
      ->submitForm([], 'Delete');
    $assert
      ->pageTextContains('Product attribute deleted.');
  }

  /**
   * Tests the attribute options user interface.
   */
  public function testAttributeUiAttributeOptions() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    $attribute = $this
      ->createAttribute();
    $option = $this
      ->createAttributeOption([
      'aid' => $attribute->aid,
    ]);
    uc_attribute_option_save($option);
    $this
      ->drupalGet('admin/store/products/attributes/' . $attribute->aid . '/options');
    $assert
      ->pageTextContains('Options for ' . $attribute->name);
  }

  /**
   * Tests the "add attribute option" user interface.
   */
  public function testAttributeUiAttributeOptionsAdd() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    $attribute = $this
      ->createAttribute();
    $this
      ->drupalGet('admin/store/products/attributes/' . $attribute->aid . '/options/add');
    $assert
      ->pageTextContains('Options for ' . $attribute->name);
    $edit = (array) $this
      ->createAttributeOption([
      'aid' => $attribute->aid,
    ], FALSE);
    unset($edit['aid']);
    $this
      ->drupalGet('admin/store/products/attributes/' . $attribute->aid . '/options/add');
    $this
      ->submitForm($edit, 'Submit');
    $option = \Drupal::database()
      ->query('SELECT * FROM {uc_attribute_options} WHERE aid = :aid', [
      ':aid' => $attribute->aid,
    ])
      ->fetchObject();
    $fields_ok = TRUE;
    foreach ($edit as $field => $value) {
      if ($option->{$field} != $value) {
        $this
          ->showVar($option);
        $this
          ->showVar($edit);
        $fields_ok = FALSE;
        break;
      }
    }
    $this
      ->assertTrue($fields_ok, 'Attribute option added successfully by form.');
  }

  /**
   * Tests the "edit attribute options" user interface.
   */
  public function testAttributeUiAttributeOptionsEdit() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    $attribute = $this
      ->createAttribute();
    $option = $this
      ->createAttributeOption([
      'aid' => $attribute->aid,
    ]);
    uc_attribute_option_save($option);
    $this
      ->drupalGet('admin/store/products/attributes/' . $attribute->aid . '/options/' . $option->oid . '/edit');
    $assert
      ->pageTextContains('Edit option: ' . $option->name);
    $edit = (array) $this
      ->createAttributeOption([
      'aid' => $attribute->aid,
    ], FALSE);
    unset($edit['aid']);
    $this
      ->drupalGet('admin/store/products/attributes/' . $attribute->aid . '/options/' . $option->oid . '/edit');
    $this
      ->submitForm($edit, 'Submit');
    $option = uc_attribute_option_load($option->oid);
    $fields_ok = TRUE;
    foreach ($edit as $field => $value) {
      if ($option->{$field} != $value) {
        $this
          ->showVar($option);
        $this
          ->showVar($edit);
        $fields_ok = FALSE;
        break;
      }
    }
    $this
      ->assertTrue($fields_ok, 'Attribute option edited successfully by form.');
  }

  /**
   * Tests the "delete attribute option" user interface.
   */
  public function testAttributeUiAttributeOptionsDelete() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    $attribute = $this
      ->createAttribute();
    $option = $this
      ->createAttributeOption([
      'aid' => $attribute->aid,
    ]);
    uc_attribute_option_save($option);
    $this
      ->drupalGet('admin/store/products/attributes/' . $attribute->aid . '/options/' . $option->oid . '/delete');
    $assert
      ->pageTextContains('Are you sure you want to delete the option ' . $option->name . '?');
    $this
      ->submitForm([], 'Delete');
    $option = uc_attribute_option_load($option->oid);
    $this
      ->assertFalse($option, 'Attribute option deleted successfully by form');
  }

  /**
   * Tests the product class attribute user interface.
   */
  public function testAttributeUiClassAttributeOverview() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    $class = $this
      ->createProductClass();
    $attribute = $this
      ->createAttribute();
    $this
      ->drupalGet('admin/structure/types/manage/' . $class
      ->id() . '/attributes');
    $assert
      ->pageTextContains('No attributes available.');
    uc_attribute_subject_save($attribute, 'class', $class
      ->id());
    $this
      ->drupalGet('admin/structure/types/manage/' . $class
      ->id() . '/attributes');
    $assert
      ->pageTextNotContains('No attributes available.');
    $a = (array) $this
      ->createAttribute([], FALSE);
    unset($a['name'], $a['description']);
    foreach ($a as $field => $value) {
      $edit["attributes[{$attribute->aid}][{$field}]"] = $value;
    }
    $this
      ->showVar($edit);
    $this
      ->drupalGet('admin/structure/types/manage/' . $class
      ->id() . '/attributes');
    $this
      ->submitForm($edit, 'Save changes');
    $attribute = uc_attribute_load($attribute->aid, $class
      ->id(), 'class');
    $fields_ok = TRUE;
    foreach ($a as $field => $value) {
      if ($attribute->{$field} != $value) {
        $this
          ->showVar($attribute);
        $this
          ->showVar($a);
        $fields_ok = FALSE;
        break;
      }
    }
    $this
      ->assertTrue($fields_ok, 'Class attribute edited successfully by form.');
    $edit = [];
    $edit["attributes[{$attribute->aid}][remove]"] = TRUE;
    $this
      ->drupalGet('admin/structure/types/manage/' . $class
      ->id() . '/attributes');
    $this
      ->submitForm($edit, 'Save changes');
    $assert
      ->pageTextContains('No attributes available.');
  }

  /**
   * Tests the "add product class attribute option" user interface.
   */
  public function testAttributeUiClassAttributeAdd() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    $class = $this
      ->createProductClass();
    $attribute = $this
      ->createAttribute();
    $this
      ->drupalGet('admin/structure/types/manage/' . $class
      ->id() . '/attributes/add');

    // Verify class attribute add form is working.
    $assert
      ->responseContains($attribute->name . '</label>');
    $edit['add_attributes[' . $attribute->aid . ']'] = 1;
    $this
      ->drupalGet('admin/structure/types/manage/' . $class
      ->id() . '/attributes/add');
    $this
      ->submitForm($edit, 'Add attributes');
    $assert
      ->pageTextNotContains('No attributes available.');
  }

  /**
   * Tests the product class attribute option user interface.
   */
  public function testAttributeUiClassAttributeOptionOverview() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    $class = $this
      ->createProductClass();
    $attribute = $this
      ->createAttribute();
    $option = $this
      ->createAttributeOption([
      'aid' => $attribute->aid,
    ]);
    uc_attribute_subject_save($attribute, 'class', $class
      ->id());
    $this
      ->drupalGet('admin/structure/types/manage/' . $class
      ->id() . '/options');

    // Verify class attribute option form is working.
    $assert
      ->responseContains($option->name . '</label>');
    $o = (array) $this
      ->createAttributeOption([
      'aid' => $attribute->aid,
    ], FALSE);
    unset($o['name'], $o['aid']);
    $o['select'] = TRUE;
    foreach ($o as $field => $value) {
      $edit["attributes[{$attribute->aid}][options][{$option->oid}][{$field}]"] = $value;
    }
    unset($o['select']);
    $edit["attributes[{$attribute->aid}][default]"] = $option->oid;
    $this
      ->showVar($edit);
    $this
      ->drupalGet('admin/structure/types/manage/' . $class
      ->id() . '/options');
    $this
      ->submitForm($edit, 'Save changes');
    $assert
      ->pageTextContains('The changes have been saved.');
    $this
      ->showVar($option);
    $option = uc_attribute_subject_option_load($option->oid, 'class', $class
      ->id());
    $fields_ok = TRUE;
    foreach ($o as $field => $value) {
      if ($option->{$field} != $value) {
        $this
          ->showVar($option);
        $this
          ->showVar($o);
        $fields_ok = FALSE;
        break;
      }
    }
    $this
      ->assertTrue($fields_ok, 'Class attribute option edited successfully by form.');
  }

  /**
   * Tests the "product attributes" page.
   */
  public function testAttributeUiProductAttributes() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    $product = $this
      ->createProduct();
    $attribute = $this
      ->createAttribute([
      'display' => 1,
    ]);
    $option = $this
      ->createAttributeOption([
      'aid' => $attribute->aid,
    ]);
    $this
      ->drupalGet('node/' . $product
      ->id() . '/edit/attributes');
    $assert
      ->pageTextContains('No attributes available.');
    $this
      ->clickLink('Add existing attribute');
    $assert
      ->pageTextContains($attribute->name);
    $this
      ->submitForm([
      'add_attributes[' . $attribute->aid . ']' => 1,
    ], 'Add attributes');
    $assert
      ->pageTextContains('1 attribute has been added.');

    // Check for attribute name.
    $assert
      ->pageTextContains($attribute->name);

    // Check for attribute label.
    $assert
      ->fieldValueEquals('attributes[' . $attribute->aid . '][label]', $attribute->label);

    // Check for default option name.
    $assert
      ->pageTextContains($option->name);

    // Check for default option price.
    $assert
      ->pageTextContains(uc_currency_format($option->price));

    // Check for attribute display setting.
    $assert
      ->fieldValueEquals('attributes[' . $attribute->aid . '][display]', $attribute->display);
    $this
      ->drupalGet('node/' . $product
      ->id() . '/edit/attributes/add');
    $assert
      ->pageTextNotContains($attribute->name);
    $assert
      ->pageTextContains('No attributes left to add.');
    $edit = [
      'attributes[' . $attribute->aid . '][remove]' => 1,
    ];
    $this
      ->drupalGet('node/' . $product
      ->id() . '/edit/attributes');
    $this
      ->submitForm($edit, 'Save changes');
    $assert
      ->pageTextContains('No attributes available.');
  }

  /**
   * Tests the "product options" page.
   */
  public function testAttributeUiProductOptions() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    $product = $this
      ->createProduct();
    $attribute = $this
      ->createAttribute([
      'display' => 1,
    ]);
    for ($i = 0; $i < 3; $i++) {
      $option = $this
        ->createAttributeOption([
        'aid' => $attribute->aid,
      ]);
      $attribute->options[$option->oid] = $option;
    }
    uc_attribute_subject_save($attribute, 'product', $product
      ->id(), TRUE);
    $this
      ->drupalGet('node/' . $product
      ->id() . '/edit/options');

    // Check for attribute name.
    $assert
      ->pageTextContains($attribute->name);
    foreach ($attribute->options as $option) {

      // Check for option name.
      $assert
        ->pageTextContains($option->name);

      // Check for option cost field.
      $assert
        ->fieldValueEquals('attributes[' . $attribute->aid . '][options][' . $option->oid . '][cost]', uc_currency_format($option->cost, FALSE));

      // Check for option price field.
      $assert
        ->fieldValueEquals('attributes[' . $attribute->aid . '][options][' . $option->oid . '][price]', uc_currency_format($option->price, FALSE));

      // Check for option weight field.
      $assert
        ->fieldValueEquals('attributes[' . $attribute->aid . '][options][' . $option->oid . '][weight]', $option->weight);
    }
  }

  /**
   * Tests the "product adjustments" page.
   */
  public function testAttributeUiProductAdjustments() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    $product = $this
      ->createProduct();
    $attribute = $this
      ->createAttribute([
      'display' => 1,
    ]);
    for ($i = 0; $i < 3; $i++) {
      $option = $this
        ->createAttributeOption([
        'aid' => $attribute->aid,
      ]);
      $adjustment = $this
        ->createProductAdjustment([
        'combination' => serialize([
          $attribute->aid => $option->oid,
        ]),
        'nid' => $product
          ->id(),
      ]);
      $option->model = $adjustment->model;
      $attribute->options[$option->oid] = $option;
    }
    uc_attribute_subject_save($attribute, 'product', $product
      ->id(), TRUE);
    $this
      ->drupalGet('node/' . $product
      ->id() . '/edit/adjustments');

    // Check for default product SKU.
    $assert
      ->pageTextContains('Default product SKU: ' . $product->model->value);

    // Verify attribute name, option name(s), and option SKU(s) are found.
    $assert
      ->responseContains('<th>' . $attribute->name . '</th>');
    foreach ($attribute->options as $option) {
      $assert
        ->responseContains('<td>' . $option->name . '</td>');
      $assert
        ->responseContains($option->model);
    }
  }

  /**
   * Tests attributes applied to a product.
   */
  public function testProductAttribute() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    $product = $this
      ->createProduct();
    $attribute = $this
      ->createAttribute([
      'display' => 2,
      'required' => TRUE,
    ]);
    for ($i = 0; $i < 3; $i++) {
      $option = $this
        ->createAttributeOption([
        'aid' => $attribute->aid,
      ]);
      $adjustment = $this
        ->createProductAdjustment([
        'combination' => serialize([
          $attribute->aid => $option->oid,
        ]),
        'nid' => $product
          ->id(),
      ]);
      $option->model = $adjustment->model;
      $attribute->options[$option->oid] = $option;
    }
    uc_attribute_subject_save($attribute, 'product', $product
      ->id(), TRUE);

    // Product node display.
    $this
      ->drupalGet('node/' . $product
      ->id());

    // Check for attribute label and description.
    $assert
      ->pageTextContains($attribute->label);
    $assert
      ->pageTextContains($attribute->description);
    foreach ($attribute->options as $option) {

      // Check for option name and price adjustment.
      $assert
        ->pageTextContains($option->name);
      $assert
        ->pageTextContains(uc_currency_format($option->price));
    }

    // Test required attribute.
    $this
      ->addToCart($product);

    // Check for attribute required message.
    $assert
      ->pageTextContains($attribute->label . ' field is required');

    // Cart display.
    $price = uc_currency_format($product->price->value + $option->price);
    $this
      ->addToCart($product, [
      'attributes[' . $attribute->aid . ']' => $option->oid,
    ]);

    // Check for selected attribute, option, and adjusted price in the cart.
    $assert
      ->pageTextContains($attribute->label . ': ' . $option->name);
    $assert
      ->pageTextContains($price);

    // Checkout display.
    $this
      ->submitForm([], 'Checkout');

    // Check for selected attribute, option, and adjusted price at checkout.
    $assert
      ->pageTextContains($attribute->label . ': ' . $option->name);
    $assert
      ->pageTextContains($price);
    $this
      ->checkout();

    // Admin order display.
    $cost = uc_currency_format($product->cost->value + $option->cost);
    $this
      ->drupalGet('admin/store/orders/1');

    // Check for selected attribute, option, adjusted price, adjusted cost and
    // adjusted SKU on admin order page.
    $assert
      ->pageTextContains($attribute->label . ': ' . $option->name, '');
    $assert
      ->pageTextContains($cost);
    $assert
      ->pageTextContains($price);
    $assert
      ->pageTextContains($option->model);

    // Invoice display.
    $this
      ->drupalGet('admin/store/orders/1/invoice');

    // Check for selected attribute, option, adjusted price, and adjusted SKU
    // on order invoice.
    $assert
      ->pageTextContains($attribute->label . ': ' . $option->name);
    $assert
      ->pageTextContains($price);
    $assert
      ->pageTextContains('SKU: ' . $option->model);
  }

  /**
   * Tests that product in cart has the selected attribute option.
   */
  public function testAttributeAddToCart() {

    /** @var \Drupal\Tests\WebAssert $assert */
    $assert = $this
      ->assertSession();
    for ($display = 0; $display <= 3; ++$display) {

      // Set up an attribute.
      $attribute = $this
        ->createAttribute([
        'display' => $display,
      ]);
      if ($display) {

        // Give the attribute an option.
        $option = $this
          ->createAttributeOption([
          'aid' => $attribute->aid,
        ]);
      }
      $attribute = uc_attribute_load($attribute->aid);

      // Put the attribute on a product.
      $product = $this
        ->createProduct();
      uc_attribute_subject_save($attribute, 'product', $product
        ->id(), TRUE);

      // Add the product to the cart.
      if ($display == 3) {
        $edit = [
          "attributes[{$attribute->aid}][{$option->oid}]" => $option->oid,
        ];
      }
      elseif (isset($option)) {
        $edit = [
          "attributes[{$attribute->aid}]" => $option->oid,
        ];
      }
      else {
        $option = new \stdClass();
        $option->name = self::randomMachineName();
        $option->price = 0;
        $edit = [
          "attributes[{$attribute->aid}]" => $option->name,
        ];
      }
      $this
        ->addToCart($product, $edit);

      // Check that option is listed on the cart item.
      $assert
        ->pageTextContains("{$attribute->label}: {$option->name}", 'Option selected on cart item.');

      // Check that the price in the cart is correct for this option.
      $assert
        ->pageTextContains(uc_currency_format($product->price->value + $option->price));
    }
  }

  /**
   * Creates a product adjustment SKU.
   *
   * @param array $data
   *   Adjustment data for this product.
   *
   * @return object
   *   Adjustment data as an object.
   */
  public function createProductAdjustment(array $data) {
    $adjustment = $data + [
      'model' => $this
        ->randomMachineName(8),
    ];
    \Drupal::database()
      ->insert('uc_product_adjustments')
      ->fields($adjustment)
      ->execute();
    return (object) $adjustment;
  }

  /**
   * Returns an array of available fields for product or class attributes.
   *
   * @param string $type
   *   One of 'product' for products or 'class' for product classes.
   *
   * @return array
   *   Associative array of fields values keyed by field name.
   */
  protected function attributeFieldsToTest($type = '') {
    $fields = [
      'aid',
      'name',
      'ordering',
      'required',
      'display',
      'description',
      'label',
    ];
    switch ($type) {
      case 'product':
      case 'class':
        $info = uc_attribute_type_info($type);
        $fields = array_merge($fields, [
          $info['id'],
        ]);
        break;
    }
    return $fields;
  }

  /**
   * Returns array of available fields for product or class attribute options.
   *
   * @param string $type
   *   One of 'product' for products or 'class' for product classes.
   *
   * @return array
   *   Associative array of fields values keyed by field name.
   */
  protected function attributeOptionFieldsToTest($type = '') {
    $fields = [
      'aid',
      'oid',
      'name',
      'cost',
      'price',
      'weight',
      'ordering',
    ];
    switch ($type) {
      case 'product':
      case 'class':
        $info = uc_attribute_type_info($type);
        $fields = array_merge($fields, [
          $info['id'],
        ]);
        break;
    }
    return $fields;
  }

  /**
   * Debug helper function.
   *
   * @param mixed $var
   *   Variable to display in the test results.
   */
  protected function showVar($var) {
    $this
      ->assertTrue(TRUE, '<pre>' . print_r($var, TRUE) . '</pre>');
  }

}

Classes

Name	Description
AttributeTest	Tests the product attribute API.