bachir/popsu-d7
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

first import

Browse Source
This commit is contained in:
Bachir Soussi Chiadmi
2015-04-08 11:40:19 +02:00
commit 1bc61b12ad
8435 changed files with 1582817 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

157
sites/all/modules/migrate/tests/plugins/destinations/comment.test Normal file
View File

@@ -0,0 +1,157 @@
<?php
/**
* @file
* Tests for the comment destination plugin.
*/
/**
* Test comment migration.
*/
class MigrateCommentUnitTest extends DrupalWebTestCase {
public static function getInfo() {
return array(
'name' => 'Comment migration',
'description' => 'Test migration of comment data',
'group' => 'Migrate',
);
}
function setUp() {
parent::setUp('taxonomy', 'image', 'comment', 'migrate', 'migrate_example');
}
function testCommentImport() {
$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('WineFileCopy');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('File 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'));
$migration = Migration::getInstance('WineComment');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Comment import returned RESULT_COMPLETED'));
$result = db_select('migrate_message_winecomment', 'w')
->fields('w', array('message'))
->execute();
foreach ($result as $row) {
$this->error($row->message);
}
$result = db_select('migrate_example_wine_comment', 'wc')
->fields('wc', array('commentid', 'comment_parent', 'name', 'mail',
'accountid', 'body', 'wineid', 'subject', 'commenthost', 'userpage',
'posted', 'lastchanged'))
->orderBy('comment_parent')
->execute();
$rawcomments = comment_load_multiple(FALSE);
// Index by subject
$comments = array();
foreach ($rawcomments as $comment) {
$comments[$comment->subject] = $comment;
}
$rows = array();
foreach ($result as $row) {
$rows[$row->subject] = $row;
}
if (!$this->assertEqual(count($comments), count($rows), t('Counts of comments and input rows match'))) {
$this->error(t('!comments comments, should be !rows',
array('!comments' => count($comments), '!rows' => count($rows))));
}
$comment = $comments['im second'];
$row = $rows['im second'];
$this->assertEqual($comment->mail, $row->mail, t('Mail matches'));
$this->assertEqual($comment->name, $row->name, t('Name matches'));
$this->assertEqual($comment->status, COMMENT_PUBLISHED, t('Status matches'));
$wine_migration = MigrationBase::getInstance('WineWine');
$destid = $wine_migration->getMap()->lookupDestinationID(array($row->wineid));
$this->assertEqual($comment->nid, reset($destid), t('Nid matches'));
$body = field_get_items('comment', $comment, 'comment_body');
$this->assertEqual($body[0]['value'], $row->body, t('Body matches'));
$this->assertEqual($comment->hostname, $row->commenthost, t('Hostname matches'));
$this->assertEqual($comment->homepage, $row->userpage, t('Homepage matches'));
$this->assertEqual($comment->created, $row->posted, t('Created matches'));
$this->assertEqual($comment->changed, $row->lastchanged, t('Changed matches'));
$comment = $comments['im child'];
$row = $rows['im child'];
$user_migration = MigrationBase::getInstance('WineUser');
$destid = $user_migration->getMap()->lookupDestinationID(array($row->accountid));
$this->assertEqual($comment->uid, reset($destid), t('Uid matches'));
$this->assertEqual($comment->pid, $comments['im parent']->cid, t('Parent matches'));
// Test updates
// Capture original comments
$original_comments = comment_load_multiple(FALSE);
$update_migration = Migration::getInstance('WineCommentUpdates');
$result = $update_migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Wine comment updates import returned RESULT_COMPLETED'));
$final_comments = comment_load_multiple(FALSE);
foreach ($original_comments as $cid => $original_comment) {
foreach ($original_comment as $field => $value) {
if ($field == 'subject') {
if ($value == $final_comments[$cid]->$field) {
$this->error(t('Field !field should have changed but did not, value=!value',
array('!field' => $field, '!value' => print_r($value, TRUE))));
}
}
else {
if ($value != $final_comments[$cid]->$field) {
$this->error(t('Field !field mismatch: original !value1, result !value2',
array('!field' => $field, '!value1' => print_r($value, TRUE),
'!value2' => print_r($final_comments[$cid]->$field, TRUE))));
}
}
}
}
// Test rollback
$result = $migration->processRollback(array('force' => TRUE));
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Comment rollback returned RESULT_COMPLETED'));
$rawcomments = comment_load_multiple(FALSE);
$this->assertEqual(count($rawcomments), 0, t('All comments deleted'));
$count = db_select('migrate_map_winecomment', 'map')
->fields('map', array('sourceid1'))
->countQuery()
->execute()
->fetchField();
$this->assertEqual($count, 0, t('Map cleared'));
$count = db_select('migrate_message_winecomment', 'msg')
->fields('msg', array('sourceid1'))
->countQuery()
->execute()
->fetchField();
$this->assertEqual($count, 0, t('Messages cleared'));
}
}

393
sites/all/modules/migrate/tests/plugins/destinations/node.test Normal file
View File

@@ -0,0 +1,393 @@
<?php
/**
* @file
* Tests for the node destination plugin.
*/
/**
* 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('list', 'number', 'taxonomy', 'image', 'migrate', 'migrate_example');
}
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('WineFileCopy');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('File 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
$rawnodes = node_load_multiple(FALSE, array('type' => 'migrate_example_producer'), TRUE);
// Index by title
$producer_nodes = array();
foreach ($rawnodes as $node) {
$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'));
$rawnodes = node_load_multiple(FALSE, array('type' => 'migrate_example_wine'), TRUE);
// Index by title
$wine_nodes = array();
foreach ($rawnodes as $node) {
$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'));
$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'));
// Test Field API fields of all types
// body_with_summary
$body = field_get_items('node', $wine_node, 'body');
$this->assertEqual($body[0]['value'], 'REVIEW: ' . drupal_strtoupper($wine_row->body),
t('body properly migrated'));
$this->assertEqual($body[0]['summary'], $wine_row->excerpt,
t('summary properly migrated'));
// taxonomy_term_reference - single and multiple
$variety = field_get_items('node', $wine_node, 'migrate_example_wine_varieties');
$variety_migration = MigrationBase::getInstance('WineVariety');
$mapped_tid = $variety_migration->getMap()->lookupDestinationID(array($wine_row->variety));
if (is_array($mapped_tid)) {
$this->assertEqual($variety[0]['tid'], 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 = field_get_items('node', $wine_node, 'migrate_example_wine_best_with');
$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 ($best_with as $current) {
$this->assertNotNull($mapped_tids[$current['tid']],
t('Multiple value taxonomy_term_reference properly migrated'));
}
// 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[LANGUAGE_NONE], $expected,
t('Vintages match (prepareRow works)'));
// Test updates
// Capture original nodes
$original_nodes = node_load_multiple(array(), array('type' => 'migrate_example_wine'));
$update_migration = Migration::getInstance('WineUpdates');
$result = $update_migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Wine updates import returned RESULT_COMPLETED'));
$final_nodes = node_load_multiple(array(), array('type' => 'migrate_example_wine'), TRUE);
foreach ($original_nodes as $nid => $original_node) {
foreach ($original_node as $field => $value) {
if ($field == 'field_migrate_example_wine_ratin' || $field == 'changed' || $field == 'revision_timestamp') {
if ($value == $final_nodes[$nid]->$field) {
$this->error(t('Field !field should have changed but did not, value=!value',
array('!field' => $field, '!value' => print_r($value, TRUE))));
}
}
else {
if ($value != $final_nodes[$nid]->$field) {
$this->error(t('Field !field mismatch: original !value1, result !value2',
array('!field' => $field, '!value1' => print_r($value, TRUE),
'!value2' => print_r($final_nodes[$nid]->$field, TRUE))));
}
}
}
}
// 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'));
$rawnodes = node_load_multiple(FALSE, array('type' => 'migrate_example_wine'), TRUE);
if (!$this->assertEqual(count($rawnodes), 4, t('Now 4 wine nodes exist'))) {
$this->error(t('There are now !count nodes', array('!count' => count($rawnodes))));
}
$nodes = node_load_multiple(FALSE, array('title' => 'Archeo Ruggero di Tasso Nero d\'Avola'), TRUE);
$node = reset($nodes);
$body = $node->body[LANGUAGE_NONE][0]['value'];
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'));
$rawnodes = node_load_multiple(FALSE, array('type' => 'migrate_example_wine'), TRUE);
$this->assertEqual(count($rawnodes), 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')));
db_update('migrate_example_wine')
->fields(array(
'body' => 'Very berry',
// Timestamp 1286008921
'last_changed' => strtotime('2010-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'));
$rawnodes = node_load_multiple(FALSE, array('type' => 'migrate_example_wine'), TRUE);
if (!$this->assertEqual(count($rawnodes), 4, t('Now 4 wine nodes exist'))) {
$this->error(t('There are now !count nodes', array('!count' => count($rawnodes))));
}
$nodes = node_load_multiple(FALSE, array('title' => 'Montes Classic Cabernet Sauvignon'), TRUE);
$node = reset($nodes);
$body = $node->body[LANGUAGE_NONE][0]['value'];
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'));
$rawnodes = node_load_multiple(FALSE, array('type' => 'migrate_example_wine'), TRUE);
$this->assertEqual(count($rawnodes), 1, t('One node imported'));
// 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'));
$rawnodes = node_load_multiple(FALSE, array('type' => 'migrate_example_wine'), TRUE);
$this->assertEqual(count($rawnodes), 1, t('One node imported'));
$node = reset($rawnodes);
$this->assertEqual($node->title, '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'));
$rawnodes = node_load_multiple(FALSE, array('type' => 'migrate_example_wine'), TRUE);
$this->assertEqual(count($rawnodes), 1, t('One node imported'));
// 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'));
$rawnodes = node_load_multiple(FALSE, array('type' => 'migrate_example_wine'), TRUE);
$this->assertEqual(count($rawnodes), 1, t('One node imported'));
$node = reset($rawnodes);
$this->assertEqual($node->title, '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_query("SELECT COUNT(nid)
FROM {node} n
INNER JOIN {migrate_map_winewine} map ON n.nid=map.destid1
WHERE n.changed = map.sourceid1*100000000")->fetchField();
$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)));
}
// Test for http://drupal.org/node/1037872 - updating with nid mapped and idlist
$migration = Migration::getInstance('BeerTerm');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Beer term import returned RESULT_COMPLETED'));
$migration = Migration::getInstance('BeerUser');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Beer user import returned RESULT_COMPLETED'));
$migration = Migration::getInstance('BeerNode');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Beer node import returned RESULT_COMPLETED'));
db_update('migrate_map_beernode')
->fields(array('needs_update' => 1))
->execute();
$result = $migration->processImport(array('idlist' => 99999999));
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Beer node update import returned RESULT_COMPLETED'));
$result = db_select('migrate_message_beernode', 'msg')
->fields('msg', array('message'))
->execute();
foreach ($result as $row) {
$this->error($row->message);
}
}
}

49
sites/all/modules/migrate/tests/plugins/destinations/table.test Normal file
View File

@@ -0,0 +1,49 @@
<?php
/**
* @file
* Tests for the table destination plugin.
*/
/**
* Test table migration.
*/
class MigrateTableUnitTest extends DrupalWebTestCase {
public static function getInfo() {
return array(
'name' => 'Table migration',
'description' => 'Test migration of table data',
'group' => 'Migrate',
);
}
function setUp() {
parent::setUp('migrate', 'migrate_example');
}
function testTableImport() {
$migration = Migration::getInstance('WineTable');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Table import returned RESULT_COMPLETED'));
$result = db_query(
"SELECT COUNT(*)
FROM {migrate_example_wine_table_source} s
INNER JOIN {migrate_map_winetable} map ON s.fooid=map.sourceid1
INNER JOIN {migrate_example_wine_table_dest} d ON map.destid1=d.recordid"
);
$this->assertEqual($result->fetchField(), 3,
t('Count of imported records is correct'));
// Test rollback
$result = $migration->processRollback();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Variety term rollback returned RESULT_COMPLETED'));
$result = db_query("SELECT COUNT(*) FROM {migrate_example_wine_table_dest}");
$this->assertEqual($result->fetchField(), 0, t('All migrated rows removed'));
$result = db_query("SELECT COUNT(*) FROM {migrate_map_winetable}");
$this->assertEqual($result->fetchField(), 0, t('All map rows removed'));
}
}

113
sites/all/modules/migrate/tests/plugins/destinations/term.test Normal file
View File

@@ -0,0 +1,113 @@
<?php
/**
* @file
* Tests for the taxonomy term destination plugin.
*/
/**
* Test taxonomy migration.
*/
class MigrateTaxonomyUnitTest extends DrupalWebTestCase {
public static function getInfo() {
return array(
'name' => 'Taxonomy migration',
'description' => 'Test migration of taxonomy data',
'group' => 'Migrate',
);
}
function setUp() {
parent::setUp('taxonomy', 'migrate', 'migrate_example');
}
function testTermImport() {
$migration = Migration::getInstance('WineVariety');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Variety term import returned RESULT_COMPLETED'));
$vocab = taxonomy_vocabulary_machine_name_load('migrate_example_wine_varieties');
$rawterms = taxonomy_term_load_multiple(array(), array('vid' => $vocab->vid));
$terms = array();
foreach ($rawterms as $term) {
$terms[$term->name] = $term;
}
$query = db_select('migrate_example_wine_categories', 'wc')
->fields('wc', array('categoryid', 'name', 'details', 'category_parent', 'ordering'))
->condition('wc.type', 'variety');
$query->leftJoin('migrate_example_wine_categories', 'wcpar',
'wc.category_parent=wcpar.categoryid');
$query->addField('wcpar', 'name', 'parent_name');
$result = $query->execute();
$rows = array();
foreach ($result as $row) {
$rows[$row->name] = $row;
}
$this->assertEqual(count($terms), count($rows), t('Counts of variety terms and input rows match'));
// Test each base term field
$this->assert(isset($terms['Merlot']) && isset($rows['Merlot']),
t("Name 'Merlot' migrated correctly"));
$this->assertEqual($terms['Merlot']->description, $rows['Merlot']->details,
t('Descriptions match'));
$this->assertEqual($terms['Merlot']->weight, $rows['Merlot']->ordering,
t('Weights match'));
$this->assertEqual($terms['Merlot']->format, $migration->basicFormat->format,
t('Formats match'));
$parents = taxonomy_get_parents($terms['White wine']->tid);
$this->assertEqual(count($parents), 0, t('Term without parent properly migrated'));
$parents = taxonomy_get_parents($terms['Merlot']->tid);
$parent = array_pop($parents);
$this->assertEqual($parent->name, 'Red wine', t('Parents match'));
// Test updates
// Capture original terms
$tempterms = taxonomy_term_load_multiple(array(), array('vid' => $vocab->vid));
foreach ($tempterms as $tid => $term) {
$original_terms[$tid] = clone $term;
}
$update_migration = Migration::getInstance('WineVarietyUpdates');
$result = $update_migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Wine variety term updates import returned RESULT_COMPLETED'));
$final_terms = taxonomy_term_load_multiple(array(), array('vid' => $vocab->vid));
foreach ($original_terms as $tid => $original_term) {
foreach ($original_term as $field => $value) {
if ($field == 'description') {
if ($value == $final_terms[$tid]->$field) {
$this->error(t('Field !field should have changed but did not, value=!value',
array('!field' => $field, '!value' => print_r($value, TRUE))));
}
}
else {
if ($value != $final_terms[$tid]->$field) {
$this->error(t('Field !field mismatch: original !value1, result !value2',
array('!field' => $field, '!value1' => print_r($value, TRUE),
'!value2' => print_r($final_terms[$tid]->$field, TRUE))));
}
}
}
}
// Test rollback
$result = $migration->processRollback(array('force' => TRUE));
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Variety term rollback returned RESULT_COMPLETED'));
$rawterms = taxonomy_term_load_multiple(array(), array('vid' => $vocab->vid));
$this->assertEqual(count($rawterms), 0, t('All terms deleted'));
$count = db_select('migrate_map_winevariety', 'map')
->fields('map', array('sourceid1'))
->countQuery()
->execute()
->fetchField();
$this->assertEqual($count, 0, t('Map cleared'));
$count = db_select('migrate_message_winevariety', 'msg')
->fields('msg', array('sourceid1'))
->countQuery()
->execute()
->fetchField();
$this->assertEqual($count, 0, t('Messages cleared'));
}
}

208
sites/all/modules/migrate/tests/plugins/destinations/user.test Normal file
View File

@@ -0,0 +1,208 @@
<?php
/**
* @file
* Tests for the user destination plugin.
*/
/**
* Test user migration.
*/
class MigrateUserUnitTest extends DrupalWebTestCase {
public static function getInfo() {
return array(
'name' => 'User migration',
'description' => 'Test migration of user data',
'group' => 'Migrate',
);
}
function setUp() {
parent::setUp('migrate', 'migrate_example');
// To test timestamps
date_default_timezone_set('US/Mountain');
}
function testUserImport() {
$migration = Migration::getInstance('WineFileCopy');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('File import returned RESULT_COMPLETED'));
$migration = Migration::getInstance('WineRole');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Role import returned RESULT_COMPLETED'));
// Confirm both roles were successfully imported
$result = db_select('role', 'r')
->fields('r', array('rid', 'name'))
->condition('name', array('Taster', 'Vintner'), 'IN')
->execute();
$roles = array();
foreach ($result as $row) {
$roles[$row->name] = $row->rid;
}
$this->assertEqual(count($roles), 2, t('Both roles imported'));
$migration = Migration::getInstance('WineUser');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('User import returned RESULT_COMPLETED'));
$result = db_select('migrate_example_wine_account', 'mea')
->fields('mea', array('accountid', 'status', 'posted', 'name',
'sex', 'password', 'mail', 'last_access', 'last_login',
'sig', 'original_mail'))
->execute();
$uids = db_select('users', 'u')
->fields('u', array('uid'))
->execute()
->fetchCol();
// Index by name
$users = array();
foreach ($uids as $uid) {
// Skip anon/admin users
if ($uid > 1) {
$account = user_load($uid);
$users[$account->name] = $account;
}
}
$rows = array();
foreach ($result as $row) {
$rows[$row->name] = $row;
}
$this->assertEqual(count($users), count($rows),
t('Counts of users and input rows match'));
// Test each base user field
$this->assert(isset($users['darren']) && isset($rows['darren']),
t("Username 'darren' migrated correctly"));
$this->assertEqual($users['darren']->mail, $rows['darren']->mail,
t('Email addresses match'));
$this->assertEqual($users['darren']->status, $rows['darren']->status,
t('Statuses match'));
$this->assertNotNull($users['darren']->roles[2], t('Authenticated role'));
$this->assertNotNull($users['darren']->roles[$roles['Taster']], t('Taster role'));
$this->assertFalse(isset($users['darren']->roles[$roles['Vintner']]), t('No Vintner role'));
$this->assertEqual($users['darren']->created, strtotime($rows['darren']->posted),
t('Created times match'));
$this->assertEqual($users['darren']->access, strtotime($rows['darren']->last_access),
t('Access times match'));
$this->assertEqual($users['darren']->login, strtotime($rows['darren']->last_login),
t('Login times match'));
$this->assertTrue(user_check_password($rows['darren']->password, $users['darren']),
t('Passwords match'));
$this->assertEqual($users['darren']->init, $rows['darren']->original_mail,
t('Init mails match'));
$this->assertEqual($users['darren']->signature, $rows['darren']->sig,
t('Signatures match'));
$this->assertEqual($users['darren']->signature_format, $migration->basicFormat->format,
t('Signature formats match'));
$this->assertEqual($users['darren']->field_migrate_example_gender[LANGUAGE_NONE][0]['value'],
0, t('Male gender migrated'));
$this->assertEqual($users['emily']->field_migrate_example_gender[LANGUAGE_NONE][0]['value'],
1, t('Female gender migrated'));
$this->assert(!isset($users['fonzie']->field_migrate_example_gender[LANGUAGE_NONE][0]['value']),
t('Missing gender left unmigrated'));
$this->assert(is_object($users['fonzie']->picture) &&
$users['fonzie']->picture->filename == 'association-individual.png',
t('Picture migrated'));
$this->assertNotNull($users['fonzie']->roles[$roles['Taster']], t('Taster role'));
$this->assertNotNull($users['fonzie']->roles[$roles['Vintner']], t('Vintner role'));
// TODO: Theme, timezone, language
// Test updates
// Capture original users
$query = new EntityFieldQuery;
$result = $query
->entityCondition('entity_type', 'user')
->propertyCondition('uid', 1, '>')
->execute();
$uids = array_keys($result['user']);
$original_users = user_load_multiple($uids, array(), TRUE);
$update_migration = Migration::getInstance('WineUserUpdates');
$result = $update_migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Wine user updates import returned RESULT_COMPLETED'));
$final_users = user_load_multiple($uids, array(), TRUE);
foreach ($original_users as $uid => $original_user) {
foreach ($original_user as $field => $value) {
if ($field == 'field_migrate_example_gender') {
if ($value == $final_users[$uid]->$field) {
$this->error(t('For user !name, field !field should have changed but did not, value=!value',
array('!name' => $final_users[$uid]->name, '!field' => $field,
'!value' => print_r($value, TRUE))));
}
}
else {
if ($value != $final_users[$uid]->$field) {
// Core bug http://drupal.org/node/935592 causes picture mismatches, ignore until it's fixed
if ($field != 'picture') {
$this->error(t('For user !name, field !field mismatch: original !value1, result !value2',
array('!name' => $final_users[$uid]->name, '!field' => $field,
'!value1' => print_r($value, TRUE),
'!value2' => print_r($final_users[$uid]->$field, TRUE))));
}
}
}
}
}
// Test rollback
$result = $migration->processRollback(array('force' => TRUE));
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('User rollback returned RESULT_COMPLETED'));
$count = db_select('users', 'u')
->fields('u', array('uid'))
->countQuery()
->execute()
->fetchField();
// 2 users left - anon and admin
$this->assertEqual($count, 2, t('All imported users deleted'));
$count = db_select('migrate_map_wineuser', 'map')
->fields('map', array('sourceid1'))
->countQuery()
->execute()
->fetchField();
$this->assertEqual($count, 0, t('Map cleared'));
$count = db_select('migrate_message_wineuser', 'msg')
->fields('msg', array('sourceid1'))
->countQuery()
->execute()
->fetchField();
$this->assertEqual($count, 0, t('Messages cleared'));
// Test deduping
// First, do the original import
$migration = Migration::getInstance('BeerUser');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('User import returned RESULT_COMPLETED'));
$accounts = db_select('users', 'u')
->fields('u', array('mail', 'name'))
->execute()
->fetchAllKeyed();
if (!$this->assertEqual($accounts['alice@example.com'], 'alice', t('alice found'))) {
$this->error(t('Expected alice, found !name', array('!name' => $accounts['alice@example.com'])));
}
if (!$this->assertEqual($accounts['alice2@example.com'], 'alice_2', t('alice_2 found'))) {
$this->error(t('Expected alice_2, found !name', array('!name' => $accounts['alice2@example.com'])));
}
// Then, update in place and make sure the usernames did not change
$migration->prepareUpdate();
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('User import returned RESULT_COMPLETED'));
$accounts = db_select('users', 'u')
->fields('u', array('mail', 'name'))
->execute()
->fetchAllKeyed();
if (!$this->assertEqual($accounts['alice@example.com'], 'alice', t('alice found'))) {
$this->error(t('Expected alice, found !name', array('!name' => $accounts['alice@example.com'])));
}
if (!$this->assertEqual($accounts['alice2@example.com'], 'alice_2', t('alice_2 found'))) {
$this->error(t('Expected alice_2, found !name', array('!name' => $accounts['alice2@example.com'])));
}
}
}

99
sites/all/modules/migrate/tests/plugins/sources/oracle.test Normal file
View File

@@ -0,0 +1,99 @@
<?php
/**
* @file
* Tests for the Oracle source plugin.
*/
/**
* Test migration from Oracle.
*
* NOTE: Test won't run correctly due to http://drupal.org/node/362373, enable
* when that is fixed.
*/
class MigrateOracleUnitTest extends DrupalWebTestCase {
public static function getInfo() {
return array(
'name' => 'Oracle migration',
'description' => 'Test migration from an Oracle source',
'group' => 'Migrate',
);
}
function setUp() {
global $conf;
if (empty($conf['oracle_db']) || empty($conf['oracle_db']['username']) ||
empty($conf['oracle_db']['password']) || empty($conf['oracle_db']['connection_string'])) {
parent::setUp();
}
else {
parent::setUp('features', 'migrate', 'migrate_example_oracle');
}
}
function testOracleImport() {
global $conf;
if (empty($conf['oracle_db'])) {
$this->pass(t('To run the Oracle test, you need to defined $conf[\'oracle_db\']
in settings.php - see migrate_example_oracle.migrate.inc.'));
}
$migration = Migration::getInstance('MigrateExampleOracle');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Region term import returned RESULT_COMPLETED'));
// Gather destination nodes, and their corresponding input data
$rawnodes = node_load_multiple(FALSE, array('type' => 'migrate_example_oracle'), TRUE);
$data = migrate_example_oracle_sample_data();
$this->assertEqual(count($rawnodes), count($data), t('Counts of nodes and input rows match'));
// Index nodes by title
$nodes = array();
foreach ($rawnodes as $node) {
$nodes[$node->title] = $node;
}
// Test each value
foreach ($data as $row) {
$node = $nodes[$row['title']];
if (!$this->assertEqual($node->title, $row['title'], 'Titles match')) {
$this->error(t('Source title !source does not match node title !destination',
array('!source' => $row['title'], '!destination' => $node->title)));
}
if (!$this->assertEqual($node->body[LANGUAGE_NONE][0]['value'], $row['body'], 'Bodies match')) {
$this->error(t('Source body !source does not match node body !destination',
array('!source' => $row['body'], '!destination' => $node->body)));
}
$created = format_date($node->created, 'custom', 'Y/m/d H:i:s');
if (!$this->assertEqual($created, $row['created'], 'Created timestamps match')) {
$this->error(t('Source created !source does not match node created !destination',
array('!source' => $row['created'], '!destination' => $created)));
}
$updated = format_date($node->changed, 'custom', 'Y/m/d H:i:s');
if (!$this->assertEqual($updated, $row['updated'], 'Updated timestamps match')) {
$this->error(t('Source updated !source does not match node changed !destination',
array('!source' => $row['updated'], '!destination' => $updated)));
}
}
// Test rollback
$result = $migration->processRollback();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Node rollback returned RESULT_COMPLETED'));
$rawnodes = node_load_multiple(FALSE, array('type' => 'migrate_example_oracle'), TRUE);
$this->assertEqual(count($rawnodes), 0, t('All nodes deleted'));
$count = db_select('migrate_map_migrateexampleoracle', 'map')
->fields('map', array('sourceid1'))
->countQuery()
->execute()
->fetchField();
$this->assertEqual($count, 0, t('Map cleared'));
$count = db_select('migrate_message_migrateexampleoracle', 'msg')
->fields('msg', array('sourceid1'))
->countQuery()
->execute()
->fetchField();
$this->assertEqual($count, 0, t('Messages cleared'));
}
}

100
sites/all/modules/migrate/tests/plugins/sources/xml.test Normal file
View File

@@ -0,0 +1,100 @@
<?php
/**
* @file
* Tests for the XML source plugins.
*/
/**
* Test node migration.
*/
class MigrateXMLUnitTest extends DrupalWebTestCase {
public static function getInfo() {
return array(
'name' => 'XML migration',
'description' => 'Test migration from XML source',
'group' => 'Migrate',
);
}
function setUp() {
parent::setUp('taxonomy', 'migrate', 'migrate_example');
}
function testNodeImport() {
$migration = Migration::getInstance('WineRegion');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Region term import returned RESULT_COMPLETED'));
$migration = Migration::getInstance('WineFileCopy');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('File 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('WineProducerXML');
$result = $migration->processImport();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Producer node import returned RESULT_COMPLETED'));
// Gather producer nodes, and their corresponding input data
$rawnodes = node_load_multiple(FALSE, array('type' => 'migrate_example_producer'), TRUE);
// Index by title
$producer_nodes = array();
foreach ($rawnodes as $node) {
$producer_nodes[$node->title] = $node;
}
$this->assertEqual(count($producer_nodes), 1,
t('Counts of producer nodes and input rows match'));
// Test each base node field
$producer_node = $producer_nodes['Lolonis Winery'];
$user_migration = MigrationBase::getInstance('WineUser');
$mapped_uid = $user_migration->getMap()->lookupDestinationID(array(3));
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' => 3)));
}
// Test Field API fields of all types
// body_with_summary
$body = field_get_items('node', $producer_node, 'body');
$this->assertEqual($body[0]['value'], 'Makers of Ladybug Red',
t('body properly migrated'));
$region = field_get_items('node', $producer_node, 'migrate_example_wine_regions');
$term = taxonomy_get_term_by_name('Redwood Valley');
$term = reset($term);
$this->assertEqual($region[0]['tid'], $term->tid,
t('region properly migrated'));
// Test rollback
$result = $migration->processRollback();
$this->assertEqual($result, Migration::RESULT_COMPLETED,
t('Producer node rollback returned RESULT_COMPLETED'));
$rawnodes = node_load_multiple(FALSE, array('type' => 'migrate_example_producer'), TRUE);
$this->assertEqual(count($rawnodes), 0, t('All nodes deleted'));
$count = db_select('migrate_map_wineproducerxml', 'map')
->fields('map', array('sourceid1'))
->countQuery()
->execute()
->fetchField();
$this->assertEqual($count, 0, t('Map cleared'));
$count = db_select('migrate_message_wineproducerxml', 'msg')
->fields('msg', array('sourceid1'))
->countQuery()
->execute()
->fetchField();
$this->assertEqual($count, 0, t('Messages cleared'));
}
}