class FieldInfoTestCase

class FieldInfoTestCase extends FieldTestCase {
    public static function getInfo() {
        return array(
            'name' => 'Field info tests',
            'description' => 'Get information about existing fields, instances and bundles.',
            'group' => 'Field API',
        );
    }
    function setUp() {
        parent::setUp('field_test');
    }
    
    /**
     * Test that field types and field definitions are correcly cached.
     */
    function testFieldInfo() {
        // Test that field_test module's fields, widgets, and formatters show up.
        $field_test_info = field_test_field_info();
        // We need to account for the existence of user_field_info_alter().
        foreach (array_keys($field_test_info) as $name) {
            $field_test_info[$name]['instance_settings']['user_register_form'] = FALSE;
        }
        $info = field_info_field_types();
        foreach ($field_test_info as $t_key => $field_type) {
            foreach ($field_type as $key => $val) {
                $this->assertEqual($info[$t_key][$key], $val, format_string('Field type %t_key key %key is %value', array(
                    '%t_key' => $t_key,
                    '%key' => $key,
                    '%value' => print_r($val, TRUE),
                )));
            }
            $this->assertEqual($info[$t_key]['module'], 'field_test', "Field type field_test module appears");
        }
        $formatter_info = field_test_field_formatter_info();
        $info = field_info_formatter_types();
        foreach ($formatter_info as $f_key => $formatter) {
            foreach ($formatter as $key => $val) {
                $this->assertEqual($info[$f_key][$key], $val, format_string('Formatter type %f_key key %key is %value', array(
                    '%f_key' => $f_key,
                    '%key' => $key,
                    '%value' => print_r($val, TRUE),
                )));
            }
            $this->assertEqual($info[$f_key]['module'], 'field_test', "Formatter type field_test module appears");
        }
        $widget_info = field_test_field_widget_info();
        $info = field_info_widget_types();
        foreach ($widget_info as $w_key => $widget) {
            foreach ($widget as $key => $val) {
                $this->assertEqual($info[$w_key][$key], $val, format_string('Widget type %w_key key %key is %value', array(
                    '%w_key' => $w_key,
                    '%key' => $key,
                    '%value' => print_r($val, TRUE),
                )));
            }
            $this->assertEqual($info[$w_key]['module'], 'field_test', "Widget type field_test module appears");
        }
        $storage_info = field_test_field_storage_info();
        $info = field_info_storage_types();
        foreach ($storage_info as $s_key => $storage) {
            foreach ($storage as $key => $val) {
                $this->assertEqual($info[$s_key][$key], $val, format_string('Storage type %s_key key %key is %value', array(
                    '%s_key' => $s_key,
                    '%key' => $key,
                    '%value' => print_r($val, TRUE),
                )));
            }
            $this->assertEqual($info[$s_key]['module'], 'field_test', "Storage type field_test module appears");
        }
        // Verify that no unexpected instances exist.
        $instances = field_info_instances('test_entity');
        $expected = array(
            'test_bundle' => array(),
        );
        $this->assertIdentical($instances, $expected, format_string("field_info_instances('test_entity') returns %expected.", array(
            '%expected' => var_export($expected, TRUE),
        )));
        $instances = field_info_instances('test_entity', 'test_bundle');
        $this->assertIdentical($instances, array(), "field_info_instances('test_entity', 'test_bundle') returns an empty array.");
        // Create a field, verify it shows up.
        $core_fields = field_info_fields();
        $field = array(
            'field_name' => drupal_strtolower($this->randomName()),
            'type' => 'test_field',
        );
        field_create_field($field);
        $fields = field_info_fields();
        $this->assertEqual(count($fields), count($core_fields) + 1, 'One new field exists');
        $this->assertEqual($fields[$field['field_name']]['field_name'], $field['field_name'], 'info fields contains field name');
        $this->assertEqual($fields[$field['field_name']]['type'], $field['type'], 'info fields contains field type');
        $this->assertEqual($fields[$field['field_name']]['module'], 'field_test', 'info fields contains field module');
        $settings = array(
            'test_field_setting' => 'dummy test string',
        );
        foreach ($settings as $key => $val) {
            $this->assertEqual($fields[$field['field_name']]['settings'][$key], $val, format_string('Field setting %key has correct default value %value', array(
                '%key' => $key,
                '%value' => $val,
            )));
        }
        $this->assertEqual($fields[$field['field_name']]['cardinality'], 1, 'info fields contains cardinality 1');
        $this->assertEqual($fields[$field['field_name']]['active'], 1, 'info fields contains active 1');
        // Create an instance, verify that it shows up
        $instance = array(
            'field_name' => $field['field_name'],
            'entity_type' => 'test_entity',
            'bundle' => 'test_bundle',
            'label' => $this->randomName(),
            'description' => $this->randomName(),
            'weight' => mt_rand(0, 127),
            // test_field has no instance settings
'widget' => array(
                'type' => 'test_field_widget',
                'settings' => array(
                    'test_setting' => 999,
                ),
            ),
        );
        field_create_instance($instance);
        $info = entity_get_info('test_entity');
        $instances = field_info_instances('test_entity', $instance['bundle']);
        $this->assertEqual(count($instances), 1, format_string('One instance shows up in info when attached to a bundle on a @label.', array(
            '@label' => $info['label'],
        )));
        $this->assertTrue($instance < $instances[$instance['field_name']], 'Instance appears in info correctly');
        // Test a valid entity type but an invalid bundle.
        $instances = field_info_instances('test_entity', 'invalid_bundle');
        $this->assertIdentical($instances, array(), "field_info_instances('test_entity', 'invalid_bundle') returns an empty array.");
        // Test invalid entity type and bundle.
        $instances = field_info_instances('invalid_entity', $instance['bundle']);
        $this->assertIdentical($instances, array(), "field_info_instances('invalid_entity', 'test_bundle') returns an empty array.");
        // Test invalid entity type, no bundle provided.
        $instances = field_info_instances('invalid_entity');
        $this->assertIdentical($instances, array(), "field_info_instances('invalid_entity') returns an empty array.");
        // Test with an entity type that has no bundles.
        $instances = field_info_instances('user');
        $expected = array(
            'user' => array(),
        );
        $this->assertIdentical($instances, $expected, format_string("field_info_instances('user') returns %expected.", array(
            '%expected' => var_export($expected, TRUE),
        )));
        $instances = field_info_instances('user', 'user');
        $this->assertIdentical($instances, array(), "field_info_instances('user', 'user') returns an empty array.");
        // Test that querying for invalid entity types does not add entries in the
        // list returned by field_info_instances().
        field_info_cache_clear();
        field_info_instances('invalid_entity', 'invalid_bundle');
        // Simulate new request by clearing static caches.
        drupal_static_reset();
        field_info_instances('invalid_entity', 'invalid_bundle');
        $instances = field_info_instances();
        $this->assertFalse(isset($instances['invalid_entity']), 'field_info_instances() does not contain entries for the invalid entity type that was queried before');
    }
    
    /**
     * Test that cached field definitions are ready for current runtime context.
     */
    function testFieldPrepare() {
        $field_definition = array(
            'field_name' => 'field',
            'type' => 'test_field',
        );
        field_create_field($field_definition);
        // Simulate a stored field definition missing a field setting (e.g. a
        // third-party module adding a new field setting has been enabled, and
        // existing fields do not know the setting yet).
        $data = db_query('SELECT data FROM {field_config} WHERE field_name = :field_name', array(
            ':field_name' => $field_definition['field_name'],
        ))->fetchField();
        $data = unserialize($data);
        $data['settings'] = array();
        db_update('field_config')->fields(array(
            'data' => serialize($data),
        ))
            ->condition('field_name', $field_definition['field_name'])
            ->execute();
        field_cache_clear();
        // Read the field back.
        $field = field_info_field($field_definition['field_name']);
        // Check that all expected settings are in place.
        $field_type = field_info_field_types($field_definition['type']);
        $this->assertIdentical($field['settings'], $field_type['settings'], 'All expected default field settings are present.');
    }
    
    /**
     * Test that cached instance definitions are ready for current runtime context.
     */
    function testInstancePrepare() {
        $field_definition = array(
            'field_name' => 'field',
            'type' => 'test_field',
        );
        field_create_field($field_definition);
        $instance_definition = array(
            'field_name' => $field_definition['field_name'],
            'entity_type' => 'test_entity',
            'bundle' => 'test_bundle',
        );
        field_create_instance($instance_definition);
        // Simulate a stored instance definition missing various settings (e.g. a
        // third-party module adding instance, widget or display settings has been
        // enabled, but existing instances do not know the new settings).
        $data = db_query('SELECT data FROM {field_config_instance} WHERE field_name = :field_name AND bundle = :bundle', array(
            ':field_name' => $instance_definition['field_name'],
            ':bundle' => $instance_definition['bundle'],
        ))->fetchField();
        $data = unserialize($data);
        $data['settings'] = array();
        $data['widget']['settings'] = 'unavailable_widget';
        $data['widget']['settings'] = array();
        $data['display']['default']['type'] = 'unavailable_formatter';
        $data['display']['default']['settings'] = array();
        db_update('field_config_instance')->fields(array(
            'data' => serialize($data),
        ))
            ->condition('field_name', $instance_definition['field_name'])
            ->condition('bundle', $instance_definition['bundle'])
            ->execute();
        field_cache_clear();
        // Read the instance back.
        $instance = field_info_instance($instance_definition['entity_type'], $instance_definition['field_name'], $instance_definition['bundle']);
        // Check that all expected instance settings are in place.
        $field_type = field_info_field_types($field_definition['type']);
        $this->assertIdentical($instance['settings'], $field_type['instance_settings'], 'All expected instance settings are present.');
        // Check that the default widget is used and expected settings are in place.
        $this->assertIdentical($instance['widget']['type'], $field_type['default_widget'], 'Unavailable widget replaced with default widget.');
        $widget_type = field_info_widget_types($instance['widget']['type']);
        $this->assertIdentical($instance['widget']['settings'], $widget_type['settings'], 'All expected widget settings are present.');
        // Check that display settings are set for the 'default' mode.
        $display = $instance['display']['default'];
        $this->assertIdentical($display['type'], $field_type['default_formatter'], "Formatter is set for the 'default' view mode");
        $formatter_type = field_info_formatter_types($display['type']);
        $this->assertIdentical($display['settings'], $formatter_type['settings'], "Formatter settings are set for the 'default' view mode");
    }
    
    /**
     * Test that instances on disabled entity types are filtered out.
     */
    function testInstanceDisabledEntityType() {
        // For this test the field type and the entity type must be exposed by
        // different modules.
        $field_definition = array(
            'field_name' => 'field',
            'type' => 'test_field',
        );
        field_create_field($field_definition);
        $instance_definition = array(
            'field_name' => 'field',
            'entity_type' => 'comment',
            'bundle' => 'comment_node_article',
        );
        field_create_instance($instance_definition);
        // Disable coment module. This clears field_info cache.
        module_disable(array(
            'comment',
        ));
        $this->assertNull(field_info_instance('comment', 'field', 'comment_node_article'), 'No instances are returned on disabled entity types.');
    }
    
    /**
     * Test field_info_field_map().
     */
    function testFieldMap() {
        // We will overlook fields created by the 'standard' install profile.
        $exclude = field_info_field_map();
        // Create a new bundle for 'test_entity' entity type.
        field_test_create_bundle('test_bundle_2');
        // Create a couple fields.
        $fields = array(
            array(
                'field_name' => 'field_1',
                'type' => 'test_field',
            ),
            array(
                'field_name' => 'field_2',
                'type' => 'hidden_test_field',
            ),
        );
        foreach ($fields as $field) {
            field_create_field($field);
        }
        // Create a couple instances.
        $instances = array(
            array(
                'field_name' => 'field_1',
                'entity_type' => 'test_entity',
                'bundle' => 'test_bundle',
            ),
            array(
                'field_name' => 'field_1',
                'entity_type' => 'test_entity',
                'bundle' => 'test_bundle_2',
            ),
            array(
                'field_name' => 'field_2',
                'entity_type' => 'test_entity',
                'bundle' => 'test_bundle',
            ),
            array(
                'field_name' => 'field_2',
                'entity_type' => 'test_cacheable_entity',
                'bundle' => 'test_bundle',
            ),
        );
        foreach ($instances as $instance) {
            field_create_instance($instance);
        }
        $expected = array(
            'field_1' => array(
                'type' => 'test_field',
                'bundles' => array(
                    'test_entity' => array(
                        'test_bundle',
                        'test_bundle_2',
                    ),
                ),
            ),
            'field_2' => array(
                'type' => 'hidden_test_field',
                'bundles' => array(
                    'test_entity' => array(
                        'test_bundle',
                    ),
                    'test_cacheable_entity' => array(
                        'test_bundle',
                    ),
                ),
            ),
        );
        // Check that the field map is correct.
        $map = field_info_field_map();
        $map = array_diff_key($map, $exclude);
        $this->assertEqual($map, $expected);
    }
    
    /**
     * Test that the field_info settings convenience functions work.
     */
    function testSettingsInfo() {
        $info = field_test_field_info();
        // We need to account for the existence of user_field_info_alter().
        foreach (array_keys($info) as $name) {
            $info[$name]['instance_settings']['user_register_form'] = FALSE;
        }
        foreach ($info as $type => $data) {
            $this->assertIdentical(field_info_field_settings($type), $data['settings'], format_string("field_info_field_settings returns %type's field settings", array(
                '%type' => $type,
            )));
            $this->assertIdentical(field_info_instance_settings($type), $data['instance_settings'], format_string("field_info_field_settings returns %type's field instance settings", array(
                '%type' => $type,
            )));
        }
        $info = field_test_field_widget_info();
        foreach ($info as $type => $data) {
            $this->assertIdentical(field_info_widget_settings($type), $data['settings'], format_string("field_info_widget_settings returns %type's widget settings", array(
                '%type' => $type,
            )));
        }
        $info = field_test_field_formatter_info();
        foreach ($info as $type => $data) {
            $this->assertIdentical(field_info_formatter_settings($type), $data['settings'], format_string("field_info_formatter_settings returns %type's formatter settings", array(
                '%type' => $type,
            )));
        }
    }
    
    /**
     * Tests that the field info cache can be built correctly.
     */
    function testFieldInfoCache() {
        // Create a test field and ensure it's in the array returned by
        // field_info_fields().
        $field_name = drupal_strtolower($this->randomName());
        $field = array(
            'field_name' => $field_name,
            'type' => 'test_field',
        );
        field_create_field($field);
        $fields = field_info_fields();
        $this->assertTrue(isset($fields[$field_name]), 'The test field is initially found in the array returned by field_info_fields().');
        // Now rebuild the field info cache, and set a variable which will cause
        // the cache to be cleared while it's being rebuilt; see
        // field_test_entity_info(). Ensure the test field is still in the returned
        // array.
        field_info_cache_clear();
        variable_set('field_test_clear_info_cache_in_hook_entity_info', TRUE);
        $fields = field_info_fields();
        $this->assertTrue(isset($fields[$field_name]), 'The test field is found in the array returned by field_info_fields() even if its cache is cleared while being rebuilt.');
    }

}