1 <?php

     2 

     3 /**

     4  * @file

     5  * Tests for image.module.

     6  */

     7 

     8 /**

     9  * TODO: Test the following functions.

    10  *

    11  * image.effects.inc:

    12  *   image_style_generate()

    13  *   image_style_create_derivative()

    14  *

    15  * image.module:

    16  *   image_style_load()

    17  *   image_style_save()

    18  *   image_style_delete()

    19  *   image_style_options()

    20  *   image_effect_definition_load()

    21  *   image_effect_load()

    22  *   image_effect_save()

    23  *   image_effect_delete()

    24  *   image_filter_keyword()

    25  */

    26 

    27 /**

    28  * This class provides methods specifically for testing Image's field handling.

    29  */

    30 class ImageFieldTestCase extends DrupalWebTestCase {

    31   protected $admin_user;

    32 

    33   function setUp() {

    34     parent::setUp('image');

    35     $this->admin_user = $this->drupalCreateUser(array('access content', 'access administration pages', 'administer site configuration', 'administer content types', 'administer nodes', 'create article content', 'edit any article content', 'delete any article content', 'administer image styles', 'administer fields'));

    36     $this->drupalLogin($this->admin_user);

    37   }

    38 

    39   /**

    40    * Create a new image field.

    41    *

    42    * @param $name

    43    *   The name of the new field (all lowercase), exclude the "field_" prefix.

    44    * @param $type_name

    45    *   The node type that this field will be added to.

    46    * @param $field_settings

    47    *   A list of field settings that will be added to the defaults.

    48    * @param $instance_settings

    49    *   A list of instance settings that will be added to the instance defaults.

    50    * @param $widget_settings

    51    *   A list of widget settings that will be added to the widget defaults.

    52    */

    53   function createImageField($name, $type_name, $field_settings = array(), $instance_settings = array(), $widget_settings = array()) {

    54     $field = array(

    55       'field_name' => $name,

    56       'type' => 'image',

    57       'settings' => array(),

    58       'cardinality' => !empty($field_settings['cardinality']) ? $field_settings['cardinality'] : 1,

    59     );

    60     $field['settings'] = array_merge($field['settings'], $field_settings);

    61     field_create_field($field);

    62 

    63     $instance = array(

    64       'field_name' => $field['field_name'],

    65       'entity_type' => 'node',

    66       'label' => $name,

    67       'bundle' => $type_name,

    68       'required' => !empty($instance_settings['required']),

    69       'settings' => array(),

    70       'widget' => array(

    71         'type' => 'image_image',

    72         'settings' => array(),

    73       ),

    74     );

    75     $instance['settings'] = array_merge($instance['settings'], $instance_settings);

    76     $instance['widget']['settings'] = array_merge($instance['widget']['settings'], $widget_settings);

    77     return field_create_instance($instance);

    78   }

    79 

    80   /**

    81    * Create a random style.

    82    *

    83    * @return array

    84    *  A list containing the details of the generated image style.

    85    */

    86   function createRandomStyle() {

    87     $style_name = strtolower($this->randomName(10));

    88     $style_label = $this->randomString();

    89     image_style_save(array('name' => $style_name, 'label' => $style_label));

    90     $style_path = 'admin/config/media/image-styles/edit/' . $style_name;

    91     return array(

    92       'name' => $style_name,

    93       'label' => $style_label,

    94       'path' => $style_path,

    95     );

    96   }

    97 

    98   /**

    99    * Upload an image to a node.

   100    *

   101    * @param $image

   102    *   A file object representing the image to upload.

   103    * @param $field_name

   104    *   Name of the image field the image should be attached to.

   105    * @param $type

   106    *   The type of node to create.

   107    */

   108   function uploadNodeImage($image, $field_name, $type) {

   109     $edit = array(

   110       'title' => $this->randomName(),

   111     );

   112     $edit['files[' . $field_name . '_' . LANGUAGE_NONE . '_0]'] = drupal_realpath($image->uri);

   113     $this->drupalPost('node/add/' . $type, $edit, t('Save'));

   114 

   115     // Retrieve ID of the newly created node from the current URL.

   116     $matches = array();

   117     preg_match('/node\/([0-9]+)/', $this->getUrl(), $matches);

   118     return isset($matches[1]) ? $matches[1] : FALSE;

   119   }

   120 }

   121 

   122 /**

   123  * Tests the functions for generating paths and URLs for image styles.

   124  */

   125 class ImageStylesPathAndUrlTestCase extends DrupalWebTestCase {

   126   protected $style_name;

   127   protected $image_info;

   128   protected $image_filepath;

   129 

   130   public static function getInfo() {

   131     return array(

   132       'name' => 'Image styles path and URL functions',

   133       'description' => 'Tests functions for generating paths and URLs to image styles.',

   134       'group' => 'Image',

   135     );

   136   }

   137 

   138   function setUp() {

   139     parent::setUp('image_module_test');

   140 

   141     $this->style_name = 'style_foo';

   142     image_style_save(array('name' => $this->style_name, 'label' => $this->randomString()));

   143   }

   144 

   145   /**

   146    * Test image_style_path().

   147    */

   148   function testImageStylePath() {

   149     $scheme = 'public';

   150     $actual = image_style_path($this->style_name, "$scheme://foo/bar.gif");

   151     $expected = "$scheme://styles/" . $this->style_name . "/$scheme/foo/bar.gif";

   152     $this->assertEqual($actual, $expected, 'Got the path for a file URI.');

   153 

   154     $actual = image_style_path($this->style_name, 'foo/bar.gif');

   155     $expected = "$scheme://styles/" . $this->style_name . "/$scheme/foo/bar.gif";

   156     $this->assertEqual($actual, $expected, 'Got the path for a relative file path.');

   157   }

   158 

   159   /**

   160    * Test image_style_url() with a file using the "public://" scheme.

   161    */

   162   function testImageStyleUrlAndPathPublic() {

   163     $this->_testImageStyleUrlAndPath('public');

   164   }

   165 

   166   /**

   167    * Test image_style_url() with a file using the "private://" scheme.

   168    */

   169   function testImageStyleUrlAndPathPrivate() {

   170     $this->_testImageStyleUrlAndPath('private');

   171   }

   172 

   173   /**

   174    * Test image_style_url() with the "public://" scheme and unclean URLs.

   175    */

   176    function testImageStylUrlAndPathPublicUnclean() {

   177      $this->_testImageStyleUrlAndPath('public', FALSE);

   178    }

   179 

   180   /**

   181    * Test image_style_url() with the "private://" schema and unclean URLs.

   182    */

   183   function testImageStyleUrlAndPathPrivateUnclean() {

   184     $this->_testImageStyleUrlAndPath('private', FALSE);

   185   }

   186 

   187   /**

   188    * Test image_style_url() with a file URL that has an extra slash in it.

   189    */

   190   function testImageStyleUrlExtraSlash() {

   191     $this->_testImageStyleUrlAndPath('public', TRUE, TRUE);

   192   }

   193 

   194   /**

   195    * Test that an invalid source image returns a 404.

   196    */

   197   function testImageStyleUrlForMissingSourceImage() {

   198     $non_existent_uri = 'public://foo.png';

   199     $generated_url = image_style_url($this->style_name, $non_existent_uri);

   200     $this->drupalGet($generated_url);

   201     $this->assertResponse(404, 'Accessing an image style URL with a source image that does not exist provides a 404 error response.');

   202   }

   203 

   204   /**

   205    * Test that we do not pass an array to drupal_add_http_header.

   206    */

   207   function testImageContentTypeHeaders() {

   208     $files = $this->drupalGetTestFiles('image');

   209     $file = array_shift($files);

   210     // Copy the test file to private folder.

   211     $private_file = file_copy($file, 'private://', FILE_EXISTS_RENAME);

   212     // Tell image_module_test module to return the headers we want to test.

   213     variable_set('image_module_test_invalid_headers', $private_file->uri);

   214     // Invoke image_style_deliver so it will try to set headers.

   215     $generated_url = image_style_url($this->style_name, $private_file->uri);

   216     $this->drupalGet($generated_url);

   217     variable_del('image_module_test_invalid_headers');

   218   }

   219 

   220   /**

   221    * Test image_style_url().

   222    */

   223   function _testImageStyleUrlAndPath($scheme, $clean_url = TRUE, $extra_slash = FALSE) {

   224     // Make the default scheme neither "public" nor "private" to verify the

   225     // functions work for other than the default scheme.

   226     variable_set('file_default_scheme', 'temporary');

   227     variable_set('clean_url', $clean_url);

   228 

   229     // Create the directories for the styles.

   230     $directory = $scheme . '://styles/' . $this->style_name;

   231     $status = file_prepare_directory($directory, FILE_CREATE_DIRECTORY);

   232     $this->assertNotIdentical(FALSE, $status, 'Created the directory for the generated images for the test style.');

   233 

   234     // Create a working copy of the file.

   235     $files = $this->drupalGetTestFiles('image');

   236     $file = array_shift($files);

   237     $image_info = image_get_info($file->uri);

   238     $original_uri = file_unmanaged_copy($file->uri, $scheme . '://', FILE_EXISTS_RENAME);

   239     // Let the image_module_test module know about this file, so it can claim

   240     // ownership in hook_file_download().

   241     variable_set('image_module_test_file_download', $original_uri);

   242     $this->assertNotIdentical(FALSE, $original_uri, 'Created the generated image file.');

   243 

   244     // Get the URL of a file that has not been generated and try to create it.

   245     $generated_uri = image_style_path($this->style_name, $original_uri);

   246     $this->assertFalse(file_exists($generated_uri), 'Generated file does not exist.');

   247     $generate_url = image_style_url($this->style_name, $original_uri);

   248 

   249     // Ensure that the tests still pass when the file is generated by accessing

   250     // a poorly constructed (but still valid) file URL that has an extra slash

   251     // in it.

   252     if ($extra_slash) {

   253       $modified_uri = str_replace('://', ':///', $original_uri);

   254       $this->assertNotEqual($original_uri, $modified_uri, 'An extra slash was added to the generated file URI.');

   255       $generate_url = image_style_url($this->style_name, $modified_uri);

   256     }

   257 

   258     if (!$clean_url) {

   259       $this->assertTrue(strpos($generate_url, '?q=') !== FALSE, 'When using non-clean URLS, the system path contains the query string.');

   260     }

   261     // Add some extra chars to the token.

   262     $this->drupalGet(str_replace(IMAGE_DERIVATIVE_TOKEN . '=', IMAGE_DERIVATIVE_TOKEN . '=Zo', $generate_url));

   263     $this->assertResponse(403, 'Image was inaccessible at the URL with an invalid token.');

   264     // Change the parameter name so the token is missing.

   265     $this->drupalGet(str_replace(IMAGE_DERIVATIVE_TOKEN . '=', 'wrongparam=', $generate_url));

   266     $this->assertResponse(403, 'Image was inaccessible at the URL with a missing token.');

   267 

   268     // Check that the generated URL is the same when we pass in a relative path

   269     // rather than a URI. We need to temporarily switch the default scheme to

   270     // match the desired scheme before testing this, then switch it back to the

   271     // "temporary" scheme used throughout this test afterwards.

   272     variable_set('file_default_scheme', $scheme);

   273     $relative_path = file_uri_target($original_uri);

   274     $generate_url_from_relative_path = image_style_url($this->style_name, $relative_path);

   275     $this->assertEqual($generate_url, $generate_url_from_relative_path, 'Generated URL is the same regardless of whether it came from a relative path or a file URI.');

   276     variable_set('file_default_scheme', 'temporary');

   277 

   278     // Fetch the URL that generates the file.

   279     $this->drupalGet($generate_url);

   280     $this->assertResponse(200, 'Image was generated at the URL.');

   281     $this->assertTrue(file_exists($generated_uri), 'Generated file does exist after we accessed it.');

   282     $this->assertRaw(file_get_contents($generated_uri), 'URL returns expected file.');

   283     $generated_image_info = image_get_info($generated_uri);

   284     $this->assertEqual($this->drupalGetHeader('Content-Type'), $generated_image_info['mime_type'], 'Expected Content-Type was reported.');

   285     $this->assertEqual($this->drupalGetHeader('Content-Length'), $generated_image_info['file_size'], 'Expected Content-Length was reported.');

   286     if ($scheme == 'private') {

   287       $this->assertEqual($this->drupalGetHeader('Expires'), 'Sun, 19 Nov 1978 05:00:00 GMT', 'Expires header was sent.');

   288       $this->assertEqual($this->drupalGetHeader('Cache-Control'), 'no-cache, must-revalidate', 'Cache-Control header was set to prevent caching.');

   289       $this->assertEqual($this->drupalGetHeader('X-Image-Owned-By'), 'image_module_test', 'Expected custom header has been added.');

   290 

   291       // Make sure that a second request to the already existing derivate works

   292       // too.

   293       $this->drupalGet($generate_url);

   294       $this->assertResponse(200, 'Image was generated at the URL.');

   295 

   296       // Make sure that access is denied for existing style files if we do not

   297       // have access.

   298       variable_del('image_module_test_file_download');

   299       $this->drupalGet($generate_url);

   300       $this->assertResponse(403, 'Confirmed that access is denied for the private image style.');

   301 

   302       // Repeat this with a different file that we do not have access to and

   303       // make sure that access is denied.

   304       $file_noaccess = array_shift($files);

   305       $original_uri_noaccess = file_unmanaged_copy($file_noaccess->uri, $scheme . '://', FILE_EXISTS_RENAME);

   306       $generated_uri_noaccess = $scheme . '://styles/' . $this->style_name . '/' . $scheme . '/'. drupal_basename($original_uri_noaccess);

   307       $this->assertFalse(file_exists($generated_uri_noaccess), 'Generated file does not exist.');

   308       $generate_url_noaccess = image_style_url($this->style_name, $original_uri_noaccess);

   309 

   310       $this->drupalGet($generate_url_noaccess);

   311       $this->assertResponse(403, 'Confirmed that access is denied for the private image style.');

   312       // Verify that images are not appended to the response. Currently this test only uses PNG images.

   313       if (strpos($generate_url, '.png') === FALSE ) {

   314         $this->fail('Confirming that private image styles are not appended require PNG file.');

   315       }

   316       else {

   317         // Check for PNG-Signature (cf. http://www.libpng.org/pub/png/book/chapter08.html#png.ch08.div.2) in the

   318         // response body.

   319         $this->assertNoRaw( chr(137) . chr(80) . chr(78) . chr(71) . chr(13) . chr(10) . chr(26) . chr(10), 'No PNG signature found in the response body.');

   320       }

   321     }

   322     elseif ($clean_url) {

   323       // Add some extra chars to the token.

   324       $this->drupalGet(str_replace(IMAGE_DERIVATIVE_TOKEN . '=', IMAGE_DERIVATIVE_TOKEN . '=Zo', $generate_url));

   325       $this->assertResponse(200, 'Existing image was accessible at the URL with an invalid token.');

   326     }

   327 

   328     // Allow insecure image derivatives to be created for the remainder of this

   329     // test.

   330     variable_set('image_allow_insecure_derivatives', TRUE);

   331 

   332     // Create another working copy of the file.

   333     $files = $this->drupalGetTestFiles('image');

   334     $file = array_shift($files);

   335     $image_info = image_get_info($file->uri);

   336     $original_uri = file_unmanaged_copy($file->uri, $scheme . '://', FILE_EXISTS_RENAME);

   337     // Let the image_module_test module know about this file, so it can claim

   338     // ownership in hook_file_download().

   339     variable_set('image_module_test_file_download', $original_uri);

   340 

   341     // Get the URL of a file that has not been generated and try to create it.

   342     $generated_uri = image_style_path($this->style_name, $original_uri);

   343     $this->assertFalse(file_exists($generated_uri), 'Generated file does not exist.');

   344     $generate_url = image_style_url($this->style_name, $original_uri);

   345 

   346     // Check that the image is accessible even without the security token.

   347     $this->drupalGet(str_replace(IMAGE_DERIVATIVE_TOKEN . '=', 'wrongparam=', $generate_url));

   348     $this->assertResponse(200, 'Image was accessible at the URL with a missing token.');

   349 

   350     // Check that a security token is still required when generating a second

   351     // image derivative using the first one as a source.

   352     $nested_uri = image_style_path($this->style_name, $generated_uri);

   353     $nested_url = image_style_url($this->style_name, $generated_uri);

   354     $nested_url_with_wrong_token = str_replace(IMAGE_DERIVATIVE_TOKEN . '=', 'wrongparam=', $nested_url);

   355     $this->drupalGet($nested_url_with_wrong_token);

   356     $this->assertResponse(403, 'Image generated from an earlier derivative was inaccessible at the URL with a missing token.');

   357     // Check that this restriction cannot be bypassed by adding extra slashes

   358     // to the URL.

   359     $this->drupalGet(substr_replace($nested_url_with_wrong_token, '//styles/', strrpos($nested_url_with_wrong_token, '/styles/'), strlen('/styles/')));

   360     $this->assertResponse(403, 'Image generated from an earlier derivative was inaccessible at the URL with a missing token, even with an extra forward slash in the URL.');

   361     $this->drupalGet(substr_replace($nested_url_with_wrong_token, '/\styles/', strrpos($nested_url_with_wrong_token, '/styles/'), strlen('/styles/')));

   362     $this->assertResponse(403, 'Image generated from an earlier derivative was inaccessible at the URL with a missing token, even with an extra backslash in the URL.');

   363     // Make sure the image can still be generated if a correct token is used.

   364     $this->drupalGet($nested_url);

   365     $this->assertResponse(200, 'Image was accessible when a correct token was provided in the URL.');

   366 

   367     // Suppress the security token in the URL, then get the URL of a file. Check

   368     // that the security token is not present in the URL but that the image is

   369     // still accessible.

   370     variable_set('image_suppress_itok_output', TRUE);

   371     $generate_url = image_style_url($this->style_name, $original_uri);

   372     $this->assertIdentical(strpos($generate_url, IMAGE_DERIVATIVE_TOKEN . '='), FALSE, 'The security token does not appear in the image style URL.');

   373     $this->drupalGet($generate_url);

   374     $this->assertResponse(200, 'Image was accessible at the URL with a missing token.');

   375 

   376     // Check that requesting a nonexistent image does not create any new

   377     // directories in the file system.

   378     $directory = $scheme . '://styles/' . $this->style_name . '/' . $scheme . '/' . $this->randomName();

   379     $this->drupalGet(file_create_url($directory . '/' . $this->randomName()));

   380     $this->assertFalse(file_exists($directory), 'New directory was not created in the filesystem when requesting an unauthorized image.');

   381   }

   382 }

   383 

   384 /**

   385  * Use the image_test.module's mock toolkit to ensure that the effects are

   386  * properly passing parameters to the image toolkit.

   387  */

   388 class ImageEffectsUnitTest extends ImageToolkitTestCase {

   389   public static function getInfo() {

   390     return array(

   391       'name' => 'Image effects',

   392       'description' => 'Test that the image effects pass parameters to the toolkit correctly.',

   393       'group' => 'Image',

   394     );

   395   }

   396 

   397   function setUp() {

   398     parent::setUp('image_module_test');

   399     module_load_include('inc', 'image', 'image.effects');

   400   }

   401 

   402   /**

   403    * Test the image_resize_effect() function.

   404    */

   405   function testResizeEffect() {

   406     $this->assertTrue(image_resize_effect($this->image, array('width' => 1, 'height' => 2)), 'Function returned the expected value.');

   407     $this->assertToolkitOperationsCalled(array('resize'));

   408 

   409     // Check the parameters.

   410     $calls = image_test_get_all_calls();

   411     $this->assertEqual($calls['resize'][0][1], 1, 'Width was passed correctly');

   412     $this->assertEqual($calls['resize'][0][2], 2, 'Height was passed correctly');

   413   }

   414 

   415   /**

   416    * Test the image_scale_effect() function.

   417    */

   418   function testScaleEffect() {

   419     // @todo: need to test upscaling.

   420     $this->assertTrue(image_scale_effect($this->image, array('width' => 10, 'height' => 10)), 'Function returned the expected value.');

   421     $this->assertToolkitOperationsCalled(array('resize'));

   422 

   423     // Check the parameters.

   424     $calls = image_test_get_all_calls();

   425     $this->assertEqual($calls['resize'][0][1], 10, 'Width was passed correctly');

   426     $this->assertEqual($calls['resize'][0][2], 5, 'Height was based off aspect ratio and passed correctly');

   427   }

   428 

   429   /**

   430    * Test the image_crop_effect() function.

   431    */

   432   function testCropEffect() {

   433     // @todo should test the keyword offsets.

   434     $this->assertTrue(image_crop_effect($this->image, array('anchor' => 'top-1', 'width' => 3, 'height' => 4)), 'Function returned the expected value.');

   435     $this->assertToolkitOperationsCalled(array('crop'));

   436 

   437     // Check the parameters.

   438     $calls = image_test_get_all_calls();

   439     $this->assertEqual($calls['crop'][0][1], 0, 'X was passed correctly');

   440     $this->assertEqual($calls['crop'][0][2], 1, 'Y was passed correctly');

   441     $this->assertEqual($calls['crop'][0][3], 3, 'Width was passed correctly');

   442     $this->assertEqual($calls['crop'][0][4], 4, 'Height was passed correctly');

   443   }

   444 

   445   /**

   446    * Test the image_scale_and_crop_effect() function.

   447    */

   448   function testScaleAndCropEffect() {

   449     $this->assertTrue(image_scale_and_crop_effect($this->image, array('width' => 5, 'height' => 10)), 'Function returned the expected value.');

   450     $this->assertToolkitOperationsCalled(array('resize', 'crop'));

   451 

   452     // Check the parameters.

   453     $calls = image_test_get_all_calls();

   454     $this->assertEqual($calls['crop'][0][1], 7.5, 'X was computed and passed correctly');

   455     $this->assertEqual($calls['crop'][0][2], 0, 'Y was computed and passed correctly');

   456     $this->assertEqual($calls['crop'][0][3], 5, 'Width was computed and passed correctly');

   457     $this->assertEqual($calls['crop'][0][4], 10, 'Height was computed and passed correctly');

   458   }

   459 

   460   /**

   461    * Test the image_desaturate_effect() function.

   462    */

   463   function testDesaturateEffect() {

   464     $this->assertTrue(image_desaturate_effect($this->image, array()), 'Function returned the expected value.');

   465     $this->assertToolkitOperationsCalled(array('desaturate'));

   466 

   467     // Check the parameters.

   468     $calls = image_test_get_all_calls();

   469     $this->assertEqual(count($calls['desaturate'][0]), 1, 'Only the image was passed.');

   470   }

   471 

   472   /**

   473    * Test the image_rotate_effect() function.

   474    */

   475   function testRotateEffect() {

   476     // @todo: need to test with 'random' => TRUE

   477     $this->assertTrue(image_rotate_effect($this->image, array('degrees' => 90, 'bgcolor' => '#fff')), 'Function returned the expected value.');

   478     $this->assertToolkitOperationsCalled(array('rotate'));

   479 

   480     // Check the parameters.

   481     $calls = image_test_get_all_calls();

   482     $this->assertEqual($calls['rotate'][0][1], 90, 'Degrees were passed correctly');

   483     $this->assertEqual($calls['rotate'][0][2], 0xffffff, 'Background color was passed correctly');

   484   }

   485 

   486   /**

   487    * Test image effect caching.

   488    */

   489   function testImageEffectsCaching() {

   490     $image_effect_definitions_called = &drupal_static('image_module_test_image_effect_info_alter');

   491 

   492     // First call should grab a fresh copy of the data.

   493     $effects = image_effect_definitions();

   494     $this->assertTrue($image_effect_definitions_called === 1, 'image_effect_definitions() generated data.');

   495 

   496     // Second call should come from cache.

   497     drupal_static_reset('image_effect_definitions');

   498     drupal_static_reset('image_module_test_image_effect_info_alter');

   499     $cached_effects = image_effect_definitions();

   500     $this->assertTrue(is_null($image_effect_definitions_called), 'image_effect_definitions() returned data from cache.');

   501 

   502     $this->assertTrue($effects == $cached_effects, 'Cached effects are the same as generated effects.');

   503   }

   504 }

   505 

   506 /**

   507  * Tests the administrative user interface.

   508  */

   509 class ImageAdminUiTestCase extends ImageFieldTestCase {

   510   public static function getInfo() {

   511     return array(

   512       'name' => 'Administrative user interface',

   513       'description' => 'Tests the forms used in the administrative user interface.',

   514       'group' => 'Image',

   515     );

   516   }

   517 

   518   function setUp() {

   519     parent::setUp(array('image'));

   520   }

   521 

   522   /**

   523    * Test if the help text is available on the add effect form.

   524    */

   525   function testAddEffectHelpText() {

   526     // Create a random image style.

   527     $style = $this->createRandomStyle();

   528 

   529     // Open the add effect form and check for the help text.

   530     $this->drupalGet($style['path'] . '/add/image_crop');

   531     $this->assertText(t('Cropping will remove portions of an image to make it the specified dimensions.'), 'The image style effect help text was displayed on the add effect page.');

   532   }

   533 

   534   /**

   535    * Test if the help text is available on the edit effect form.

   536    */

   537   function testEditEffectHelpText() {

   538     // Create a random image style.

   539     $random_style = $this->createRandomStyle();

   540 

   541     // Add the crop effect to the image style.

   542     $edit = array();

   543     $edit['data[width]'] = 20;

   544     $edit['data[height]'] = 20;

   545     $this->drupalPost($random_style['path'] . '/add/image_crop', $edit, t('Add effect'));

   546 

   547     // Open the edit effect form and check for the help text.

   548     drupal_static_reset('image_styles');

   549     $style = image_style_load($random_style['name']);

   550 

   551     foreach ($style['effects'] as $ieid => $effect) {

   552       $this->drupalGet($random_style['path'] . '/effects/' . $ieid);

   553       $this->assertText(t('Cropping will remove portions of an image to make it the specified dimensions.'), 'The image style effect help text was displayed on the edit effect page.');

   554     }

   555   }

   556 }

   557 

   558 /**

   559  * Tests creation, deletion, and editing of image styles and effects.

   560  */

   561 class ImageAdminStylesUnitTest extends ImageFieldTestCase {

   562 

   563   public static function getInfo() {

   564     return array(

   565       'name' => 'Image styles and effects UI configuration',

   566       'description' => 'Tests creation, deletion, and editing of image styles and effects at the UI level.',

   567       'group' => 'Image',

   568     );

   569   }

   570 

   571   /**

   572    * Given an image style, generate an image.

   573    */

   574   function createSampleImage($style) {

   575     static $file_path;

   576 

   577     // First, we need to make sure we have an image in our testing

   578     // file directory. Copy over an image on the first run.

   579     if (!isset($file_path)) {

   580       $files = $this->drupalGetTestFiles('image');

   581       $file = reset($files);

   582       $file_path = file_unmanaged_copy($file->uri);

   583     }

   584 

   585     return image_style_url($style['name'], $file_path) ? $file_path : FALSE;

   586   }

   587 

   588   /**

   589    * Count the number of images currently create for a style.

   590    */

   591   function getImageCount($style) {

   592     return count(file_scan_directory('public://styles/' . $style['name'], '/.*/'));

   593   }

   594 

   595   /**

   596    * Test creating an image style with a numeric name and ensuring it can be

   597    * applied to an image.

   598    */

   599   function testNumericStyleName() {

   600     $style_name = rand();

   601     $style_label = $this->randomString();

   602     $edit = array(

   603       'name' => $style_name,

   604       'label' => $style_label,

   605     );

   606     $this->drupalPost('admin/config/media/image-styles/add', $edit, t('Create new style'));

   607     $this->assertRaw(t('Style %name was created.', array('%name' => $style_label)), 'Image style successfully created.');

   608     $options = image_style_options();

   609     $this->assertTrue(array_key_exists($style_name, $options), format_string('Array key %key exists.', array('%key' => $style_name)));

   610   }

   611 

   612   /**

   613    * General test to add a style, add/remove/edit effects to it, then delete it.

   614    */

   615   function testStyle() {

   616     // Setup a style to be created and effects to add to it.

   617     $style_name = strtolower($this->randomName(10));

   618     $style_label = $this->randomString();

   619     $style_path = 'admin/config/media/image-styles/edit/' . $style_name;

   620     $effect_edits = array(

   621       'image_resize' => array(

   622         'data[width]' => 100,

   623         'data[height]' => 101,

   624       ),

   625       'image_scale' => array(

   626         'data[width]' => 110,

   627         'data[height]' => 111,

   628         'data[upscale]' => 1,

   629       ),

   630       'image_scale_and_crop' => array(

   631         'data[width]' => 120,

   632         'data[height]' => 121,

   633       ),

   634       'image_crop' => array(

   635         'data[width]' => 130,

   636         'data[height]' => 131,

   637         'data[anchor]' => 'center-center',

   638       ),

   639       'image_desaturate' => array(

   640         // No options for desaturate.

   641       ),

   642       'image_rotate' => array(

   643         'data[degrees]' => 5,

   644         'data[random]' => 1,

   645         'data[bgcolor]' => '#FFFF00',

   646       ),

   647     );

   648 

   649     // Add style form.

   650 

   651     $edit = array(

   652       'name' => $style_name,

   653       'label' => $style_label,

   654     );

   655     $this->drupalPost('admin/config/media/image-styles/add', $edit, t('Create new style'));

   656     $this->assertRaw(t('Style %name was created.', array('%name' => $style_label)), 'Image style successfully created.');

   657 

   658     // Add effect form.

   659 

   660     // Add each sample effect to the style.

   661     foreach ($effect_edits as $effect => $edit) {

   662       // Add the effect.

   663       $this->drupalPost($style_path, array('new' => $effect), t('Add'));

   664       if (!empty($edit)) {

   665         $this->drupalPost(NULL, $edit, t('Add effect'));

   666       }

   667     }

   668 

   669     // Edit effect form.

   670 

   671     // Revisit each form to make sure the effect was saved.

   672     drupal_static_reset('image_styles');

   673     $style = image_style_load($style_name);

   674 

   675     foreach ($style['effects'] as $ieid => $effect) {

   676       $this->drupalGet($style_path . '/effects/' . $ieid);

   677       foreach ($effect_edits[$effect['name']] as $field => $value) {

   678         $this->assertFieldByName($field, $value, format_string('The %field field in the %effect effect has the correct value of %value.', array('%field' => $field, '%effect' => $effect['name'], '%value' => $value)));

   679       }

   680     }

   681 

   682     // Image style overview form (ordering and renaming).

   683 

   684     // Confirm the order of effects is maintained according to the order we

   685     // added the fields.

   686     $effect_edits_order = array_keys($effect_edits);

   687     $effects_order = array_values($style['effects']);

   688     $order_correct = TRUE;

   689     foreach ($effects_order as $index => $effect) {

   690       if ($effect_edits_order[$index] != $effect['name']) {

   691         $order_correct = FALSE;

   692       }

   693     }

   694     $this->assertTrue($order_correct, 'The order of the effects is correctly set by default.');

   695 

   696     // Test the style overview form.

   697     // Change the name of the style and adjust the weights of effects.

   698     $style_name = strtolower($this->randomName(10));

   699     $style_label = $this->randomString();

   700     $weight = count($effect_edits);

   701     $edit = array(

   702       'name' => $style_name,

   703       'label' => $style_label,

   704     );

   705     foreach ($style['effects'] as $ieid => $effect) {

   706       $edit['effects[' . $ieid . '][weight]'] = $weight;

   707       $weight--;

   708     }

   709 

   710     // Create an image to make sure it gets flushed after saving.

   711     $image_path = $this->createSampleImage($style);

   712     $this->assertEqual($this->getImageCount($style), 1, format_string('Image style %style image %file successfully generated.', array('%style' => $style['label'], '%file' => $image_path)));

   713 

   714     $this->drupalPost($style_path, $edit, t('Update style'));

   715 

   716     // Note that after changing the style name, the style path is changed.

   717     $style_path = 'admin/config/media/image-styles/edit/' . $style_name;

   718 

   719     // Check that the URL was updated.

   720     $this->drupalGet($style_path);

   721     $this->assertResponse(200, format_string('Image style %original renamed to %new', array('%original' => $style['label'], '%new' => $style_label)));

   722 

   723     // Check that the image was flushed after updating the style.

   724     // This is especially important when renaming the style. Make sure that

   725     // the old image directory has been deleted.

   726     $this->assertEqual($this->getImageCount($style), 0, format_string('Image style %style was flushed after renaming the style and updating the order of effects.', array('%style' => $style['label'])));

   727 

   728     // Load the style by the new name with the new weights.

   729     drupal_static_reset('image_styles');

   730     $style = image_style_load($style_name, NULL);

   731 

   732     // Confirm the new style order was saved.

   733     $effect_edits_order = array_reverse($effect_edits_order);

   734     $effects_order = array_values($style['effects']);

   735     $order_correct = TRUE;

   736     foreach ($effects_order as $index => $effect) {

   737       if ($effect_edits_order[$index] != $effect['name']) {

   738         $order_correct = FALSE;

   739       }

   740     }

   741     $this->assertTrue($order_correct, 'The order of the effects is correctly set by default.');

   742 

   743     // Image effect deletion form.

   744 

   745     // Create an image to make sure it gets flushed after deleting an effect.

   746     $image_path = $this->createSampleImage($style);

   747     $this->assertEqual($this->getImageCount($style), 1, format_string('Image style %style image %file successfully generated.', array('%style' => $style['label'], '%file' => $image_path)));

   748 

   749     // Test effect deletion form.

   750     $effect = array_pop($style['effects']);

   751     $this->drupalPost($style_path . '/effects/' . $effect['ieid'] . '/delete', array(), t('Delete'));

   752     $this->assertRaw(t('The image effect %name has been deleted.', array('%name' => $effect['label'])), 'Image effect deleted.');

   753 

   754     // Style deletion form.

   755 

   756     // Delete the style.

   757     $this->drupalPost('admin/config/media/image-styles/delete/' . $style_name, array(), t('Delete'));

   758 

   759     // Confirm the style directory has been removed.

   760     $directory = file_default_scheme() . '://styles/' . $style_name;

   761     $this->assertFalse(is_dir($directory), format_string('Image style %style directory removed on style deletion.', array('%style' => $style['label'])));

   762 

   763     drupal_static_reset('image_styles');

   764     $this->assertFalse(image_style_load($style_name), format_string('Image style %style successfully deleted.', array('%style' => $style['label'])));

   765 

   766   }

   767 

   768   /**

   769    * Test to override, edit, then revert a style.

   770    */

   771   function testDefaultStyle() {

   772     // Setup a style to be created and effects to add to it.

   773     $style_name = 'thumbnail';

   774     $style_label = 'Thumbnail (100x100)';

   775     $edit_path = 'admin/config/media/image-styles/edit/' . $style_name;

   776     $delete_path = 'admin/config/media/image-styles/delete/' . $style_name;

   777     $revert_path = 'admin/config/media/image-styles/revert/' . $style_name;

   778 

   779     // Ensure deleting a default is not possible.

   780     $this->drupalGet($delete_path);

   781     $this->assertText(t('Page not found'), 'Default styles may not be deleted.');

   782 

   783     // Ensure that editing a default is not possible (without overriding).

   784     $this->drupalGet($edit_path);

   785     $disabled_field = $this->xpath('//input[@id=:id and @disabled="disabled"]', array(':id' => 'edit-name'));

   786     $this->assertTrue($disabled_field, 'Default styles may not be renamed.');

   787     $this->assertNoField('edit-submit', 'Default styles may not be edited.');

   788     $this->assertNoField('edit-add', 'Default styles may not have new effects added.');

   789 

   790     // Create an image to make sure the default works before overriding.

   791     drupal_static_reset('image_styles');

   792     $style = image_style_load($style_name);

   793     $image_path = $this->createSampleImage($style);

   794     $this->assertEqual($this->getImageCount($style), 1, format_string('Image style %style image %file successfully generated.', array('%style' => $style['name'], '%file' => $image_path)));

   795 

   796     // Verify that effects attached to a default style do not have an ieid key.

   797     foreach ($style['effects'] as $effect) {

   798       $this->assertFalse(isset($effect['ieid']), format_string('The %effect effect does not have an ieid.', array('%effect' => $effect['name'])));

   799     }

   800 

   801     // Override the default.

   802     $this->drupalPost($edit_path, array(), t('Override defaults'));

   803     $this->assertRaw(t('The %style style has been overridden, allowing you to change its settings.', array('%style' => $style_label)), 'Default image style may be overridden.');

   804 

   805     // Add sample effect to the overridden style.

   806     $this->drupalPost($edit_path, array('new' => 'image_desaturate'), t('Add'));

   807     drupal_static_reset('image_styles');

   808     $style = image_style_load($style_name);

   809 

   810     // Verify that effects attached to the style have an ieid now.

   811     foreach ($style['effects'] as $effect) {

   812       $this->assertTrue(isset($effect['ieid']), format_string('The %effect effect has an ieid.', array('%effect' => $effect['name'])));

   813     }

   814 

   815     // The style should now have 2 effect, the original scale provided by core

   816     // and the desaturate effect we added in the override.

   817     $effects = array_values($style['effects']);

   818     $this->assertEqual($effects[0]['name'], 'image_scale', 'The default effect still exists in the overridden style.');

   819     $this->assertEqual($effects[1]['name'], 'image_desaturate', 'The added effect exists in the overridden style.');

   820 

   821     // Check that we are able to rename an overridden style.

   822     $this->drupalGet($edit_path);

   823     $disabled_field = $this->xpath('//input[@id=:id and @disabled="disabled"]', array(':id' => 'edit-name'));

   824     $this->assertFalse($disabled_field, 'Overridden styles may be renamed.');

   825 

   826     // Create an image to ensure the override works properly.

   827     $image_path = $this->createSampleImage($style);

   828     $this->assertEqual($this->getImageCount($style), 1, format_string('Image style %style image %file successfully generated.', array('%style' => $style['label'], '%file' => $image_path)));

   829 

   830     // Revert the image style.

   831     $this->drupalPost($revert_path, array(), t('Revert'));

   832     drupal_static_reset('image_styles');

   833     $style = image_style_load($style_name);

   834 

   835     // The style should now have the single effect for scale.

   836     $effects = array_values($style['effects']);

   837     $this->assertEqual($effects[0]['name'], 'image_scale', 'The default effect still exists in the reverted style.');

   838     $this->assertFalse(array_key_exists(1, $effects), 'The added effect has been removed in the reverted style.');

   839   }

   840 

   841   /**

   842    * Test deleting a style and choosing a replacement style.

   843    */

   844   function testStyleReplacement() {

   845     // Create a new style.

   846     $style_name = strtolower($this->randomName(10));

   847     $style_label = $this->randomString();

   848     image_style_save(array('name' => $style_name, 'label' => $style_label));

   849     $style_path = 'admin/config/media/image-styles/edit/' . $style_name;

   850 

   851     // Create an image field that uses the new style.

   852     $field_name = strtolower($this->randomName(10));

   853     $this->createImageField($field_name, 'article');

   854     $instance = field_info_instance('node', $field_name, 'article');

   855     $instance['display']['default']['type'] = 'image';

   856     $instance['display']['default']['settings']['image_style'] = $style_name;

   857     field_update_instance($instance);

   858 

   859     // Create a new node with an image attached.

   860     $test_image = current($this->drupalGetTestFiles('image'));

   861     $nid = $this->uploadNodeImage($test_image, $field_name, 'article');

   862     $node = node_load($nid);

   863 

   864     // Test that image is displayed using newly created style.

   865     $this->drupalGet('node/' . $nid);

   866     $this->assertRaw(check_plain(image_style_url($style_name, $node->{$field_name}[LANGUAGE_NONE][0]['uri'])), format_string('Image displayed using style @style.', array('@style' => $style_name)));

   867 

   868     // Rename the style and make sure the image field is updated.

   869     $new_style_name = strtolower($this->randomName(10));

   870     $new_style_label = $this->randomString();

   871     $edit = array(

   872       'name' => $new_style_name,

   873       'label' => $new_style_label,

   874     );

   875     $this->drupalPost('admin/config/media/image-styles/edit/' . $style_name, $edit, t('Update style'));

   876     $this->assertText(t('Changes to the style have been saved.'), format_string('Style %name was renamed to %new_name.', array('%name' => $style_name, '%new_name' => $new_style_name)));

   877     $this->drupalGet('node/' . $nid);

   878     $this->assertRaw(check_plain(image_style_url($new_style_name, $node->{$field_name}[LANGUAGE_NONE][0]['uri'])), format_string('Image displayed using style replacement style.'));

   879 

   880     // Delete the style and choose a replacement style.

   881     $edit = array(

   882       'replacement' => 'thumbnail',

   883     );

   884     $this->drupalPost('admin/config/media/image-styles/delete/' . $new_style_name, $edit, t('Delete'));

   885     $message = t('Style %name was deleted.', array('%name' => $new_style_label));

   886     $this->assertRaw($message, $message);

   887 

   888     $this->drupalGet('node/' . $nid);

   889     $this->assertRaw(check_plain(image_style_url('thumbnail', $node->{$field_name}[LANGUAGE_NONE][0]['uri'])), format_string('Image displayed using style replacement style.'));

   890   }

   891 }

   892 

   893 /**

   894  * Test class to check that formatters and display settings are working.

   895  */

   896 class ImageFieldDisplayTestCase extends ImageFieldTestCase {

   897   public static function getInfo() {

   898     return array(

   899       'name' => 'Image field display tests',

   900       'description' => 'Test the display of image fields.',

   901       'group' => 'Image',

   902     );

   903   }

   904 

   905   /**

   906    * Test image formatters on node display for public files.

   907    */

   908   function testImageFieldFormattersPublic() {

   909     $this->_testImageFieldFormatters('public');

   910   }

   911 

   912   /**

   913    * Test image formatters on node display for private files.

   914    */

   915   function testImageFieldFormattersPrivate() {

   916     // Remove access content permission from anonymous users.

   917     user_role_change_permissions(DRUPAL_ANONYMOUS_RID, array('access content' => FALSE));

   918     $this->_testImageFieldFormatters('private');

   919   }

   920 

   921   /**

   922    * Test image formatters on node display.

   923    */

   924   function _testImageFieldFormatters($scheme) {

   925     $field_name = strtolower($this->randomName());

   926     $this->createImageField($field_name, 'article', array('uri_scheme' => $scheme));

   927     // Create a new node with an image attached.

   928     $test_image = current($this->drupalGetTestFiles('image'));

   929     $nid = $this->uploadNodeImage($test_image, $field_name, 'article');

   930     $node = node_load($nid, NULL, TRUE);

   931 

   932     // Test that the default formatter is being used.

   933     $image_uri = $node->{$field_name}[LANGUAGE_NONE][0]['uri'];

   934     $image_info = array(

   935       'path' => $image_uri,

   936       'width' => 40,

   937       'height' => 20,

   938     );

   939     $default_output = theme('image', $image_info);

   940     $this->assertRaw($default_output, 'Default formatter displaying correctly on full node view.');

   941 

   942     // Test the image linked to file formatter.

   943     $instance = field_info_instance('node', $field_name, 'article');

   944     $instance['display']['default']['type'] = 'image';

   945     $instance['display']['default']['settings']['image_link'] = 'file';

   946     field_update_instance($instance);

   947     $default_output = l(theme('image', $image_info), file_create_url($image_uri), array('html' => TRUE));

   948     $this->drupalGet('node/' . $nid);

   949     $this->assertRaw($default_output, 'Image linked to file formatter displaying correctly on full node view.');

   950     // Verify that the image can be downloaded.

   951     $this->assertEqual(file_get_contents($test_image->uri), $this->drupalGet(file_create_url($image_uri)), 'File was downloaded successfully.');

   952     if ($scheme == 'private') {

   953       // Only verify HTTP headers when using private scheme and the headers are

   954       // sent by Drupal.

   955       $this->assertEqual($this->drupalGetHeader('Content-Type'), 'image/png', 'Content-Type header was sent.');

   956       $this->assertEqual($this->drupalGetHeader('Cache-Control'), 'private', 'Cache-Control header was sent.');

   957 

   958       // Log out and try to access the file.

   959       $this->drupalLogout();

   960       $this->drupalGet(file_create_url($image_uri));

   961       $this->assertResponse('403', 'Access denied to original image as anonymous user.');

   962 

   963       // Log in again.

   964       $this->drupalLogin($this->admin_user);

   965     }

   966 

   967     // Test the image linked to content formatter.

   968     $instance['display']['default']['settings']['image_link'] = 'content';

   969     field_update_instance($instance);

   970     $default_output = l(theme('image', $image_info), 'node/' . $nid, array('html' => TRUE, 'attributes' => array('class' => 'active')));

   971     $this->drupalGet('node/' . $nid);

   972     $this->assertRaw($default_output, 'Image linked to content formatter displaying correctly on full node view.');

   973 

   974     // Test the image style 'thumbnail' formatter.

   975     $instance['display']['default']['settings']['image_link'] = '';

   976     $instance['display']['default']['settings']['image_style'] = 'thumbnail';

   977     field_update_instance($instance);

   978     // Ensure the derivative image is generated so we do not have to deal with

   979     // image style callback paths.

   980     $this->drupalGet(image_style_url('thumbnail', $image_uri));

   981     // Need to create the URL again since it will change if clean URLs

   982     // are disabled.

   983     $image_info['path'] = image_style_url('thumbnail', $image_uri);

   984     $image_info['width'] = 100;

   985     $image_info['height'] = 50;

   986     $default_output = theme('image', $image_info);

   987     $this->drupalGet('node/' . $nid);

   988     $this->assertRaw($default_output, 'Image style thumbnail formatter displaying correctly on full node view.');

   989 

   990     if ($scheme == 'private') {

   991       // Log out and try to access the file.

   992       $this->drupalLogout();

   993       $this->drupalGet(image_style_url('thumbnail', $image_uri));

   994       $this->assertResponse('403', 'Access denied to image style thumbnail as anonymous user.');

   995     }

   996   }

   997 

   998   /**

   999    * Tests for image field settings.

  1000    */

  1001   function testImageFieldSettings() {

  1002     $test_image = current($this->drupalGetTestFiles('image'));

  1003     list(, $test_image_extension) = explode('.', $test_image->filename);

  1004     $field_name = strtolower($this->randomName());

  1005     $instance_settings = array(

  1006       'alt_field' => 1,

  1007       'file_extensions' => $test_image_extension,

  1008       'max_filesize' => '50 KB',

  1009       'max_resolution' => '100x100',

  1010       'min_resolution' => '10x10',

  1011       'title_field' => 1,

  1012     );

  1013     $widget_settings = array(

  1014       'preview_image_style' => 'medium',

  1015     );

  1016     $field = $this->createImageField($field_name, 'article', array(), $instance_settings, $widget_settings);

  1017     $field['deleted'] = 0;

  1018     $table = _field_sql_storage_tablename($field);

  1019     $schema = drupal_get_schema($table, TRUE);

  1020     $instance = field_info_instance('node', $field_name, 'article');

  1021 

  1022     $this->drupalGet('node/add/article');

  1023     $this->assertText(t('Files must be less than 50 KB.'), 'Image widget max file size is displayed on article form.');

  1024     $this->assertText(t('Allowed file types: ' . $test_image_extension . '.'), 'Image widget allowed file types displayed on article form.');

  1025     $this->assertText(t('Images must be between 10x10 and 100x100 pixels.'), 'Image widget allowed resolution displayed on article form.');

  1026 

  1027     // We have to create the article first and then edit it because the alt

  1028     // and title fields do not display until the image has been attached.

  1029     $nid = $this->uploadNodeImage($test_image, $field_name, 'article');

  1030     $this->drupalGet('node/' . $nid . '/edit');

  1031     $this->assertFieldByName($field_name . '[' . LANGUAGE_NONE . '][0][alt]', '', 'Alt field displayed on article form.');

  1032     $this->assertFieldByName($field_name . '[' . LANGUAGE_NONE . '][0][title]', '', 'Title field displayed on article form.');

  1033     // Verify that the attached image is being previewed using the 'medium'

  1034     // style.

  1035     $node = node_load($nid, NULL, TRUE);

  1036     $image_info = array(

  1037       'path' => image_style_url('medium', $node->{$field_name}[LANGUAGE_NONE][0]['uri']),

  1038       'width' => 220,

  1039       'height' => 110,

  1040     );

  1041     $default_output = theme('image', $image_info);

  1042     $this->assertRaw($default_output, "Preview image is displayed using 'medium' style.");

  1043 

  1044     // Add alt/title fields to the image and verify that they are displayed.

  1045     $image_info = array(

  1046       'path' => $node->{$field_name}[LANGUAGE_NONE][0]['uri'],

  1047       'alt' => $this->randomName(),

  1048       'title' => $this->randomName(),

  1049       'width' => 40,

  1050       'height' => 20,

  1051     );

  1052     $edit = array(

  1053       $field_name . '[' . LANGUAGE_NONE . '][0][alt]' => $image_info['alt'],

  1054       $field_name . '[' . LANGUAGE_NONE . '][0][title]' => $image_info['title'],

  1055     );

  1056     $this->drupalPost('node/' . $nid . '/edit', $edit, t('Save'));

  1057     $default_output = theme('image', $image_info);

  1058     $this->assertRaw($default_output, 'Image displayed using user supplied alt and title attributes.');

  1059 

  1060     // Verify that alt/title longer than allowed results in a validation error.

  1061     $test_size = 2000;

  1062     $edit = array(

  1063       $field_name . '[' . LANGUAGE_NONE . '][0][alt]' => $this->randomName($test_size),

  1064       $field_name . '[' . LANGUAGE_NONE . '][0][title]' => $this->randomName($test_size),

  1065     );

  1066     $this->drupalPost('node/' . $nid . '/edit', $edit, t('Save'));

  1067     $this->assertRaw(t('Alternate text cannot be longer than %max characters but is currently %length characters long.', array(

  1068       '%max' => $schema['fields'][$field_name .'_alt']['length'],

  1069       '%length' => $test_size,

  1070     )));

  1071     $this->assertRaw(t('Title cannot be longer than %max characters but is currently %length characters long.', array(

  1072       '%max' => $schema['fields'][$field_name .'_title']['length'],

  1073       '%length' => $test_size,

  1074     )));

  1075   }

  1076 

  1077   /**

  1078    * Test passing attributes into the image field formatters.

  1079    */

  1080   function testImageFieldFormatterAttributes() {

  1081     $image = theme('image_formatter', array(

  1082       'item' => array(

  1083         'uri' => 'http://example.com/example.png',

  1084         'attributes' => array(

  1085           'data-image-field-formatter' => 'testFound',

  1086         ),

  1087         'alt' => t('Image field formatter attribute test.'),

  1088         'title' => t('Image field formatter'),

  1089       ),

  1090     ));

  1091     $this->assertTrue(stripos($image, 'testFound') > 0, 'Image field formatters can have attributes.');

  1092   }

  1093 

  1094   /**

  1095    * Test use of a default image with an image field.

  1096    */

  1097   function testImageFieldDefaultImage() {

  1098     // Create a new image field.

  1099     $field_name = strtolower($this->randomName());

  1100     $this->createImageField($field_name, 'article');

  1101 

  1102     // Create a new node, with no images and verify that no images are

  1103     // displayed.

  1104     $node = $this->drupalCreateNode(array('type' => 'article'));

  1105     $this->drupalGet('node/' . $node->nid);

  1106     // Verify that no image is displayed on the page by checking for the class

  1107     // that would be used on the image field.

  1108     $this->assertNoPattern('<div class="(.*?)field-name-' . strtr($field_name, '_', '-') . '(.*?)">', 'No image displayed when no image is attached and no default image specified.');

  1109 

  1110     // Add a default image to the public imagefield instance.

  1111     $images = $this->drupalGetTestFiles('image');

  1112     $edit = array(

  1113       'files[field_settings_default_image]' => drupal_realpath($images[0]->uri),

  1114     );

  1115     $this->drupalPost('admin/structure/types/manage/article/fields/' . $field_name, $edit, t('Save settings'));

  1116     // Clear field info cache so the new default image is detected.

  1117     field_info_cache_clear();

  1118     $field = field_info_field($field_name);

  1119     $image = file_load($field['settings']['default_image']);

  1120     $this->assertTrue($image->status == FILE_STATUS_PERMANENT, 'The default image status is permanent.');

  1121     $default_output = theme('image', array('path' => $image->uri));

  1122     $this->drupalGet('node/' . $node->nid);

  1123     $this->assertRaw($default_output, 'Default image displayed when no user supplied image is present.');

  1124 

  1125     // Create a node with an image attached and ensure that the default image

  1126     // is not displayed.

  1127     $nid = $this->uploadNodeImage($images[1], $field_name, 'article');

  1128     $node = node_load($nid, NULL, TRUE);

  1129     $image_info = array(

  1130       'path' => $node->{$field_name}[LANGUAGE_NONE][0]['uri'],

  1131       'width' => 40,

  1132       'height' => 20,

  1133     );

  1134     $image_output = theme('image', $image_info);

  1135     $this->drupalGet('node/' . $nid);

  1136     $this->assertNoRaw($default_output, 'Default image is not displayed when user supplied image is present.');