class FieldInstanceCrudTest

class FieldInstanceCrudTest extends FieldUnitTestBase {
  protected $field;
  public static function getInfo() {
    return array(
      'name' => 'Field instance CRUD tests',
      'description' => 'Create field entities by attaching fields to entities.',
      'group' => 'Field API',
    );
  }
  function setUp() {
    parent::setUp();
    $this->field = array(
      'field_name' => drupal_strtolower($this
        ->randomName()),
      'type' => 'test_field',
    );
    field_create_field($this->field);
    $this->instance_definition = array(
      'field_name' => $this->field['field_name'],
      'entity_type' => 'test_entity',
      'bundle' => 'test_bundle',
    );
  }

  // TODO : test creation with
  // - a full fledged $instance structure, check that all the values are there
  // - a minimal $instance structure, check all default values are set
  // defer actual $instance comparison to a helper function, used for the two cases above,
  // and for testUpdateFieldInstance

  /**
   * Test the creation of a field instance.
   */
  function testCreateFieldInstance() {
    $instance = field_create_instance($this->instance_definition);

    // Read the configuration. Check against raw configuration data rather than
    // the loaded ConfigEntity, to be sure we check that the defaults are
    // applied on write.
    $config = \Drupal::config('field.instance.' . $instance
      ->id())
      ->get();
    $field_type = field_info_field_types($this->field['type']);

    // Check that default values are set.
    $this
      ->assertEqual($config['required'], FALSE, 'Required defaults to false.');
    $this
      ->assertIdentical($config['label'], $this->instance_definition['field_name'], 'Label defaults to field name.');
    $this
      ->assertIdentical($config['description'], '', 'Description defaults to empty string.');

    // Check that default settings are set.
    $this
      ->assertEqual($config['settings'], $field_type['instance_settings'], 'Default instance settings have been written.');

    // Guarantee that the field/bundle combination is unique.
    try {
      field_create_instance($this->instance_definition);
      $this
        ->fail(t('Cannot create two instances with the same field / bundle combination.'));
    } catch (FieldException $e) {
      $this
        ->pass(t('Cannot create two instances with the same field / bundle combination.'));
    }

    // Check that the specified field exists.
    try {
      $this->instance_definition['field_name'] = $this
        ->randomName();
      field_create_instance($this->instance_definition);
      $this
        ->fail(t('Cannot create an instance of a non-existing field.'));
    } catch (FieldException $e) {
      $this
        ->pass(t('Cannot create an instance of a non-existing field.'));
    }

    // Create a field restricted to a specific entity type.
    $field_restricted = array(
      'field_name' => drupal_strtolower($this
        ->randomName()),
      'type' => 'test_field',
      'entity_types' => array(
        'test_cacheable_entity',
      ),
    );
    field_create_field($field_restricted);

    // Check that an instance can be added to an entity type allowed
    // by the field.
    try {
      $instance = $this->instance_definition;
      $instance['field_name'] = $field_restricted['field_name'];
      $instance['entity_type'] = 'test_cacheable_entity';
      field_create_instance($instance);
      $this
        ->pass(t('Can create an instance on an entity type allowed by the field.'));
    } catch (FieldException $e) {
      $this
        ->fail(t('Can create an instance on an entity type allowed by the field.'));
    }

    // Check that an instance cannot be added to an entity type
    // forbidden by the field.
    try {
      $instance = $this->instance_definition;
      $instance['field_name'] = $field_restricted['field_name'];
      field_create_instance($instance);
      $this
        ->fail(t('Cannot create an instance on an entity type forbidden by the field.'));
    } catch (FieldException $e) {
      $this
        ->pass(t('Cannot create an instance on an entity type forbidden by the field.'));
    }

    // TODO: test other failures.
  }

  /**
   * Test reading back an instance definition.
   */
  function testReadFieldInstance() {
    field_create_instance($this->instance_definition);

    // Read the instance back.
    $instance = field_read_instance('test_entity', $this->instance_definition['field_name'], $this->instance_definition['bundle']);
    $this
      ->assertTrue($this->instance_definition['field_name'] == $instance['field_name'], 'The field was properly read.');
    $this
      ->assertTrue($this->instance_definition['entity_type'] == $instance['entity_type'], 'The field was properly read.');
    $this
      ->assertTrue($this->instance_definition['bundle'] == $instance['bundle'], 'The field was properly read.');
  }

  /**
   * Test the update of a field instance.
   */
  function testUpdateFieldInstance() {
    field_create_instance($this->instance_definition);

    // Check that basic changes are saved.
    $instance = field_read_instance('test_entity', $this->instance_definition['field_name'], $this->instance_definition['bundle']);
    $instance['required'] = !$instance['required'];
    $instance['label'] = $this
      ->randomName();
    $instance['description'] = $this
      ->randomName();
    $instance['settings']['test_instance_setting'] = $this
      ->randomName();
    field_update_instance($instance);
    $instance_new = field_read_instance('test_entity', $this->instance_definition['field_name'], $this->instance_definition['bundle']);
    $this
      ->assertEqual($instance['required'], $instance_new['required'], '"required" change is saved');
    $this
      ->assertEqual($instance['label'], $instance_new['label'], '"label" change is saved');
    $this
      ->assertEqual($instance['description'], $instance_new['description'], '"description" change is saved');

    // TODO: test failures.
  }

  /**
   * Test the deletion of a field instance.
   */
  function testDeleteFieldInstance() {

    // TODO: Test deletion of the data stored in the field also.
    // Need to check that data for a 'deleted' field / instance doesn't get loaded
    // Need to check data marked deleted is cleaned on cron (not implemented yet...)
    // Create two instances for the same field so we can test that only one
    // is deleted.
    field_create_instance($this->instance_definition);
    $this->another_instance_definition = $this->instance_definition;
    $this->another_instance_definition['bundle'] .= '_another_bundle';
    $instance = field_create_instance($this->another_instance_definition);

    // Test that the first instance is not deleted, and then delete it.
    $instance = field_read_instance('test_entity', $this->instance_definition['field_name'], $this->instance_definition['bundle'], array(
      'include_deleted' => TRUE,
    ));
    $this
      ->assertTrue(!empty($instance) && empty($instance['deleted']), 'A new field instance is not marked for deletion.');
    field_delete_instance($instance);

    // Make sure the instance is marked as deleted when the instance is
    // specifically loaded.
    $instance = field_read_instance('test_entity', $this->instance_definition['field_name'], $this->instance_definition['bundle'], array(
      'include_deleted' => TRUE,
    ));
    $this
      ->assertTrue(!empty($instance['deleted']), 'A deleted field instance is marked for deletion.');

    // Try to load the instance normally and make sure it does not show up.
    $instance = field_read_instance('test_entity', $this->instance_definition['field_name'], $this->instance_definition['bundle']);
    $this
      ->assertTrue(empty($instance), 'A deleted field instance is not loaded by default.');

    // Make sure the other field instance is not deleted.
    $another_instance = field_read_instance('test_entity', $this->another_instance_definition['field_name'], $this->another_instance_definition['bundle']);
    $this
      ->assertTrue(!empty($another_instance) && empty($another_instance['deleted']), 'A non-deleted field instance is not marked for deletion.');

    // Make sure the field is deleted when its last instance is deleted.
    field_delete_instance($another_instance);
    $deleted_fields = \Drupal::state()
      ->get('field.field.deleted');
    $this
      ->assertTrue(isset($deleted_fields[$another_instance['field_id']]), 'A deleted field is marked for deletion.');
    $field = field_read_field($another_instance['field_name']);
    $this
      ->assertFalse($field, 'The field marked to be deleted is not found anymore in the configuration.');
  }

}