upgrade to OpenPublish 7.x-1.0-alpha9
[eupraxis:fsrn.git] / openpublish / modules / simpletest / tests / entity_query.test
1 <?php
2
3
4 /**
5  * @file
6  * Unit test file for the entity API.
7  */
8
9 /**
10  * Tests EntityFieldQuery.
11  */
12 class EntityFieldQueryTestCase extends DrupalWebTestCase {
13
14   public static function getInfo() {
15     return array(
16       'name' => 'Entity query',
17       'description' => 'Test the EntityFieldQuery class.',
18       'group' => 'Entity API',
19     );
20   }
21
22   function setUp() {
23     parent::setUp(array('field_test'));
24
25     field_test_create_bundle('bundle1');
26     field_test_create_bundle('bundle2');
27     field_test_create_bundle('test_bundle');
28     field_test_create_bundle('test_entity_bundle');
29
30     $instances = array();
31     $this->fields = array();
32     $this->field_names[0] = $field_name = drupal_strtolower($this->randomName() . '_field_name');
33     $field = array('field_name' => $field_name, 'type' => 'test_field', 'cardinality' => 4);
34     $field = field_create_field($field);
35     $this->fields[0] = $field;
36     $instance = array(
37       'field_name' => $field_name,
38       'entity_type' => '',
39       'bundle' => '',
40       'label' => $this->randomName() . '_label',
41       'description' => $this->randomName() . '_description',
42       'weight' => mt_rand(0, 127),
43       'settings' => array(
44         'test_instance_setting' => $this->randomName(),
45       ),
46       'widget' => array(
47         'type' => 'test_field_widget',
48         'label' => 'Test Field',
49         'settings' => array(
50           'test_widget_setting' => $this->randomName(),
51         )
52       )
53     );
54
55     $instances[0] = $instance;
56
57     // Add an instance to that bundle.
58     $instances[0]['bundle'] = 'bundle1';
59     $instances[0]['entity_type'] = 'test_entity_bundle_key';
60     field_create_instance($instances[0]);
61     $instances[0]['bundle'] = 'bundle2';
62     field_create_instance($instances[0]);
63     $instances[0]['bundle'] = $instances[0]['entity_type'] = 'test_entity_bundle';
64     field_create_instance($instances[0]);
65
66     $this->field_names[1] = $field_name = drupal_strtolower($this->randomName() . '_field_name');
67     $field = array('field_name' => $field_name, 'type' => 'shape', 'cardinality' => 4);
68     $field = field_create_field($field);
69     $this->fields[1] = $field;
70     $instance = array(
71       'field_name' => $field_name,
72       'entity_type' => '',
73       'bundle' => '',
74       'label' => $this->randomName() . '_label',
75       'description' => $this->randomName() . '_description',
76       'weight' => mt_rand(0, 127),
77       'settings' => array(
78         'test_instance_setting' => $this->randomName(),
79       ),
80       'widget' => array(
81         'type' => 'test_field_widget',
82         'label' => 'Test Field',
83         'settings' => array(
84           'test_widget_setting' => $this->randomName(),
85         )
86       )
87     );
88
89     $instances[1] = $instance;
90
91     // Add a field instance to the bundles.
92     $instances[1]['bundle'] = 'bundle1';
93     $instances[1]['entity_type'] = 'test_entity_bundle_key';
94     field_create_instance($instances[1]);
95     $instances[1]['bundle'] = $instances[1]['entity_type'] = 'test_entity_bundle';
96     field_create_instance($instances[1]);
97
98     $this->instances = $instances;
99     // Write entity base table if there is one.
100     $entities = array();
101
102     // Create entities which have a 'bundle key' defined.
103     for ($i = 1; $i < 7; $i++) {
104       $entity = new stdClass();
105       $entity->ftid = $i;
106       $entity->fttype = ($i < 5) ? 'bundle1' : 'bundle2';
107
108       $entity->{$this->field_names[0]}[LANGUAGE_NONE][0]['value'] = $i;
109       drupal_write_record('test_entity_bundle_key', $entity);
110       field_attach_insert('test_entity_bundle_key', $entity);
111     }
112
113     $entity = new stdClass();
114     $entity->ftid = 5;
115     $entity->fttype = 'test_entity_bundle';
116     $entity->{$this->field_names[1]}[LANGUAGE_NONE][0]['shape'] = 'square';
117     $entity->{$this->field_names[1]}[LANGUAGE_NONE][0]['color'] = 'red';
118     $entity->{$this->field_names[1]}[LANGUAGE_NONE][1]['shape'] = 'circle';
119     $entity->{$this->field_names[1]}[LANGUAGE_NONE][1]['color'] = 'blue';
120     drupal_write_record('test_entity_bundle', $entity);
121     field_attach_insert('test_entity_bundle', $entity);
122
123     $instances[2] = $instance;
124     $instances[2]['bundle'] = 'test_bundle';
125     $instances[2]['field_name'] = $this->field_names[0];
126     $instances[2]['entity_type'] = 'test_entity';
127     field_create_instance($instances[2]);
128
129     // Create entities with support for revisions.
130     for ($i = 1; $i < 5; $i++) {
131       $entity = new stdClass();
132       $entity->ftid = $i;
133       $entity->ftvid = $i;
134       $entity->fttype = 'test_bundle';
135       $entity->{$this->field_names[0]}[LANGUAGE_NONE][0]['value'] = $i;
136
137       drupal_write_record('test_entity', $entity);
138       field_attach_insert('test_entity', $entity);
139       drupal_write_record('test_entity_revision', $entity);
140     }
141
142     // Add two revisions to an entity.
143     for ($i = 100; $i < 102; $i++) {
144       $entity = new stdClass();
145       $entity->ftid = 4;
146       $entity->ftvid = $i;
147       $entity->fttype = 'test_bundle';
148       $entity->{$this->field_names[0]}[LANGUAGE_NONE][0]['value'] = $i;
149
150       drupal_write_record('test_entity', $entity, 'ftid');
151       drupal_write_record('test_entity_revision', $entity);
152
153       db_update('test_entity')
154        ->fields(array('ftvid' => $entity->ftvid))
155        ->condition('ftid', $entity->ftid)
156        ->execute();
157
158       field_attach_update('test_entity', $entity);
159     }
160   }
161
162   /**
163    * Tests EntityFieldQuery.
164    */
165   function testEntityFieldQuery() {
166     $query = new EntityFieldQuery();
167     $query
168       ->entityCondition('entity_type', 'test_entity_bundle')
169       ->entityCondition('entity_id', '5');
170     $this->assertEntityFieldQuery($query, array(
171       array('test_entity_bundle', 5),
172     ), t('Test query on an entity type with a generated bundle.'));
173
174     // Test entity_type condition.
175     $query = new EntityFieldQuery();
176     $query->entityCondition('entity_type', 'test_entity_bundle_key');
177     $this->assertEntityFieldQuery($query, array(
178       array('test_entity_bundle_key', 1),
179       array('test_entity_bundle_key', 2),
180       array('test_entity_bundle_key', 3),
181       array('test_entity_bundle_key', 4),
182       array('test_entity_bundle_key', 5),
183       array('test_entity_bundle_key', 6),
184     ), t('Test entity entity_type condition.'));
185
186     // Test entity_id condition.
187     $query = new EntityFieldQuery();
188     $query
189       ->entityCondition('entity_type', 'test_entity_bundle_key')
190       ->entityCondition('entity_id', '3');
191     $this->assertEntityFieldQuery($query, array(
192       array('test_entity_bundle_key', 3),
193     ), t('Test entity entity_id condition.'));
194
195     $query = new EntityFieldQuery();
196     $query
197       ->entityCondition('entity_type', 'test_entity_bundle_key')
198       ->propertyCondition('ftid', '3');
199     $this->assertEntityFieldQuery($query, array(
200       array('test_entity_bundle_key', 3),
201     ), t('Test entity entity_id condition and entity_id property condition.'));
202
203     // Test bundle condition.
204     $query = new EntityFieldQuery();
205     $query
206       ->entityCondition('entity_type', 'test_entity_bundle_key')
207       ->entityCondition('bundle', 'bundle1');
208     $this->assertEntityFieldQuery($query, array(
209       array('test_entity_bundle_key', 1),
210       array('test_entity_bundle_key', 2),
211       array('test_entity_bundle_key', 3),
212       array('test_entity_bundle_key', 4),
213     ), t('Test entity bundle condition: bundle1.'));
214
215     $query = new EntityFieldQuery();
216     $query
217       ->entityCondition('entity_type', 'test_entity_bundle_key')
218       ->entityCondition('bundle', 'bundle2');
219     $this->assertEntityFieldQuery($query, array(
220       array('test_entity_bundle_key', 5),
221       array('test_entity_bundle_key', 6),
222     ), t('Test entity bundle condition: bundle2.'));
223
224     $query = new EntityFieldQuery();
225     $query
226       ->entityCondition('entity_type', 'test_entity_bundle_key')
227       ->propertyCondition('fttype', 'bundle2');
228     $this->assertEntityFieldQuery($query, array(
229       array('test_entity_bundle_key', 5),
230       array('test_entity_bundle_key', 6),
231     ), t('Test entity bundle condition and bundle property condition.'));
232
233     // Test revision_id condition.
234     $query = new EntityFieldQuery();
235     $query
236       ->entityCondition('entity_type', 'test_entity')
237       ->entityCondition('revision_id', '3');
238     $this->assertEntityFieldQuery($query, array(
239       array('test_entity', 3),
240     ), t('Test entity revision_id condition.'));
241
242     $query = new EntityFieldQuery();
243     $query
244       ->entityCondition('entity_type', 'test_entity')
245       ->propertyCondition('ftvid', '3');
246     $this->assertEntityFieldQuery($query, array(
247       array('test_entity', 3),
248     ), t('Test entity revision_id condition and revision_id property condition.'));
249
250     $query = new EntityFieldQuery();
251     $query
252       ->entityCondition('entity_type', 'test_entity')
253       ->fieldCondition($this->fields[0], 'value', 100, '>=')
254       ->age(FIELD_LOAD_REVISION);
255     $this->assertEntityFieldQuery($query, array(
256         array('test_entity', 100),
257         array('test_entity', 101),
258     ), t('Test revision age.'));
259
260     // Test that fields attached to the non-revision supporting entity
261     // 'test_entity_bundle_key' are reachable in FIELD_LOAD_REVISION.
262     $query = new EntityFieldQuery();
263     $query
264       ->fieldCondition($this->fields[0], 'value', 100, '<')
265       ->age(FIELD_LOAD_REVISION);
266     $this->assertEntityFieldQuery($query, array(
267         array('test_entity_bundle_key', 1),
268         array('test_entity_bundle_key', 2),
269         array('test_entity_bundle_key', 3),
270         array('test_entity_bundle_key', 4),
271         array('test_entity_bundle_key', 5),
272         array('test_entity_bundle_key', 6),
273         array('test_entity', 1),
274         array('test_entity', 2),
275         array('test_entity', 3),
276         array('test_entity', 4),
277     ), t('Test that fields are reachable from FIELD_LOAD_REVISION even for non-revision entities.'));
278
279     // Test entity sort by entity_id.
280     $query = new EntityFieldQuery();
281     $query
282       ->entityCondition('entity_type', 'test_entity_bundle_key')
283       ->entityOrderBy('entity_id', 'ASC');
284     $this->assertEntityFieldQuery($query, array(
285       array('test_entity_bundle_key', 1),
286       array('test_entity_bundle_key', 2),
287       array('test_entity_bundle_key', 3),
288       array('test_entity_bundle_key', 4),
289       array('test_entity_bundle_key', 5),
290       array('test_entity_bundle_key', 6),
291     ), t('Test sort entity entity_id in ascending order.'), TRUE);
292
293     $query = new EntityFieldQuery();
294     $query
295       ->entityCondition('entity_type', 'test_entity_bundle_key')
296       ->entityOrderBy('entity_id', 'DESC');
297     $this->assertEntityFieldQuery($query, array(
298       array('test_entity_bundle_key', 6),
299       array('test_entity_bundle_key', 5),
300       array('test_entity_bundle_key', 4),
301       array('test_entity_bundle_key', 3),
302       array('test_entity_bundle_key', 2),
303       array('test_entity_bundle_key', 1),
304     ), t('Test sort entity entity_id in descending order.'), TRUE);
305
306     // Test entity sort by entity_id, with a field condition.
307     $query = new EntityFieldQuery();
308     $query
309       ->entityCondition('entity_type', 'test_entity_bundle_key')
310       ->fieldCondition($this->fields[0], 'value', 0, '>')
311       ->entityOrderBy('entity_id', 'ASC');
312     $this->assertEntityFieldQuery($query, array(
313       array('test_entity_bundle_key', 1),
314       array('test_entity_bundle_key', 2),
315       array('test_entity_bundle_key', 3),
316       array('test_entity_bundle_key', 4),
317       array('test_entity_bundle_key', 5),
318       array('test_entity_bundle_key', 6),
319     ), t('Test sort entity entity_id in ascending order, with a field condition.'), TRUE);
320
321     $query = new EntityFieldQuery();
322     $query
323       ->entityCondition('entity_type', 'test_entity_bundle_key')
324       ->fieldCondition($this->fields[0], 'value', 0, '>')
325       ->propertyOrderBy('ftid', 'DESC');
326     $this->assertEntityFieldQuery($query, array(
327       array('test_entity_bundle_key', 6),
328       array('test_entity_bundle_key', 5),
329       array('test_entity_bundle_key', 4),
330       array('test_entity_bundle_key', 3),
331       array('test_entity_bundle_key', 2),
332       array('test_entity_bundle_key', 1),
333     ), t('Test sort entity entity_id property in descending order, with a field condition.'), TRUE);
334
335     // Test property sort by entity id.
336     $query = new EntityFieldQuery();
337     $query
338       ->entityCondition('entity_type', 'test_entity_bundle_key')
339       ->propertyOrderBy('ftid', 'ASC');
340     $this->assertEntityFieldQuery($query, array(
341       array('test_entity_bundle_key', 1),
342       array('test_entity_bundle_key', 2),
343       array('test_entity_bundle_key', 3),
344       array('test_entity_bundle_key', 4),
345       array('test_entity_bundle_key', 5),
346       array('test_entity_bundle_key', 6),
347     ), t('Test sort entity entity_id property in ascending order.'), TRUE);
348
349     $query = new EntityFieldQuery();
350     $query
351       ->entityCondition('entity_type', 'test_entity_bundle_key')
352       ->propertyOrderBy('ftid', 'DESC');
353     $this->assertEntityFieldQuery($query, array(
354       array('test_entity_bundle_key', 6),
355       array('test_entity_bundle_key', 5),
356       array('test_entity_bundle_key', 4),
357       array('test_entity_bundle_key', 3),
358       array('test_entity_bundle_key', 2),
359       array('test_entity_bundle_key', 1),
360     ), t('Test sort entity entity_id property in descending order.'), TRUE);
361
362     // Test property sort by entity id, with a field condition.
363     $query = new EntityFieldQuery();
364     $query
365       ->entityCondition('entity_type', 'test_entity_bundle_key')
366       ->fieldCondition($this->fields[0], 'value', 0, '>')
367       ->propertyOrderBy('ftid', 'ASC');
368     $this->assertEntityFieldQuery($query, array(
369       array('test_entity_bundle_key', 1),
370       array('test_entity_bundle_key', 2),
371       array('test_entity_bundle_key', 3),
372       array('test_entity_bundle_key', 4),
373       array('test_entity_bundle_key', 5),
374       array('test_entity_bundle_key', 6),
375     ), t('Test sort entity entity_id property in ascending order, with a field condition.'), TRUE);
376
377     $query = new EntityFieldQuery();
378     $query
379       ->entityCondition('entity_type', 'test_entity_bundle_key')
380       ->fieldCondition($this->fields[0], 'value', 0, '>')
381       ->propertyOrderBy('ftid', 'DESC');
382     $this->assertEntityFieldQuery($query, array(
383       array('test_entity_bundle_key', 6),
384       array('test_entity_bundle_key', 5),
385       array('test_entity_bundle_key', 4),
386       array('test_entity_bundle_key', 3),
387       array('test_entity_bundle_key', 2),
388       array('test_entity_bundle_key', 1),
389     ), t('Test sort entity entity_id property in descending order, with a field condition.'), TRUE);
390
391     // Test entity sort by bundle.
392     $query = new EntityFieldQuery();
393     $query
394       ->entityCondition('entity_type', 'test_entity_bundle_key')
395       ->entityOrderBy('bundle', 'ASC')
396       ->propertyOrderBy('ftid', 'DESC');
397     $this->assertEntityFieldQuery($query, array(
398       array('test_entity_bundle_key', 4),
399       array('test_entity_bundle_key', 3),
400       array('test_entity_bundle_key', 2),
401       array('test_entity_bundle_key', 1),
402       array('test_entity_bundle_key', 6),
403       array('test_entity_bundle_key', 5),
404     ), t('Test sort entity bundle in ascending order, property in descending order.'), TRUE);
405
406     $query = new EntityFieldQuery();
407     $query
408       ->entityCondition('entity_type', 'test_entity_bundle_key')
409       ->entityOrderBy('bundle', 'DESC')
410       ->propertyOrderBy('ftid', 'ASC');
411     $this->assertEntityFieldQuery($query, array(
412       array('test_entity_bundle_key', 5),
413       array('test_entity_bundle_key', 6),
414       array('test_entity_bundle_key', 1),
415       array('test_entity_bundle_key', 2),
416       array('test_entity_bundle_key', 3),
417       array('test_entity_bundle_key', 4),
418     ), t('Test sort entity bundle in descending order, property in ascending order.'), TRUE);
419
420     // Test entity sort by bundle, with a field condition.
421     $query = new EntityFieldQuery();
422     $query
423       ->entityCondition('entity_type', 'test_entity_bundle_key')
424       ->fieldCondition($this->fields[0], 'value', 0, '>')
425       ->entityOrderBy('bundle', 'ASC')
426       ->propertyOrderBy('ftid', 'DESC');
427     $this->assertEntityFieldQuery($query, array(
428       array('test_entity_bundle_key', 4),
429       array('test_entity_bundle_key', 3),
430       array('test_entity_bundle_key', 2),
431       array('test_entity_bundle_key', 1),
432       array('test_entity_bundle_key', 6),
433       array('test_entity_bundle_key', 5),
434     ), t('Test sort entity bundle in ascending order, property in descending order, with a field condition.'), TRUE);
435
436     $query = new EntityFieldQuery();
437     $query
438       ->entityCondition('entity_type', 'test_entity_bundle_key')
439       ->fieldCondition($this->fields[0], 'value', 0, '>')
440       ->entityOrderBy('bundle', 'DESC')
441       ->propertyOrderBy('ftid', 'ASC');
442     $this->assertEntityFieldQuery($query, array(
443       array('test_entity_bundle_key', 5),
444       array('test_entity_bundle_key', 6),
445       array('test_entity_bundle_key', 1),
446       array('test_entity_bundle_key', 2),
447       array('test_entity_bundle_key', 3),
448       array('test_entity_bundle_key', 4),
449     ), t('Test sort entity bundle in descending order, property in ascending order, with a field condition.'), TRUE);
450
451     // Test entity sort by bundle, field.
452     $query = new EntityFieldQuery();
453     $query
454       ->entityCondition('entity_type', 'test_entity_bundle_key')
455       ->entityOrderBy('bundle', 'ASC')
456       ->fieldOrderBy($this->fields[0], 'value', 'DESC');
457     $this->assertEntityFieldQuery($query, array(
458       array('test_entity_bundle_key', 4),
459       array('test_entity_bundle_key', 3),
460       array('test_entity_bundle_key', 2),
461       array('test_entity_bundle_key', 1),
462       array('test_entity_bundle_key', 6),
463       array('test_entity_bundle_key', 5),
464     ), t('Test sort entity bundle in ascending order, field in descending order.'), TRUE);
465
466     $query = new EntityFieldQuery();
467     $query
468       ->entityCondition('entity_type', 'test_entity_bundle_key')
469       ->entityOrderBy('bundle', 'DESC')
470       ->fieldOrderBy($this->fields[0], 'value', 'ASC');
471     $this->assertEntityFieldQuery($query, array(
472       array('test_entity_bundle_key', 5),
473       array('test_entity_bundle_key', 6),
474       array('test_entity_bundle_key', 1),
475       array('test_entity_bundle_key', 2),
476       array('test_entity_bundle_key', 3),
477       array('test_entity_bundle_key', 4),
478     ), t('Test sort entity bundle in descending order, field in ascending order.'), TRUE);
479
480     // Test entity sort by revision_id.
481     $query = new EntityFieldQuery();
482     $query
483       ->entityCondition('entity_type', 'test_entity')
484       ->entityOrderBy('revision_id', 'ASC');
485     $this->assertEntityFieldQuery($query, array(
486       array('test_entity', 1),
487       array('test_entity', 2),
488       array('test_entity', 3),
489       array('test_entity', 4),
490     ), t('Test sort entity revision_id in ascending order.'), TRUE);
491
492     $query = new EntityFieldQuery();
493     $query
494       ->entityCondition('entity_type', 'test_entity')
495       ->entityOrderBy('revision_id', 'DESC');
496     $this->assertEntityFieldQuery($query, array(
497       array('test_entity', 4),
498       array('test_entity', 3),
499       array('test_entity', 2),
500       array('test_entity', 1),
501     ), t('Test sort entity revision_id in descending order.'), TRUE);
502
503     // Test entity sort by revision_id, with a field condition.
504     $query = new EntityFieldQuery();
505     $query
506       ->entityCondition('entity_type', 'test_entity')
507       ->fieldCondition($this->fields[0], 'value', 0, '>')
508       ->entityOrderBy('revision_id', 'ASC');
509     $this->assertEntityFieldQuery($query, array(
510       array('test_entity', 1),
511       array('test_entity', 2),
512       array('test_entity', 3),
513       array('test_entity', 4),
514     ), t('Test sort entity revision_id in ascending order, with a field condition.'), TRUE);
515
516     $query = new EntityFieldQuery();
517     $query
518       ->entityCondition('entity_type', 'test_entity')
519       ->fieldCondition($this->fields[0], 'value', 0, '>')
520       ->entityOrderBy('revision_id', 'DESC');
521     $this->assertEntityFieldQuery($query, array(
522       array('test_entity', 4),
523       array('test_entity', 3),
524       array('test_entity', 2),
525       array('test_entity', 1),
526     ), t('Test sort entity revision_id in descending order, with a field condition.'), TRUE);
527
528     // Test property sort by revision_id.
529     $query = new EntityFieldQuery();
530     $query
531       ->entityCondition('entity_type', 'test_entity')
532       ->propertyOrderBy('ftvid', 'ASC');
533     $this->assertEntityFieldQuery($query, array(
534       array('test_entity', 1),
535       array('test_entity', 2),
536       array('test_entity', 3),
537       array('test_entity', 4),
538     ), t('Test sort entity revision_id property in ascending order.'), TRUE);
539
540     $query = new EntityFieldQuery();
541     $query
542       ->entityCondition('entity_type', 'test_entity')
543       ->propertyOrderBy('ftvid', 'DESC');
544     $this->assertEntityFieldQuery($query, array(
545       array('test_entity', 4),
546       array('test_entity', 3),
547       array('test_entity', 2),
548       array('test_entity', 1),
549     ), t('Test sort entity revision_id property in descending order.'), TRUE);
550
551     // Test property sort by revision_id, with a field condition.
552     $query = new EntityFieldQuery();
553     $query
554       ->entityCondition('entity_type', 'test_entity')
555       ->fieldCondition($this->fields[0], 'value', 0, '>')
556       ->propertyOrderBy('ftvid', 'ASC');
557     $this->assertEntityFieldQuery($query, array(
558       array('test_entity', 1),
559       array('test_entity', 2),
560       array('test_entity', 3),
561       array('test_entity', 4),
562     ), t('Test sort entity revision_id property in ascending order, with a field condition.'), TRUE);
563
564     $query = new EntityFieldQuery();
565     $query
566       ->entityCondition('entity_type', 'test_entity')
567       ->fieldCondition($this->fields[0], 'value', 0, '>')
568       ->propertyOrderBy('ftvid', 'DESC');
569     $this->assertEntityFieldQuery($query, array(
570       array('test_entity', 4),
571       array('test_entity', 3),
572       array('test_entity', 2),
573       array('test_entity', 1),
574     ), t('Test sort entity revision_id property in descending order, with a field condition.'), TRUE);
575
576     $query = new EntityFieldQuery();
577     $query
578       ->entityCondition('entity_type', 'test_entity_bundle_key')
579       ->fieldOrderBy($this->fields[0], 'value', 'ASC');
580     $this->assertEntityFieldQuery($query, array(
581       array('test_entity_bundle_key', 1),
582       array('test_entity_bundle_key', 2),
583       array('test_entity_bundle_key', 3),
584       array('test_entity_bundle_key', 4),
585       array('test_entity_bundle_key', 5),
586       array('test_entity_bundle_key', 6),
587     ), t('Test sort field in ascending order without field condition.'), TRUE);
588
589     $query = new EntityFieldQuery();
590     $query
591       ->entityCondition('entity_type', 'test_entity_bundle_key')
592       ->fieldOrderBy($this->fields[0], 'value', 'DESC');
593     $this->assertEntityFieldQuery($query, array(
594       array('test_entity_bundle_key', 6),
595       array('test_entity_bundle_key', 5),
596       array('test_entity_bundle_key', 4),
597       array('test_entity_bundle_key', 3),
598       array('test_entity_bundle_key', 2),
599       array('test_entity_bundle_key', 1),
600     ), t('Test sort field in descending order without field condition.'), TRUE);
601
602     $query = new EntityFieldQuery();
603     $query
604       ->entityCondition('entity_type', 'test_entity_bundle_key')
605       ->fieldCondition($this->fields[0], 'value', 0, '>')
606       ->fieldOrderBy($this->fields[0], 'value', 'ASC');
607     $this->assertEntityFieldQuery($query, array(
608       array('test_entity_bundle_key', 1),
609       array('test_entity_bundle_key', 2),
610       array('test_entity_bundle_key', 3),
611       array('test_entity_bundle_key', 4),
612       array('test_entity_bundle_key', 5),
613       array('test_entity_bundle_key', 6),
614     ), t('Test sort field in ascending order.'), TRUE);
615
616     $query = new EntityFieldQuery();
617     $query
618       ->entityCondition('entity_type', 'test_entity_bundle_key')
619       ->fieldCondition($this->fields[0], 'value', 0, '>')
620       ->fieldOrderBy($this->fields[0], 'value', 'DESC');
621     $this->assertEntityFieldQuery($query, array(
622       array('test_entity_bundle_key', 6),
623       array('test_entity_bundle_key', 5),
624       array('test_entity_bundle_key', 4),
625       array('test_entity_bundle_key', 3),
626       array('test_entity_bundle_key', 2),
627       array('test_entity_bundle_key', 1),
628     ), t('Test sort field in descending order.'), TRUE);
629
630     // Test "in" operation with entity entity_type condition and entity_id
631     // property condition.
632     $query = new EntityFieldQuery();
633     $query
634       ->entityCondition('entity_type', 'test_entity_bundle_key')
635       ->propertyCondition('ftid', array(1, 3, 4), 'IN');
636     $this->assertEntityFieldQuery($query, array(
637       array('test_entity_bundle_key', 1),
638       array('test_entity_bundle_key', 3),
639       array('test_entity_bundle_key', 4),
640     ), t('Test "in" operation with entity entity_type condition and entity_id property condition.'));
641
642     // Test "in" operation with entity entity_type condition and entity_id
643     // property condition. Sort in descending order by entity_id.
644     $query = new EntityFieldQuery();
645     $query
646       ->entityCondition('entity_type', 'test_entity_bundle_key')
647       ->propertyCondition('ftid', array(1, 3, 4), 'IN')
648       ->propertyOrderBy('ftid', 'DESC');
649     $this->assertEntityFieldQuery($query, array(
650       array('test_entity_bundle_key', 4),
651       array('test_entity_bundle_key', 3),
652       array('test_entity_bundle_key', 1),
653     ), t('Test "in" operation with entity entity_type condition and entity_id property condition. Sort entity_id in descending order.'), TRUE);
654
655     // Test query count
656     $query = new EntityFieldQuery();
657     $query_count = $query
658       ->entityCondition('entity_type', 'test_entity_bundle_key')
659       ->count()
660       ->execute();
661     $this->assertEqual($query_count, 6, t('Test query count on entity condition.'));
662
663     $query = new EntityFieldQuery();
664     $query_count = $query
665       ->entityCondition('entity_type', 'test_entity_bundle_key')
666       ->propertyCondition('ftid', '1')
667       ->count()
668       ->execute();
669     $this->assertEqual($query_count, 1, t('Test query count on entity and property condition.'));
670
671     $query = new EntityFieldQuery();
672     $query_count = $query
673       ->entityCondition('entity_type', 'test_entity_bundle_key')
674       ->propertyCondition('ftid', '4', '>')
675       ->count()
676       ->execute();
677     $this->assertEqual($query_count, 2, t('Test query count on entity and property condition with operator.'));
678
679     $query = new EntityFieldQuery();
680     $query_count = $query
681       ->entityCondition('entity_type', 'test_entity_bundle_key')
682       ->fieldCondition($this->fields[0], 'value', 3, '=')
683       ->count()
684       ->execute();
685     $this->assertEqual($query_count, 1, t('Test query count on field condition.'));
686
687     // First, test without options.
688     $query = new EntityFieldQuery();
689     $query
690       ->entityCondition('entity_type', 'test_entity_bundle_key')
691       ->propertyCondition('fttype', 'und', 'CONTAINS');
692     $this->assertEntityFieldQuery($query, array(
693       array('test_entity_bundle_key', 1),
694       array('test_entity_bundle_key', 2),
695       array('test_entity_bundle_key', 3),
696       array('test_entity_bundle_key', 4),
697       array('test_entity_bundle_key', 5),
698       array('test_entity_bundle_key', 6),
699     ), t('Test the "contains" operation on a property.'));
700
701     $query = new EntityFieldQuery();
702     $query->fieldCondition($this->fields[1], 'shape', 'uar', 'CONTAINS');
703     $this->assertEntityFieldQuery($query, array(
704       array('test_entity_bundle', 5),
705     ), t('Test the "contains" operation on a field.'));
706
707     $query = new EntityFieldQuery();
708     $query
709       ->entityCondition('entity_type', 'test_entity_bundle_key')
710       ->propertyCondition('ftid', 1, '=');
711     $this->assertEntityFieldQuery($query, array(
712       array('test_entity_bundle_key', 1),
713     ), t('Test the "equal to" operation on a property.'));
714
715     $query = new EntityFieldQuery();
716     $query->fieldCondition($this->fields[0], 'value', 3, '=');
717     $this->assertEntityFieldQuery($query, array(
718       array('test_entity_bundle_key', 3),
719       array('test_entity', 3),
720     ), t('Test the "equal to" operation on a field.'));
721
722     $query = new EntityFieldQuery();
723     $query
724       ->entityCondition('entity_type', 'test_entity_bundle_key')
725       ->propertyCondition('ftid', 3, '<>');
726     $this->assertEntityFieldQuery($query, array(
727       array('test_entity_bundle_key', 1),
728       array('test_entity_bundle_key', 2),
729       array('test_entity_bundle_key', 4),
730       array('test_entity_bundle_key', 5),
731       array('test_entity_bundle_key', 6),
732     ), t('Test the "not equal to" operation on a property.'));
733
734     $query = new EntityFieldQuery();
735     $query->fieldCondition($this->fields[0], 'value', 3, '<>');
736     $this->assertEntityFieldQuery($query, array(
737       array('test_entity_bundle_key', 1),
738       array('test_entity_bundle_key', 2),
739       array('test_entity_bundle_key', 4),
740       array('test_entity_bundle_key', 5),
741       array('test_entity_bundle_key', 6),
742       array('test_entity', 1),
743       array('test_entity', 2),
744       array('test_entity', 4),
745     ), t('Test the "not equal to" operation on a field.'));
746
747     $query = new EntityFieldQuery();
748     $query
749       ->entityCondition('entity_type', 'test_entity_bundle_key')
750       ->propertyCondition('ftid', 3, '!=');
751     $this->assertEntityFieldQuery($query, array(
752       array('test_entity_bundle_key', 1),
753       array('test_entity_bundle_key', 2),
754       array('test_entity_bundle_key', 4),
755       array('test_entity_bundle_key', 5),
756       array('test_entity_bundle_key', 6),
757     ), t('Test the "not equal to" operation on a property.'));
758
759     $query = new EntityFieldQuery();
760     $query->fieldCondition($this->fields[0], 'value', 3, '!=');
761     $this->assertEntityFieldQuery($query, array(
762       array('test_entity_bundle_key', 1),
763       array('test_entity_bundle_key', 2),
764       array('test_entity_bundle_key', 4),
765       array('test_entity_bundle_key', 5),
766       array('test_entity_bundle_key', 6),
767       array('test_entity', 1),
768       array('test_entity', 2),
769       array('test_entity', 4),
770     ), t('Test the "not equal to" operation on a field.'));
771
772     $query = new EntityFieldQuery();
773     $query
774       ->entityCondition('entity_type', 'test_entity_bundle_key')
775       ->propertyCondition('ftid', 2, '<');
776     $this->assertEntityFieldQuery($query, array(
777       array('test_entity_bundle_key', 1),
778     ), t('Test the "less than" operation on a property.'));
779
780     $query = new EntityFieldQuery();
781     $query->fieldCondition($this->fields[0], 'value', 2, '<');
782     $this->assertEntityFieldQuery($query, array(
783       array('test_entity_bundle_key', 1),
784       array('test_entity', 1),
785     ), t('Test the "less than" operation on a field.'));
786
787     $query = new EntityFieldQuery();
788     $query
789       ->entityCondition('entity_type', 'test_entity_bundle_key')
790       ->propertyCondition('ftid', 2, '<=');
791     $this->assertEntityFieldQuery($query, array(
792       array('test_entity_bundle_key', 1),
793       array('test_entity_bundle_key', 2),
794     ), t('Test the "less than or equal to" operation on a property.'));
795
796     $query = new EntityFieldQuery();
797     $query->fieldCondition($this->fields[0], 'value', 2, '<=');
798     $this->assertEntityFieldQuery($query, array(
799       array('test_entity_bundle_key', 1),
800       array('test_entity_bundle_key', 2),
801       array('test_entity', 1),
802       array('test_entity', 2),
803     ), t('Test the "less than or equal to" operation on a field.'));
804
805     $query = new EntityFieldQuery();
806     $query
807       ->entityCondition('entity_type', 'test_entity_bundle_key')
808       ->propertyCondition('ftid', 4, '>');
809     $this->assertEntityFieldQuery($query, array(
810       array('test_entity_bundle_key', 5),
811       array('test_entity_bundle_key', 6),
812     ), t('Test the "greater than" operation on a property.'));
813
814     $query = new EntityFieldQuery();
815     $query->fieldCondition($this->fields[0], 'value', 2, '>');
816     $this->assertEntityFieldQuery($query, array(
817       array('test_entity_bundle_key', 3),
818       array('test_entity_bundle_key', 4),
819       array('test_entity_bundle_key', 5),
820       array('test_entity_bundle_key', 6),
821       array('test_entity', 3),
822       array('test_entity', 4),
823     ), t('Test the "greater than" operation on a field.'));
824
825     $query = new EntityFieldQuery();
826     $query
827       ->entityCondition('entity_type', 'test_entity_bundle_key')
828       ->propertyCondition('ftid', 4, '>=');
829     $this->assertEntityFieldQuery($query, array(
830       array('test_entity_bundle_key', 4),
831       array('test_entity_bundle_key', 5),
832       array('test_entity_bundle_key', 6),
833     ), t('Test the "greater than or equal to" operation on a property.'));
834
835     $query = new EntityFieldQuery();
836     $query->fieldCondition($this->fields[0], 'value', 3, '>=');
837     $this->assertEntityFieldQuery($query, array(
838       array('test_entity_bundle_key', 3),
839       array('test_entity_bundle_key', 4),
840       array('test_entity_bundle_key', 5),
841       array('test_entity_bundle_key', 6),
842       array('test_entity', 3),
843       array('test_entity', 4),
844     ), t('Test the "greater than or equal to" operation on a field.'));
845
846     $query = new EntityFieldQuery();
847     $query
848       ->entityCondition('entity_type', 'test_entity_bundle_key')
849       ->propertyCondition('ftid', array(3, 4), 'NOT IN');
850     $this->assertEntityFieldQuery($query, array(
851       array('test_entity_bundle_key', 1),
852       array('test_entity_bundle_key', 2),
853       array('test_entity_bundle_key', 5),
854       array('test_entity_bundle_key', 6),
855     ), t('Test the "not in" operation on a property.'));
856
857     $query = new EntityFieldQuery();
858     $query->fieldCondition($this->fields[0], 'value', array(3, 4, 100, 101), 'NOT IN');
859     $this->assertEntityFieldQuery($query, array(
860       array('test_entity_bundle_key', 1),
861       array('test_entity_bundle_key', 2),
862       array('test_entity_bundle_key', 5),
863       array('test_entity_bundle_key', 6),
864       array('test_entity', 1),
865       array('test_entity', 2),
866     ), t('Test the "not in" operation on a field.'));
867
868     $query = new EntityFieldQuery();
869     $query
870       ->entityCondition('entity_type', 'test_entity_bundle_key')
871       ->propertyCondition('ftid', array(3, 4), 'IN');
872     $this->assertEntityFieldQuery($query, array(
873       array('test_entity_bundle_key', 3),
874       array('test_entity_bundle_key', 4),
875     ), t('Test the "in" operation on a property.'));
876
877     $query = new EntityFieldQuery();
878     $query->fieldCondition($this->fields[0], 'value', array(2, 3), 'IN');
879     $this->assertEntityFieldQuery($query, array(
880       array('test_entity_bundle_key', 2),
881       array('test_entity_bundle_key', 3),
882       array('test_entity', 2),
883       array('test_entity', 3),
884     ), t('Test the "in" operation on a field.'));
885
886     $query = new EntityFieldQuery();
887     $query
888       ->entityCondition('entity_type', 'test_entity_bundle_key')
889       ->propertyCondition('ftid', array(1, 3), 'BETWEEN');
890     $this->assertEntityFieldQuery($query, array(
891       array('test_entity_bundle_key', 1),
892       array('test_entity_bundle_key', 2),
893       array('test_entity_bundle_key', 3),
894     ), t('Test the "between" operation on a property.'));
895
896     $query = new EntityFieldQuery();
897     $query->fieldCondition($this->fields[0], 'value', array(1, 3), 'BETWEEN');
898     $this->assertEntityFieldQuery($query, array(
899       array('test_entity_bundle_key', 1),
900       array('test_entity_bundle_key', 2),
901       array('test_entity_bundle_key', 3),
902       array('test_entity', 1),
903       array('test_entity', 2),
904       array('test_entity', 3),
905     ), t('Test the "between" operation on a field.'));
906
907     $query = new EntityFieldQuery();
908     $query
909       ->entityCondition('entity_type', 'test_entity_bundle_key')
910       ->propertyCondition('fttype', 'bun', 'STARTS_WITH');
911     $this->assertEntityFieldQuery($query, array(
912       array('test_entity_bundle_key', 1),
913       array('test_entity_bundle_key', 2),
914       array('test_entity_bundle_key', 3),
915       array('test_entity_bundle_key', 4),
916       array('test_entity_bundle_key', 5),
917       array('test_entity_bundle_key', 6),
918     ), t('Test the "starts_with" operation on a property.'));
919
920     $query = new EntityFieldQuery();
921     $query->fieldCondition($this->fields[1], 'shape', 'squ', 'STARTS_WITH');
922     $this->assertEntityFieldQuery($query, array(
923       array('test_entity_bundle', 5),
924     ), t('Test the "starts_with" operation on a field.'));
925
926     $query = new EntityFieldQuery();
927     $query->fieldCondition($this->fields[0], 'value', 3);
928     $this->assertEntityFieldQuery($query, array(
929       array('test_entity_bundle_key', 3),
930       array('test_entity', 3),
931     ), t('Test omission of an operator with a single item.'));
932
933     $query = new EntityFieldQuery();
934     $query->fieldCondition($this->fields[0], 'value', array(2, 3));
935     $this->assertEntityFieldQuery($query, array(
936       array('test_entity_bundle_key', 2),
937       array('test_entity_bundle_key', 3),
938       array('test_entity', 2),
939       array('test_entity', 3),
940     ), t('Test omission of an operator with multiple items.'));
941
942     $query = new EntityFieldQuery();
943     $query
944       ->entityCondition('entity_type', 'test_entity_bundle_key')
945       ->propertyCondition('ftid', 1, '>')
946       ->fieldCondition($this->fields[0], 'value', 4, '<');
947     $this->assertEntityFieldQuery($query, array(
948       array('test_entity_bundle_key', 2),
949       array('test_entity_bundle_key', 3),
950     ), t('Test entity, property and field conditions.'));
951
952     $query = new EntityFieldQuery();
953     $query
954       ->entityCondition('entity_type', 'test_entity_bundle_key')
955       ->entityCondition('bundle', 'bundle', 'STARTS_WITH')
956       ->propertyCondition('ftid', 4)
957       ->fieldCondition($this->fields[0], 'value', 4);
958     $this->assertEntityFieldQuery($query, array(
959       array('test_entity_bundle_key', 4),
960     ), t('Test entity condition with "starts_with" operation, and property and field conditions.'));
961
962     $query = new EntityFieldQuery();
963     $query
964       ->entityCondition('entity_type', 'test_entity_bundle_key')
965       ->propertyOrderBy('ftid', 'ASC')
966       ->range(0, 2);
967     $this->assertEntityFieldQuery($query, array(
968       array('test_entity_bundle_key', 1),
969       array('test_entity_bundle_key', 2),
970     ), t('Test limit on a property.'), TRUE);
971
972     $query = new EntityFieldQuery();
973     $query
974       ->entityCondition('entity_type', 'test_entity_bundle_key')
975       ->fieldCondition($this->fields[0], 'value', 0, '>=')
976       ->fieldOrderBy($this->fields[0], 'value', 'ASC')
977       ->range(0, 2);
978     $this->assertEntityFieldQuery($query, array(
979       array('test_entity_bundle_key', 1),
980       array('test_entity_bundle_key', 2),
981     ), t('Test limit on a field.'), TRUE);
982
983     $query = new EntityFieldQuery();
984     $query
985       ->entityCondition('entity_type', 'test_entity_bundle_key')
986       ->propertyOrderBy('ftid', 'ASC')
987       ->range(4, 6);
988     $this->assertEntityFieldQuery($query, array(
989       array('test_entity_bundle_key', 5),
990       array('test_entity_bundle_key', 6),
991     ), t('Test offset on a property.'), TRUE);
992
993     $query = new EntityFieldQuery();
994     $query
995       ->entityCondition('entity_type', 'test_entity_bundle_key')
996       ->fieldCondition($this->fields[0], 'value', 0, '>')
997       ->fieldOrderBy($this->fields[0], 'value', 'ASC')
998       ->range(2, 4);
999     $this->assertEntityFieldQuery($query, array(
1000       array('test_entity_bundle_key', 3),
1001       array('test_entity_bundle_key', 4),
1002       array('test_entity_bundle_key', 5),
1003       array('test_entity_bundle_key', 6),
1004     ), t('Test offset on a field.'), TRUE);
1005
1006     for ($i = 6; $i < 10; $i++) {
1007       $entity = new stdClass();
1008       $entity->ftid = $i;
1009       $entity->fttype = 'test_entity_bundle';
1010       $entity->{$this->field_names[0]}[LANGUAGE_NONE][0]['value'] = $i - 5;
1011       drupal_write_record('test_entity_bundle', $entity);
1012       field_attach_insert('test_entity_bundle', $entity);
1013     }
1014
1015     $query = new EntityFieldQuery();
1016     $query->fieldCondition($this->fields[0], 'value', 2, '>');
1017     $this->assertEntityFieldQuery($query, array(
1018       array('test_entity_bundle_key', 3),
1019       array('test_entity_bundle_key', 4),
1020       array('test_entity_bundle_key', 5),
1021       array('test_entity_bundle_key', 6),
1022       array('test_entity', 3),
1023       array('test_entity', 4),
1024       array('test_entity_bundle', 8),
1025       array('test_entity_bundle', 9),
1026     ), t('Select a field across multiple entities.'));
1027
1028     $query = new EntityFieldQuery();
1029     $query
1030       ->fieldCondition($this->fields[1], 'shape', 'square')
1031       ->fieldCondition($this->fields[1], 'color', 'blue');
1032     $this->assertEntityFieldQuery($query, array(
1033       array('test_entity_bundle', 5),
1034     ), t('Test without a delta group.'));
1035
1036     $query = new EntityFieldQuery();
1037     $query
1038       ->fieldCondition($this->fields[1], 'shape', 'square', '=', 'group')
1039       ->fieldCondition($this->fields[1], 'color', 'blue', '=', 'group');
1040     $this->assertEntityFieldQuery($query, array(), t('Test with a delta group.'));
1041
1042     // Test query on a deleted field.
1043     field_attach_delete_bundle('test_entity_bundle_key', 'bundle1');
1044     field_attach_delete_bundle('test_entity', 'test_bundle');
1045     $query = new EntityFieldQuery();
1046     $query->fieldCondition($this->fields[0], 'value', '3');
1047     $this->assertEntityFieldQuery($query, array(
1048       array('test_entity_bundle', 8),
1049     ), t('Test query on a field after deleting field from some entities.'));
1050
1051     field_attach_delete_bundle('test_entity_bundle', 'test_entity_bundle');
1052     $query = new EntityFieldQuery();
1053     $query->fieldCondition($this->fields[0], 'value', '3');
1054     $this->assertEntityFieldQuery($query, array(), t('Test query on a field after deleting field from all entities.'));
1055
1056     $query = new EntityFieldQuery();
1057     $query
1058       ->fieldCondition($this->fields[0], 'value', '3')
1059       ->deleted(TRUE);
1060     $this->assertEntityFieldQuery($query, array(
1061       array('test_entity_bundle_key', 3),
1062       array('test_entity_bundle', 8),
1063       array('test_entity', 3),
1064     ), t('Test query on a deleted field with deleted option set to TRUE.'));
1065
1066     $pass = FALSE;
1067     $query = new EntityFieldQuery();
1068     try {
1069       $query->execute();
1070     }
1071     catch (EntityFieldQueryException $exception) {
1072       $pass = ($exception->getMessage() == t('For this query an entity type must be specified.'));
1073     }
1074     $this->assertTrue($pass, t("Can't query the universe."));
1075   }
1076
1077   /**
1078    * Tests querying translatable fields.
1079    */
1080   function testEntityFieldQueryTranslatable() {
1081
1082     // Make a test field translatable AND cardinality one.
1083     $this->fields[0]['translatable'] = TRUE;
1084     $this->fields[0]['cardinality'] = 1;
1085     field_update_field($this->fields[0]);
1086     field_test_entity_info_translatable('test_entity', TRUE);
1087
1088     // Create more items with different languages.
1089     $entity = new stdClass();
1090     $entity->ftid = 1;
1091     $entity->ftvid = 1;
1092     $entity->fttype = 'test_bundle';
1093
1094     // Set fields in two languages with one field value.
1095     foreach (array(LANGUAGE_NONE, 'en') as $langcode) {
1096       $entity->{$this->field_names[0]}[$langcode][0]['value'] = 1234;
1097     }
1098
1099     field_attach_update('test_entity', $entity);
1100
1101     // Look up number of results when querying a single entity with multilingual
1102     // field values.
1103     $query = new EntityFieldQuery();
1104     $query_count = $query
1105       ->entityCondition('entity_type', 'test_entity')
1106       ->entityCondition('bundle', 'test_bundle')
1107       ->entityCondition('entity_id', '1')
1108       ->fieldCondition($this->fields[0])
1109       ->count()
1110       ->execute();
1111
1112     $this->assertEqual($query_count, 1, t("Count on translatable cardinality one field is correct."));
1113   }
1114
1115   /**
1116    * Tests field meta conditions.
1117    */
1118   function testEntityFieldQueryMetaConditions() {
1119     // Make a test field translatable.
1120     $this->fields[0]['translatable'] = TRUE;
1121     field_update_field($this->fields[0]);
1122     field_test_entity_info_translatable('test_entity', TRUE);
1123
1124     // Create more items with different languages.
1125     $entity = new stdClass();
1126     $entity->ftid = 1;
1127     $entity->ftvid = 1;
1128     $entity->fttype = 'test_bundle';
1129     $j = 0;
1130
1131     foreach (array(LANGUAGE_NONE, 'en') as $langcode) {
1132       for ($i = 0; $i < 4; $i++) {
1133         $entity->{$this->field_names[0]}[$langcode][$i]['value'] = $i + $j;
1134       }
1135       $j += 4;
1136     }
1137
1138     field_attach_update('test_entity', $entity);
1139
1140     // Test delta field meta condition.
1141     $query = new EntityFieldQuery();
1142     $query
1143       ->entityCondition('entity_type', 'test_entity', '=')
1144       ->fieldDeltaCondition($this->fields[0], 0, '>');
1145     $this->assertEntityFieldQuery($query, array(
1146       array('test_entity', 1),
1147     ), t('Test with a delta meta condition.'));
1148
1149     // Test language field meta condition.
1150     $query = new EntityFieldQuery();
1151     $query
1152       ->entityCondition('entity_type', 'test_entity', '=')
1153       ->fieldLanguageCondition($this->fields[0], LANGUAGE_NONE, '<>');
1154     $this->assertEntityFieldQuery($query, array(
1155       array('test_entity', 1),
1156     ), t('Test with a language meta condition.'));
1157
1158     // Test language field meta condition.
1159     $query = new EntityFieldQuery();
1160     $query
1161       ->entityCondition('entity_type', 'test_entity', '=')
1162       ->fieldLanguageCondition($this->fields[0], LANGUAGE_NONE, '!=');
1163     $this->assertEntityFieldQuery($query, array(
1164       array('test_entity', 1),
1165     ), t('Test with a language meta condition.'));
1166
1167     // Test delta grouping.
1168     $query = new EntityFieldQuery();
1169     $query
1170       ->entityCondition('entity_type', 'test_entity', '=')
1171       ->fieldCondition($this->fields[0], 'value', 0, '=', 'group')
1172       ->fieldDeltaCondition($this->fields[0], 1, '<', 'group');
1173     $this->assertEntityFieldQuery($query, array(
1174       array('test_entity', 1),
1175     ), t('Test with a grouped delta meta condition.'));
1176
1177     $query = new EntityFieldQuery();
1178     $query
1179       ->entityCondition('entity_type', 'test_entity', '=')
1180       ->fieldCondition($this->fields[0], 'value', 0, '=', 'group')
1181       ->fieldDeltaCondition($this->fields[0], 1, '>=', 'group');
1182     $this->assertEntityFieldQuery($query, array(), t('Test with a grouped delta meta condition (empty result set).'));
1183
1184     // Test language grouping.
1185     $query = new EntityFieldQuery();
1186     $query
1187       ->entityCondition('entity_type', 'test_entity', '=')
1188       ->fieldCondition($this->fields[0], 'value', 0, '=', NULL, 'group')
1189       ->fieldLanguageCondition($this->fields[0], 'en', '<>', NULL, 'group');
1190     $this->assertEntityFieldQuery($query, array(
1191       array('test_entity', 1),
1192     ), t('Test with a grouped language meta condition.'));
1193
1194     // Test language grouping.
1195     $query = new EntityFieldQuery();
1196     $query
1197       ->entityCondition('entity_type', 'test_entity', '=')
1198       ->fieldCondition($this->fields[0], 'value', 0, '=', NULL, 'group')
1199       ->fieldLanguageCondition($this->fields[0], 'en', '!=', NULL, 'group');
1200     $this->assertEntityFieldQuery($query, array(
1201       array('test_entity', 1),
1202     ), t('Test with a grouped language meta condition.'));
1203
1204     $query = new EntityFieldQuery();
1205     $query
1206       ->entityCondition('entity_type', 'test_entity', '=')
1207       ->fieldCondition($this->fields[0], 'value', 0, '=', NULL, 'group')
1208       ->fieldLanguageCondition($this->fields[0], LANGUAGE_NONE, '<>', NULL, 'group');
1209     $this->assertEntityFieldQuery($query, array(), t('Test with a grouped language meta condition (empty result set).'));
1210
1211     $query = new EntityFieldQuery();
1212     $query
1213       ->entityCondition('entity_type', 'test_entity', '=')
1214       ->fieldCondition($this->fields[0], 'value', 0, '=', NULL, 'group')
1215       ->fieldLanguageCondition($this->fields[0], LANGUAGE_NONE, '!=', NULL, 'group');
1216     $this->assertEntityFieldQuery($query, array(), t('Test with a grouped language meta condition (empty result set).'));
1217
1218     // Test delta and language grouping.
1219     $query = new EntityFieldQuery();
1220     $query
1221       ->entityCondition('entity_type', 'test_entity', '=')
1222       ->fieldCondition($this->fields[0], 'value', 0, '=', 'delta', 'language')
1223       ->fieldDeltaCondition($this->fields[0], 1, '<', 'delta', 'language')
1224       ->fieldLanguageCondition($this->fields[0], 'en', '<>', 'delta', 'language');
1225     $this->assertEntityFieldQuery($query, array(
1226       array('test_entity', 1),
1227     ), t('Test with a grouped delta + language meta condition.'));
1228
1229     // Test delta and language grouping.
1230     $query = new EntityFieldQuery();
1231     $query
1232       ->entityCondition('entity_type', 'test_entity', '=')
1233       ->fieldCondition($this->fields[0], 'value', 0, '=', 'delta', 'language')
1234       ->fieldDeltaCondition($this->fields[0], 1, '<', 'delta', 'language')
1235       ->fieldLanguageCondition($this->fields[0], 'en', '!=', 'delta', 'language');
1236     $this->assertEntityFieldQuery($query, array(
1237       array('test_entity', 1),
1238     ), t('Test with a grouped delta + language meta condition.'));
1239
1240     $query = new EntityFieldQuery();
1241     $query
1242       ->entityCondition('entity_type', 'test_entity', '=')
1243       ->fieldCondition($this->fields[0], 'value', 0, '=', 'delta', 'language')
1244       ->fieldDeltaCondition($this->fields[0], 1, '>=', 'delta', 'language')
1245       ->fieldLanguageCondition($this->fields[0], 'en', '<>', 'delta', 'language');
1246     $this->assertEntityFieldQuery($query, array(), t('Test with a grouped delta + language meta condition (empty result set, delta condition unsatisifed).'));
1247
1248     $query = new EntityFieldQuery();
1249     $query
1250       ->entityCondition('entity_type', 'test_entity', '=')
1251       ->fieldCondition($this->fields[0], 'value', 0, '=', 'delta', 'language')
1252       ->fieldDeltaCondition($this->fields[0], 1, '>=', 'delta', 'language')
1253       ->fieldLanguageCondition($this->fields[0], 'en', '!=', 'delta', 'language');
1254     $this->assertEntityFieldQuery($query, array(), t('Test with a grouped delta + language meta condition (empty result set, delta condition unsatisifed).'));
1255
1256     $query = new EntityFieldQuery();
1257     $query
1258       ->entityCondition('entity_type', 'test_entity', '=')
1259       ->fieldCondition($this->fields[0], 'value', 0, '=', 'delta', 'language')
1260       ->fieldDeltaCondition($this->fields[0], 1, '<', 'delta', 'language')
1261       ->fieldLanguageCondition($this->fields[0], LANGUAGE_NONE, '<>', 'delta', 'language');
1262     $this->assertEntityFieldQuery($query, array(), t('Test with a grouped delta + language meta condition (empty result set, language condition unsatisifed).'));
1263
1264     $query = new EntityFieldQuery();
1265     $query
1266       ->entityCondition('entity_type', 'test_entity', '=')
1267       ->fieldCondition($this->fields[0], 'value', 0, '=', 'delta', 'language')
1268       ->fieldDeltaCondition($this->fields[0], 1, '<', 'delta', 'language')
1269       ->fieldLanguageCondition($this->fields[0], LANGUAGE_NONE, '!=', 'delta', 'language');
1270     $this->assertEntityFieldQuery($query, array(), t('Test with a grouped delta + language meta condition (empty result set, language condition unsatisifed).'));
1271
1272     $query = new EntityFieldQuery();
1273     $query
1274       ->entityCondition('entity_type', 'test_entity', '=')
1275       ->fieldCondition($this->fields[0], 'value', 0, '=', 'delta', 'language')
1276       ->fieldDeltaCondition($this->fields[0], 1, '>=', 'delta', 'language')
1277       ->fieldLanguageCondition($this->fields[0], LANGUAGE_NONE, '<>', 'delta', 'language');
1278     $this->assertEntityFieldQuery($query, array(), t('Test with a grouped delta + language meta condition (empty result set, both conditions unsatisifed).'));
1279
1280     $query = new EntityFieldQuery();
1281     $query
1282       ->entityCondition('entity_type', 'test_entity', '=')
1283       ->fieldCondition($this->fields[0], 'value', 0, '=', 'delta', 'language')
1284       ->fieldDeltaCondition($this->fields[0], 1, '>=', 'delta', 'language')
1285       ->fieldLanguageCondition($this->fields[0], LANGUAGE_NONE, '!=', 'delta', 'language');
1286     $this->assertEntityFieldQuery($query, array(), t('Test with a grouped delta + language meta condition (empty result set, both conditions unsatisifed).'));
1287
1288     // Test grouping with another field to ensure that grouping cache is reset
1289     // properly.
1290     $query = new EntityFieldQuery();
1291     $query
1292       ->entityCondition('entity_type', 'test_entity_bundle', '=')
1293       ->fieldCondition($this->fields[1], 'shape', 'circle', '=', 'delta', 'language')
1294       ->fieldCondition($this->fields[1], 'color', 'blue', '=', 'delta', 'language')
1295       ->fieldDeltaCondition($this->fields[1], 1, '=', 'delta', 'language')
1296       ->fieldLanguageCondition($this->fields[1], LANGUAGE_NONE, '=', 'delta', 'language');
1297     $this->assertEntityFieldQuery($query, array(
1298       array('test_entity_bundle', 5),
1299     ), t('Test grouping cache.'));
1300   }
1301
1302   /**
1303    * Tests the routing feature of EntityFieldQuery.
1304    */
1305   function testEntityFieldQueryRouting() {
1306     // Entity-only query.
1307     $query = new EntityFieldQuery();
1308     $query->entityCondition('entity_type', 'test_entity_bundle_key');
1309     $this->assertIdentical($query->queryCallback(), array($query, 'propertyQuery'), t('Entity-only queries are handled by the propertyQuery handler.'));
1310
1311     // Field-only query.
1312     $query = new EntityFieldQuery();
1313     $query->fieldCondition($this->fields[0], 'value', '3');
1314     $this->assertIdentical($query->queryCallback(), 'field_sql_storage_field_storage_query', t('Pure field queries are handled by the Field storage handler.'));
1315
1316     // Mixed entity and field query.
1317     $query = new EntityFieldQuery();
1318     $query
1319       ->entityCondition('entity_type', 'test_entity_bundle_key')
1320       ->fieldCondition($this->fields[0], 'value', '3');
1321     $this->assertIdentical($query->queryCallback(), 'field_sql_storage_field_storage_query', t('Mixed queries are handled by the Field storage handler.'));
1322
1323     // Overriding with $query->executeCallback.
1324     $query = new EntityFieldQuery();
1325     $query->entityCondition('entity_type', 'test_entity_bundle_key');
1326     $query->executeCallback = 'field_test_dummy_field_storage_query';
1327     $this->assertEntityFieldQuery($query, array(
1328       array('user', 1),
1329     ), t('executeCallback can override the query handler.'));
1330
1331     // Overriding with $query->executeCallback via hook_entity_query_alter().
1332     $query = new EntityFieldQuery();
1333     $query->entityCondition('entity_type', 'test_entity_bundle_key');
1334     // Add a flag that will be caught by field_test_entity_query_alter().
1335     $query->alterMyExecuteCallbackPlease = TRUE;
1336     $this->assertEntityFieldQuery($query, array(
1337       array('user', 1),
1338     ), t('executeCallback can override the query handler when set in a hook_entity_query_alter().'));
1339
1340     // Mixed-storage queries.
1341     $query = new EntityFieldQuery();
1342     $query
1343       ->fieldCondition($this->fields[0], 'value', '3')
1344       ->fieldCondition($this->fields[1], 'shape', 'squ', 'STARTS_WITH');
1345     // Alter the storage of the field.
1346     $query->fields[1]['storage']['module'] = 'dummy_storage';
1347     try {
1348       $query->queryCallback();
1349     }
1350     catch (EntityFieldQueryException $exception) {
1351       $pass = ($exception->getMessage() == t("Can't handle more than one field storage engine"));
1352     }
1353     $this->assertTrue($pass, t('Cannot query across field storage engines.'));
1354   }
1355
1356   /**
1357    * Tests the pager integration of EntityFieldQuery.
1358    */
1359   function testEntityFieldQueryPager() {
1360     // Test pager in propertyQuery
1361     $_GET['page'] = '0,1';
1362     $query = new EntityFieldQuery();
1363     $query
1364       ->entityCondition('entity_type', 'test_entity_bundle_key')
1365       ->propertyOrderBy('ftid', 'ASC')
1366       ->pager(3, 0);
1367     $this->assertEntityFieldQuery($query, array(
1368       array('test_entity_bundle_key', 1),
1369       array('test_entity_bundle_key', 2),
1370       array('test_entity_bundle_key', 3),
1371     ), t('Test pager integration in propertyQuery: page 1.'), TRUE);
1372
1373     $query = new EntityFieldQuery();
1374     $query
1375       ->entityCondition('entity_type', 'test_entity_bundle_key')
1376       ->propertyOrderBy('ftid', 'ASC')
1377       ->pager(3, 1);
1378     $this->assertEntityFieldQuery($query, array(
1379       array('test_entity_bundle_key', 4),
1380       array('test_entity_bundle_key', 5),
1381       array('test_entity_bundle_key', 6),
1382     ), t('Test pager integration in propertyQuery: page 2.'), TRUE);
1383
1384     // Test pager in field storage
1385     $_GET['page'] = '0,1';
1386     $query = new EntityFieldQuery();
1387     $query
1388       ->entityCondition('entity_type', 'test_entity_bundle_key')
1389       ->fieldCondition($this->fields[0], 'value', 0, '>')
1390       ->propertyOrderBy('ftid', 'ASC')
1391       ->pager(2, 0);
1392     $this->assertEntityFieldQuery($query, array(
1393       array('test_entity_bundle_key', 1),
1394       array('test_entity_bundle_key', 2),
1395     ), t('Test pager integration in field storage: page 1.'), TRUE);
1396
1397     $query = new EntityFieldQuery();
1398     $query
1399       ->entityCondition('entity_type', 'test_entity_bundle_key')
1400       ->fieldCondition($this->fields[0], 'value', 0, '>')
1401       ->propertyOrderBy('ftid', 'ASC')
1402       ->pager(2, 1);
1403     $this->assertEntityFieldQuery($query, array(
1404       array('test_entity_bundle_key', 3),
1405       array('test_entity_bundle_key', 4),
1406     ), t('Test pager integration in field storage: page 2.'), TRUE);
1407
1408     unset($_GET['page']);
1409   }
1410
1411   /**
1412    * Tests disabling the pager in EntityFieldQuery.
1413    */
1414   function testEntityFieldQueryDisablePager() {
1415     // Test enabling a pager and then disabling it.
1416     $query = new EntityFieldQuery();
1417     $query
1418       ->entityCondition('entity_type', 'test_entity_bundle_key')
1419       ->propertyOrderBy('ftid', 'ASC')
1420       ->pager(1)
1421       ->pager(0);
1422     $this->assertEntityFieldQuery($query, array(
1423       array('test_entity_bundle_key', 1),
1424       array('test_entity_bundle_key', 2),
1425       array('test_entity_bundle_key', 3),
1426       array('test_entity_bundle_key', 4),
1427       array('test_entity_bundle_key', 5),
1428       array('test_entity_bundle_key', 6),
1429     ), 'All test entities are listed when the pager is enabled and then disabled.', TRUE);
1430   }
1431
1432   /**
1433    * Tests the TableSort integration of EntityFieldQuery.
1434    */
1435   function testEntityFieldQueryTableSort() {
1436     // Test TableSort in propertyQuery
1437     $_GET['sort'] = 'asc';
1438     $_GET['order'] = 'Id';
1439     $header = array(
1440       'id' => array('data' => 'Id', 'type' => 'property',  'specifier' => 'ftid'),
1441       'type' => array('data' => 'Type', 'type' => 'entity', 'specifier' => 'bundle'),
1442     );
1443     $query = new EntityFieldQuery();
1444     $query
1445       ->entityCondition('entity_type', 'test_entity_bundle_key')
1446       ->tableSort($header);
1447     $this->assertEntityFieldQuery($query, array(
1448       array('test_entity_bundle_key', 1),
1449       array('test_entity_bundle_key', 2),
1450       array('test_entity_bundle_key', 3),
1451       array('test_entity_bundle_key', 4),
1452       array('test_entity_bundle_key', 5),
1453       array('test_entity_bundle_key', 6),
1454     ), t('Test TableSort by property: ftid ASC in propertyQuery.'), TRUE);
1455
1456     $_GET['sort'] = 'desc';
1457     $_GET['order'] = 'Id';
1458     $query = new EntityFieldQuery();
1459     $query
1460       ->entityCondition('entity_type', 'test_entity_bundle_key')
1461       ->tableSort($header);
1462     $this->assertEntityFieldQuery($query, array(
1463       array('test_entity_bundle_key', 6),
1464       array('test_entity_bundle_key', 5),
1465       array('test_entity_bundle_key', 4),
1466       array('test_entity_bundle_key', 3),
1467       array('test_entity_bundle_key', 2),
1468       array('test_entity_bundle_key', 1),
1469     ), t('Test TableSort by property: ftid DESC in propertyQuery.'), TRUE);
1470
1471     $_GET['sort'] = 'asc';
1472     $_GET['order'] = 'Type';
1473     $query = new EntityFieldQuery();
1474     $query
1475       ->entityCondition('entity_type', 'test_entity_bundle_key')
1476       ->tableSort($header);
1477     $this->assertEntityFieldQuery($query, array(
1478       array('test_entity_bundle_key', 1),
1479       array('test_entity_bundle_key', 2),
1480       array('test_entity_bundle_key', 3),
1481       array('test_entity_bundle_key', 4),
1482       array('test_entity_bundle_key', 5),
1483       array('test_entity_bundle_key', 6),
1484     ), t('Test TableSort by entity: bundle ASC in propertyQuery.'), TRUE);
1485
1486     $_GET['sort'] = 'desc';
1487     $_GET['order'] = 'Type';
1488     $query = new EntityFieldQuery();
1489     $query
1490       ->entityCondition('entity_type', 'test_entity_bundle_key')
1491       ->tableSort($header);
1492     $this->assertEntityFieldQuery($query, array(
1493       array('test_entity_bundle_key', 5),
1494       array('test_entity_bundle_key', 6),
1495       array('test_entity_bundle_key', 1),
1496       array('test_entity_bundle_key', 2),
1497       array('test_entity_bundle_key', 3),
1498       array('test_entity_bundle_key', 4),
1499     ), t('Test TableSort by entity: bundle DESC in propertyQuery.'), TRUE);
1500
1501     // Test TableSort in field storage
1502     $_GET['sort'] = 'asc';
1503     $_GET['order'] = 'Id';
1504     $header = array(
1505       'id' => array('data' => 'Id', 'type' => 'property',  'specifier' => 'ftid'),
1506       'type' => array('data' => 'Type', 'type' => 'entity', 'specifier' => 'bundle'),
1507       'field' => array('data' => 'Field', 'type' => 'field', 'specifier' => array('field' => $this->field_names[0], 'column' => 'value')),
1508     );
1509     $query = new EntityFieldQuery();
1510     $query
1511       ->entityCondition('entity_type', 'test_entity_bundle_key')
1512       ->fieldCondition($this->fields[0], 'value', 0, '>')
1513       ->tableSort($header);
1514     $this->assertEntityFieldQuery($query, array(
1515       array('test_entity_bundle_key', 1),
1516       array('test_entity_bundle_key', 2),
1517       array('test_entity_bundle_key', 3),
1518       array('test_entity_bundle_key', 4),
1519       array('test_entity_bundle_key', 5),
1520       array('test_entity_bundle_key', 6),
1521     ), t('Test TableSort by property: ftid ASC in field storage.'), TRUE);
1522
1523     $_GET['sort'] = 'desc';
1524     $_GET['order'] = 'Id';
1525     $query = new EntityFieldQuery();
1526     $query
1527       ->entityCondition('entity_type', 'test_entity_bundle_key')
1528       ->fieldCondition($this->fields[0], 'value', 0, '>')
1529       ->tableSort($header);
1530     $this->assertEntityFieldQuery($query, array(
1531       array('test_entity_bundle_key', 6),
1532       array('test_entity_bundle_key', 5),
1533       array('test_entity_bundle_key', 4),
1534       array('test_entity_bundle_key', 3),
1535       array('test_entity_bundle_key', 2),
1536       array('test_entity_bundle_key', 1),
1537     ), t('Test TableSort by property: ftid DESC in field storage.'), TRUE);
1538
1539     $_GET['sort'] = 'asc';
1540     $_GET['order'] = 'Type';
1541     $query = new EntityFieldQuery();
1542     $query
1543       ->entityCondition('entity_type', 'test_entity_bundle_key')
1544       ->fieldCondition($this->fields[0], 'value', 0, '>')
1545       ->tableSort($header)
1546       ->entityOrderBy('entity_id', 'DESC');
1547     $this->assertEntityFieldQuery($query, array(
1548       array('test_entity_bundle_key', 4),
1549       array('test_entity_bundle_key', 3),
1550       array('test_entity_bundle_key', 2),
1551       array('test_entity_bundle_key', 1),
1552       array('test_entity_bundle_key', 6),
1553       array('test_entity_bundle_key', 5),
1554     ), t('Test TableSort by entity: bundle ASC in field storage.'), TRUE);
1555
1556     $_GET['sort'] = 'desc';
1557     $_GET['order'] = 'Type';
1558     $query = new EntityFieldQuery();
1559     $query
1560       ->entityCondition('entity_type', 'test_entity_bundle_key')
1561       ->fieldCondition($this->fields[0], 'value', 0, '>')
1562       ->tableSort($header)
1563       ->entityOrderBy('entity_id', 'ASC');
1564     $this->assertEntityFieldQuery($query, array(
1565       array('test_entity_bundle_key', 5),
1566       array('test_entity_bundle_key', 6),
1567       array('test_entity_bundle_key', 1),
1568       array('test_entity_bundle_key', 2),
1569       array('test_entity_bundle_key', 3),
1570       array('test_entity_bundle_key', 4),
1571     ), t('Test TableSort by entity: bundle DESC in field storage.'), TRUE);
1572
1573     $_GET['sort'] = 'asc';
1574     $_GET['order'] = 'Field';
1575     $query = new EntityFieldQuery();
1576     $query
1577       ->entityCondition('entity_type', 'test_entity_bundle_key')
1578       ->fieldCondition($this->fields[0], 'value', 0, '>')
1579       ->tableSort($header);
1580     $this->assertEntityFieldQuery($query, array(
1581       array('test_entity_bundle_key', 1),
1582       array('test_entity_bundle_key', 2),
1583       array('test_entity_bundle_key', 3),
1584       array('test_entity_bundle_key', 4),
1585       array('test_entity_bundle_key', 5),
1586       array('test_entity_bundle_key', 6),
1587     ), t('Test TableSort by field ASC.'), TRUE);
1588
1589     $_GET['sort'] = 'desc';
1590     $_GET['order'] = 'Field';
1591     $query = new EntityFieldQuery();
1592     $query
1593       ->entityCondition('entity_type', 'test_entity_bundle_key')
1594       ->fieldCondition($this->fields[0], 'value', 0, '>')
1595       ->tableSort($header);
1596     $this->assertEntityFieldQuery($query, array(
1597       array('test_entity_bundle_key', 6),
1598       array('test_entity_bundle_key', 5),
1599       array('test_entity_bundle_key', 4),
1600       array('test_entity_bundle_key', 3),
1601       array('test_entity_bundle_key', 2),
1602       array('test_entity_bundle_key', 1),
1603     ), t('Test TableSort by field DESC.'), TRUE);
1604
1605     unset($_GET['sort']);
1606     unset($_GET['order']);
1607   }
1608
1609   /**
1610    * Fetches the results of an EntityFieldQuery and compares.
1611    *
1612    * @param $query
1613    *   An EntityFieldQuery to run.
1614    * @param $intended_results
1615    *   A list of results, every entry is again a list, first being the entity
1616    *   type, the second being the entity_id.
1617    * @param $message
1618    *   The message to be displayed as the result of this test.
1619    * @param $ordered
1620    *   If FALSE then the result of EntityFieldQuery will match
1621    *   $intended_results even if the order is not the same. If TRUE then order
1622    *   should match too.
1623    */
1624   function assertEntityFieldQuery($query, $intended_results, $message, $ordered = FALSE) {
1625     $results = array();
1626     try {
1627       foreach ($query->execute() as $entity_type => $entity_ids) {
1628         foreach ($entity_ids as $entity_id => $stub_entity) {
1629           $results[] = array($entity_type, $entity_id);
1630         }
1631       }
1632       if (!isset($ordered) || !$ordered) {
1633         sort($results);
1634         sort($intended_results);
1635       }
1636       $this->assertEqual($results, $intended_results, $message);
1637     }
1638     catch (Exception $e) {
1639       $this->fail('Exception thrown: '. $e->getMessage());
1640     }
1641   }
1642 }