node.test in Migrate 6.2

File

tests/plugins/destinations/node.test

<?php

/**
 * Test node migration.
 */
class MigrateNodeUnitTest extends DrupalWebTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Node migration',
      'description' => 'Test migration of node data',
      'group' => 'Migrate',
    );
  }
  function setUp() {
    parent::setUp('autoload', 'dbtng', 'taxonomy', 'content', 'text', 'number', 'date_api', 'date_timezone', 'date', 'filefield', 'imagefield', 'migrate', 'migrate_extras', 'migrate_example');

    // Make sure the migrations are registered.
    migrate_get_module_apis();

    // Create and login user
    $migrate_user = $this
      ->drupalCreateUser(array(
      'access content',
      'administer nodes',
      'create page content',
      'delete any page content',
    ));
    $this
      ->drupalLogin($migrate_user);
  }
  function testNodeImport() {
    $migration = Migration::getInstance('WineVariety');
    $result = $migration
      ->processImport();
    $this
      ->assertEqual($result, Migration::RESULT_COMPLETED, t('Variety term import returned RESULT_COMPLETED'));
    $migration = Migration::getInstance('WineRegion');
    $result = $migration
      ->processImport();
    $this
      ->assertEqual($result, Migration::RESULT_COMPLETED, t('Region term import returned RESULT_COMPLETED'));
    $migration = Migration::getInstance('WineBestWith');
    $result = $migration
      ->processImport();
    $this
      ->assertEqual($result, Migration::RESULT_COMPLETED, t('"Best With" term import returned RESULT_COMPLETED'));
    $migration = Migration::getInstance('WineRole');
    $result = $migration
      ->processImport();
    $this
      ->assertEqual($result, Migration::RESULT_COMPLETED, t('Role import returned RESULT_COMPLETED'));
    $migration = Migration::getInstance('WineUser');
    $result = $migration
      ->processImport();
    $this
      ->assertEqual($result, Migration::RESULT_COMPLETED, t('User import returned RESULT_COMPLETED'));
    $migration = Migration::getInstance('WineProducer');
    $result = $migration
      ->processImport();
    $this
      ->assertEqual($result, Migration::RESULT_COMPLETED, t('Producer node import returned RESULT_COMPLETED'));
    $migration = Migration::getInstance('WineWine');
    $result = $migration
      ->processImport();
    $this
      ->assertEqual($result, Migration::RESULT_COMPLETED, t('Wine node import returned RESULT_COMPLETED'));

    // Gather wine and producer nodes, and their corresponding input data
    $nids = db_select('node', 'n')
      ->fields('n', array(
      'nid',
    ))
      ->condition('type', 'migrate_example_producer')
      ->execute()
      ->fetchCol();
    $producer_nodes = array();
    foreach ($nids as $nid) {
      $node = node_load($nid);
      $producer_nodes[$node->title] = $node;
    }
    $query = db_select('migrate_example_wine_producer', 'p')
      ->fields('p', array(
      'producerid',
      'name',
      'body',
      'excerpt',
      'accountid',
    ));

    // Region term is singletons, handled straighforwardly
    $query
      ->leftJoin('migrate_example_wine_category_producer', 'reg', "p.producerid = reg.producerid");
    $query
      ->addField('reg', 'categoryid', 'region');
    $result = $query
      ->execute();
    $producer_rows = array();
    foreach ($result as $row) {
      $producer_rows[$row->name] = $row;
    }
    $this
      ->assertEqual(count($producer_nodes), count($producer_rows), t('Counts of producer nodes and input rows match'));
    $nids = db_select('node', 'n')
      ->fields('n', array(
      'nid',
    ))
      ->condition('type', 'migrate_example_wine')
      ->execute()
      ->fetchCol();
    $wine_nodes = array();
    foreach ($nids as $nid) {
      $node = node_load($nid);
      $wine_nodes[$node->title] = $node;
    }
    $query = db_select('migrate_example_wine', 'w')
      ->fields('w', array(
      'wineid',
      'name',
      'body',
      'excerpt',
      'accountid',
      'posted',
      'last_changed',
      'variety',
      'region',
      'rating',
    ));
    $query
      ->leftJoin('migrate_example_wine_category_wine', 'cwbw', "w.wineid = cwbw.wineid");
    $query
      ->leftJoin('migrate_example_wine_categories', 'bw', "cwbw.categoryid = bw.categoryid AND bw.type = 'best_with'");

    // Gives a single comma-separated list of related terms
    $query
      ->groupBy('cwbw.wineid');
    $query
      ->addExpression('GROUP_CONCAT(bw.categoryid)', 'best_with');
    $result = $query
      ->execute();
    $wine_rows = array();
    foreach ($result as $row) {
      $wine_rows[$row->name] = $row;
    }
    $this
      ->assertEqual(count($wine_nodes), count($wine_rows), t('Counts of wine nodes and input rows match'));

    // Test each base node field
    $producer_node = $producer_nodes['Montes'];
    $producer_row = $producer_rows['Montes'];
    $wine_node = $wine_nodes['Montes Classic Cabernet Sauvignon'];
    $wine_row = $wine_rows['Montes Classic Cabernet Sauvignon'];
    $user_migration = MigrationBase::getInstance('WineUser');
    $mapped_uid = $user_migration
      ->getMap()
      ->lookupDestinationID(array(
      $producer_row->accountid,
    ));
    if (is_array($mapped_uid)) {
      $this
        ->assertEqual($producer_node->uid, reset($mapped_uid), t('uid properly migrated'));
    }
    else {
      $this
        ->error(t('Account ID !id not migrated', array(
        '!id' => $producer_row->accountid,
      )));
    }
    $this
      ->assertEqual($wine_node->created, $wine_row->posted, t('created properly migrated'));
    $this
      ->assertEqual($wine_node->changed, $wine_row->last_changed, t('changed properly migrated'));
    $this
      ->assertEqual($wine_node->body, 'REVIEW: ' . drupal_strtoupper($wine_row->body), t('body properly migrated'));
    $this
      ->assertEqual($wine_node->teaser, $wine_row->excerpt, t('teaser properly migrated'));

    // Taxonomy terms - single and multiple
    $variety_migration = MigrationBase::getInstance('WineVariety');
    $mapped_tid = $variety_migration
      ->getMap()
      ->lookupDestinationID(array(
      $wine_row->variety,
    ));
    if (is_array($mapped_tid)) {
      $this
        ->assertNotNull($wine_node->taxonomy[reset($mapped_tid)], t('Single taxonomy_term_reference properly migrated'));
    }
    else {
      $this
        ->error(t('Variety !var not migrated', array(
        '!var' => $wine_row->variety,
      )));
    }
    $best_with_migration = MigrationBase::getInstance('WineBestWith');
    $source_ids = explode(',', $wine_row->best_with);
    $mapped_tids = array();
    foreach ($source_ids as $source_id) {
      $tid = $best_with_migration
        ->getMap()
        ->lookupDestinationID(array(
        $source_id,
      ));
      if ($tid) {
        $mapped_tids[reset($tid)] = reset($tid);
      }
    }

    /*    $this->assertEqual(count($best_with), count($mapped_tids),
          t('Counts of Best With match'));*/
    foreach ($mapped_tids as $tid) {
      $this
        ->assertNotNull($wine_node->taxonomy[$tid], t('Multiple value taxonomy_term_reference properly migrated'));
    }

    // Test Field API fields of all types
    $this
      ->assertEqual($wine_node->field_migrate_example_wine_ratin[0]['value'], $wine_row->rating, t('Decimal field (rating) matches'));

    // Test the vintages field (demonstrating prepareRow() works) - we know
    // the valid vintages for this node are 2006 and 2007
    $expected = array(
      array(
        'value' => 2006,
      ),
      array(
        'value' => 2007,
      ),
    );
    $this
      ->assertEqual($wine_node->field_migrate_example_top_vintag, $expected, t('Vintages match (prepareRow works)'));

    // Test highwater marks - add new wines, modify an old one, and see what changes
    $fields = array(
      'wineid',
      'name',
      'body',
      'excerpt',
      'accountid',
      'posted',
      'last_changed',
      'variety',
      'region',
      'rating',
    );
    $query = db_insert('migrate_example_wine')
      ->fields($fields);
    $data = array(
      // Timestamps 1284008523, 1284120550
      array(
        3,
        'Schloss Muhlenhof Dornfelder',
        'Juicy black & red berry fruits',
        'Pretty good',
        9,
        strtotime('2010-09-09 01:02:03'),
        strtotime('2010-09-10 08:09:10'),
        25,
        17,
        95,
      ),
      // Timestamps 1286122209, 1286122209
      array(
        4,
        'Gachot-Monot Bourgogne Rge 06',
        'Funky',
        'Pair with white sauced dishes',
        3,
        strtotime('2010-10-03 12:10:09'),
        strtotime('2010-10-03 12:10:09'),
        26,
        2,
        85,
      ),
    );
    foreach ($data as $row) {
      $query
        ->values(array_combine($fields, $row));
    }
    $query
      ->execute();
    db_update('migrate_example_wine')
      ->fields(array(
      'body' => 'Not so much berry character',
      // Timestamp 1285058521
      'last_changed' => strtotime('2010-10-21 04:42:01'),
    ))
      ->condition('wineid', 2)
      ->execute();
    $migration = Migration::getInstance('WineWine');
    $result = $migration
      ->processImport();
    $this
      ->assertEqual($result, Migration::RESULT_COMPLETED, t('Wine node import returned RESULT_COMPLETED'));
    $count = db_select('node', 'n')
      ->fields('n', array(
      'nid',
    ))
      ->condition('n.type', 'migrate_example_wine')
      ->countQuery()
      ->execute()
      ->fetchField();
    if (!$this
      ->assertEqual($count, 4, t('Now 4 wine nodes exist'))) {
      $this
        ->error(t('There are now !count nodes', array(
        '!count' => $count,
      )));
    }
    $nid = db_select('node', 'n')
      ->fields('n', array(
      'nid',
    ))
      ->condition('n.title', 'Archeo Ruggero di Tasso Nero d\'Avola')
      ->execute()
      ->fetchField();
    $node = node_load($nid, NULL, TRUE);
    $body = $node->body;
    if (!$this
      ->assertEqual($body, 'REVIEW: NOT SO MUCH BERRY CHARACTER', t('Body updated'))) {
      $this
        ->error(t('Actual body !body', array(
        '!body' => $body,
      )));
    }

    // Test rollback
    $result = $migration
      ->processRollback(array(
      'force' => TRUE,
    ));
    $this
      ->assertEqual($result, Migration::RESULT_COMPLETED, t('Wine node rollback returned RESULT_COMPLETED'));
    $count = db_select('node', 'n')
      ->fields('n', array(
      'nid',
    ))
      ->condition('type', 'migrate_example_wine')
      ->countQuery()
      ->execute()
      ->fetchField();
    $this
      ->assertEqual($count, 0, t('All nodes deleted'));
    $count = db_select('migrate_map_winewine', 'map')
      ->fields('map', array(
      'sourceid1',
    ))
      ->countQuery()
      ->execute()
      ->fetchField();
    $this
      ->assertEqual($count, 0, t('Map cleared'));
    $count = db_select('migrate_message_winewine', 'msg')
      ->fields('msg', array(
      'sourceid1',
    ))
      ->countQuery()
      ->execute()
      ->fetchField();
    $this
      ->assertEqual($count, 0, t('Messages cleared'));

    // Now test highwater with unjoined map table
    $migration
      ->getSource()
      ->setMapJoinable(FALSE);
    $result = $migration
      ->processImport(array(
      'limit' => array(
        'value' => 2,
        'unit' => 'items',
      ),
    ));
    $query = db_update('migrate_example_wine')
      ->fields(array(
      'body' => 'Very berry',
      // Timestamp 1286008921
      'last_changed' => strtotime('2011-10-02 04:42:01'),
    ))
      ->condition('wineid', 1)
      ->execute();
    $result = $migration
      ->processImport();
    $this
      ->assertEqual($result, Migration::RESULT_COMPLETED, t('Wine node import returned RESULT_COMPLETED'));
    $count = db_select('node', 'n')
      ->fields('n', array(
      'nid',
    ))
      ->condition('type', 'migrate_example_wine')
      ->countQuery()
      ->execute()
      ->fetchField();
    if (!$this
      ->assertEqual($count, 4, t('Now 4 wine nodes exist'))) {
      $this
        ->error(t('There are now !count nodes', array(
        '!count' => count($rawnodes),
      )));
    }
    $nid = db_select('node', 'n')
      ->fields('n', array(
      'nid',
    ))
      ->condition('n.title', 'Montes Classic Cabernet Sauvignon')
      ->execute()
      ->fetchField();
    $node = node_load($nid, NULL, TRUE);
    $body = $node->body;
    if (!$this
      ->assertEqual($body, 'REVIEW: VERY BERRY', t('Body updated'))) {
      $this
        ->error(t('Actual body !body', array(
        '!body' => $body,
      )));
    }

    // Test itemlimit (joined map table)
    $result = $migration
      ->processRollback(array(
      'force' => TRUE,
    ));
    $migration
      ->getSource()
      ->setMapJoinable(TRUE);
    $result = $migration
      ->processImport(array(
      'limit' => array(
        'value' => 1,
        'unit' => 'item',
      ),
    ));
    $this
      ->assertEqual($result, Migration::RESULT_COMPLETED, t('Wine node import with itemlimit returned RESULT_COMPLETED'));
    $titles = db_select('node', 'n')
      ->fields('n', array(
      'title',
    ))
      ->condition('type', 'migrate_example_wine')
      ->execute()
      ->fetchCol();
    if (!$this
      ->assertEqual(count($titles), 1, t('One node imported'))) {
      $this
        ->error(t('Actual nodes imported: !count', array(
        '!count' => count($titles),
      )));
    }

    // Test idlist (joined map table)
    $result = $migration
      ->processRollback(array(
      'force' => TRUE,
    ));
    $result = $migration
      ->processImport(array(
      'idlist' => 2,
    ));
    $this
      ->assertEqual($result, Migration::RESULT_COMPLETED, t('Wine node import with idlist returned RESULT_COMPLETED'));
    $titles = db_select('node', 'n')
      ->fields('n', array(
      'title',
    ))
      ->condition('type', 'migrate_example_wine')
      ->execute()
      ->fetchCol();
    $this
      ->assertEqual(count($titles), 1, t('One node imported'));
    $this
      ->assertEqual($titles[0], 'Archeo Ruggero di Tasso Nero d\'Avola', t('Single specified node imported'));

    // Test itemlimit (unjoined map table)
    $result = $migration
      ->processRollback(array(
      'force' => TRUE,
    ));
    $migration
      ->getSource()
      ->setMapJoinable(FALSE);
    $result = $migration
      ->processImport(array(
      'limit' => array(
        'value' => 1,
        'unit' => 'item',
      ),
    ));
    $this
      ->assertEqual($result, Migration::RESULT_COMPLETED, t('Wine node import with itemlimit returned RESULT_COMPLETED'));
    $titles = db_select('node', 'n')
      ->fields('n', array(
      'title',
    ))
      ->condition('type', 'migrate_example_wine')
      ->execute()
      ->fetchCol();
    if (!$this
      ->assertEqual(count($titles), 1, t('One node imported'))) {
      $this
        ->error(t('Actual nodes imported: !count', array(
        '!count' => count($titles),
      )));
    }

    // Test idlist (unjoined map table)
    $result = $migration
      ->processRollback(array(
      'force' => TRUE,
    ));
    $result = $migration
      ->processImport(array(
      'idlist' => 2,
    ));
    $this
      ->assertEqual($result, Migration::RESULT_COMPLETED, t('Wine node import with idlist returned RESULT_COMPLETED'));
    $titles = db_select('node', 'n')
      ->fields('n', array(
      'title',
    ))
      ->condition('type', 'migrate_example_wine')
      ->execute()
      ->fetchCol();
    $this
      ->assertEqual(count($titles), 1, t('One node imported'));
    $this
      ->assertEqual($titles[0], 'Archeo Ruggero di Tasso Nero d\'Avola', t('Single specified node imported'));

    // Test integer highwater marks (http://drupal.org/node/1161612)
    $result = $migration
      ->processRollback(array(
      'force' => TRUE,
    ));
    db_update('migrate_example_wine')
      ->fields(array(
      'last_changed' => 100000000,
    ))
      ->condition('wineid', 1)
      ->execute();
    db_update('migrate_example_wine')
      ->fields(array(
      'last_changed' => 200000000,
    ))
      ->condition('wineid', 2)
      ->execute();
    db_update('migrate_example_wine')
      ->fields(array(
      'last_changed' => 300000000,
    ))
      ->condition('wineid', 3)
      ->execute();
    db_update('migrate_example_wine')
      ->fields(array(
      'last_changed' => 400000000,
    ))
      ->condition('wineid', 4)
      ->execute();
    $result = $migration
      ->processImport();

    // Just a quick check to make sure we got four nodes with the right changed values
    $count = db_result(db_query("SELECT COUNT(nid)\n                       FROM {node} n\n                       INNER JOIN {migrate_map_winewine} map ON n.nid=map.destid1\n                       WHERE n.changed = map.sourceid1*100000000"));
    $this
      ->assertEqual($count, 4, t('Four nodes with updated changed values imported'));

    // We mark two nodes with higher updated values. If these end up being treated
    // as strings in saveHighwater(), the saved highwater mark will end up as
    // 500000000 instead of 1000000000.
    db_update('migrate_example_wine')
      ->fields(array(
      'last_changed' => 1000000000,
    ))
      ->condition('wineid', 2)
      ->execute();
    db_update('migrate_example_wine')
      ->fields(array(
      'last_changed' => 500000000,
    ))
      ->condition('wineid', 3)
      ->execute();
    $result = $migration
      ->processImport();
    $newHighwater = db_select('migrate_status', 'ms')
      ->fields('ms', array(
      'highwater',
    ))
      ->condition('machine_name', 'WineWine')
      ->execute()
      ->fetchField();
    if (!$this
      ->assertEqual($newHighwater, 1000000000, t('Correct highwater mark set'))) {
      $this
        ->error(t('Unexpected highwater mark !highwater', array(
        '!highwater' => $newHighwater,
      )));
    }
  }

}

Classes

Name	Description
MigrateNodeUnitTest	Test node migration.