1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
<?php
// $Id$
/**
* Test taxonomy upgrades.
*/
class UpgradePathTaxonomyTestCase extends UpgradePathTestCase {
public static function getInfo() {
return array(
'name' => 'Taxonomy upgrade path',
'description' => 'Taxonomy upgrade path tests.',
'group' => 'Upgrade path',
);
}
public function setUp() {
// Path to the database dump.
$this->databaseDumpFiles = array(
drupal_get_path('module', 'simpletest') . '/tests/upgrade/drupal-6.filled.database.php',
);
parent::setUp();
}
/**
* Retrieve an array mapping allowed vocabulary id to field name for
* all taxonomy_term_reference fields for which an instance exists
* for the specified entity type and bundle.
*/
function instanceVocabularies($entity_type, $bundle) {
$instances = array();
foreach (field_info_instances($entity_type, $bundle) as $instance) {
$field = field_info_field($instance['field_name']);
if ($field['type'] == 'taxonomy_term_reference') {
foreach ($field['settings']['allowed_values'] as $tree) {
// Prefer valid taxonomy term reference fields for a given vocabulary
// when they exist.
if (empty($instances[$tree['vocabulary']]) || $instances[$tree['vocabulary']] == 'taxonomyextra') {
$instances[$tree['vocabulary']] = $field['field_name'];
}
}
}
}
return $instances;
}
/**
* Basic tests for the taxonomy upgrade.
*/
public function testTaxonomyUpgrade() {
$this->assertTrue($this->performUpgrade(), t('The upgrade was completed successfully.'));
// Visit the front page to assert for PHP warning and errors.
$this->drupalGet('');
// Check that taxonomy_vocabulary_node_type and taxonomy_term_node have been
// removed.
$this->assertFalse(db_table_exists('taxonomy_vocabulary_node_type'), t('taxonomy_vocabulary_node_type has been removed.'));
$this->assertFalse(db_table_exists('taxonomy_term_node'), t('taxonomy_term_node has been removed.'));
// Check that the node type 'page' has been associated to a taxonomy
// reference field for each vocabulary.
$voc_keys = array();
foreach (taxonomy_get_vocabularies() as $vocab) {
$voc_keys[] = $vocab->machine_name;
}
$instances = $this->instanceVocabularies('node', 'page');
$inst_keys = array_keys($instances);
sort($voc_keys);
sort($inst_keys);
$this->assertEqual($voc_keys, $inst_keys, t('Node type page has instances for every vocabulary.'));
// Node type 'story' was not explicitly in $vocabulary->nodes but
// each node of type 'story' was associated to one or more terms.
// Check that the node type 'story' has been associated only to
// the taxonomyextra field.
$instances = $this->instanceVocabularies('node', 'story');
$field_names = array_flip($instances);
$this->assertEqual(count($field_names), 1, t('Only one taxonomy term field instance exists for story nodes'));
$this->assertEqual(key($field_names), 'taxonomyextra', t('Only the excess taxonomy term field is used on story nodes'));
// Check that the node type 'poll' has been associated to no taxonomy
// reference field.
$instances = $this->instanceVocabularies('node', 'poll');
$this->assertTrue(empty($instances), t('Node type poll has no taxonomy term reference field instances.'));
// Check that each node of type 'page' and 'story' is associated to all the
// terms except terms whose ID is equal to the node ID or is equal to the
// node ID subtracted from 49.
$nodes = node_load_multiple(array(), array('type' => 'page'));
$nodes += node_load_multiple(array(), array('type' => 'story'));
$terms = db_select('taxonomy_term_data', 'td')
->fields('td')
->orderBy('vid')
->orderBy('tid')
->execute()
->fetchAllAssoc('tid');
field_attach_prepare_view('node', $nodes, 'full');
foreach ($nodes as $nid => $node) {
$node->content = field_attach_view('node', $node, 'full');
$render = drupal_render($node->content);
$this->drupalSetContent($render);
$this->verbose($render);
$vocabulary_seen = array();
foreach ($terms as $tid => $term) {
// In our test database, each node is arbitrary associated with all
// terms except two: one whose tid is ($nid) and one whose tid is
// (49 - $nid).
$should_be_displayed = ($tid != $nid) && ($tid + $nid != 49);
// Only vocabularies 13 to 24 are properly associated with the node
// type 'page'. All other node types are not associated with any
// vocabulary, but still are associated with terms. Those terms
// will be moved to the taxonomy extra field.
if ($node->type == 'page' && $term->vid >= 13 && $term->vid <= 24) {
$vocabulary = taxonomy_vocabulary_load($term->vid);
$field_class = 'field-name-' . strtr('taxonomy_' . $vocabulary->machine_name, '_', '-');;
}
else {
$field_class = 'field-name-taxonomyextra';
}
// Odd vocabularies are single, so any additional term will be moved
// to the taxonomy extra field.
if ($should_be_displayed) {
if ($term->vid % 2 == 1 && !empty($vocabulary_seen[$term->vid])) {
$field_class = 'field-name-taxonomyextra';
}
$vocabulary_seen[$term->vid] = TRUE;
}
$args = array(
'%name' => $term->name,
'@field' => $field_class,
'%nid' => $nid,
);
// Use link rather than term name because migrated term names can be
// substrings of other term names. e.g. "term 1 of vocabulary 2" is
// found when "term 1 of vocabulary 20" is output.
$term_path = url('taxonomy/term/' . $term->tid);
if (!$should_be_displayed) {
// Look for any link with the term path.
$links = $this->xpath('//a[@href=:term_path]', array(':term_path' => $term_path));
$this->assertFalse($links, t('Term %name (@field) is not displayed on node %nid', $args));
}
else {
// Look for a link with the term path inside the correct field.
// We search for "SPACE + class + SPACE" to avoid matching a substring
// of the class.
$links = $this->xpath('//div[contains(concat(" ", normalize-space(@class), " "), :field_class)]//a[@href=:term_path]', array(':field_class' => ' ' . $field_class . ' ', ':term_path' => $term_path));
$this->assertTrue($links, t('Term %name (@field) is displayed on node %nid', $args));
}
}
// nid 1, revision 1 had a bogus record in {term_node} pointing to term
// ID 0. Make sure we ignored this instead of generating a bogus term.
if ($node->nid == 1) {
$link = l($term->name, 'taxonomy/term/0');
$this->assertNoRaw($link, t('Bogus term (tid 0) is not displayed on node 1 vid %old_vid.', $args));
}
// The first 12 nodes have two revisions. For nodes with
// revisions, check that the oldest revision is associated only
// to terms whose ID is equal to the node ID or 49 less the node ID.
$revisions = node_revision_list($node);
if ($node->nid < 13) {
$this->assertEqual(count($revisions), 2, t('Node %nid has two revisions.', $args));
$last_rev = end($revisions);
$args['%old_vid'] = $last_rev->vid;
$node_old = node_load($node->nid, $last_rev->vid);
field_attach_prepare_view('node', array($node_old->nid => $node_old), 'full');
$node_old->content = field_attach_view('node', $node_old, 'full');
$render = drupal_render($node_old->content);
$this->drupalSetContent($render);
$this->verbose($render);
$term = $terms[$node->nid];
$link = l($term->name, 'taxonomy/term/' . $term->tid);
$this->assertRaw($link, t('Term %name (@field) is displayed on node %nid vid %old_vid.', $args));
$term = $terms[49-$node->nid];
$link = l($term->name, 'taxonomy/term/' . $term->tid);
$this->assertRaw($link, t('Term %name (@field) is displayed on node %nid %old_vid.', $args));
}
else {
$this->assertEqual(count($revisions), 1, t('Node %nid has one revision.', $args));
}
}
}
}
|
