<?php

/**

* @group taxonomy

*/

class Tests_Term_getTerms extends WP_UnitTestCase {

protected static $taxonomy = 'wptests_tax_3';

public function set_up() {

parent::set_up();

register_taxonomy( self::$taxonomy, 'post', array( 'hierarchical' => true ) );

_clean_term_filters();

wp_cache_delete( 'last_changed', 'terms' );

}

public static function wpSetUpBeforeClass( WP_UnitTest_Factory $factory ) {

register_taxonomy( self::$taxonomy, 'page', array( 'hierarchical' => true ) );

$term_id1 = $factory->term->create(

array(

'name' => 'Foo',

'slug' => 'Foo',

'taxonomy' => self::$taxonomy,

)

);

$term_id2 = $factory->term->create(

array(

'name' => 'Bar',

'slug' => 'bar',

'taxonomy' => self::$taxonomy,

)

);

$posts = $factory->post->create_many( 3, array( 'post_type' => 'page' ) );

foreach ( $posts as $i => $post ) {

wp_set_object_terms( $post, array( $term_id1, $term_id2 ), self::$taxonomy );

}

}

/**

* @ticket 37568

*/

public function test_meta_query_args_only() {

register_taxonomy( 'wptests_tax', 'post', array( 'hierarchical' => true ) );

$term1 = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax' ) );

$term2 = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax' ) );

$post = self::factory()->post->create( array( 'post_type' => 'post' ) );

update_term_meta( $term1, 'somekey', 'thevalue' );

wp_set_post_terms( $post, array( $term1, $term2 ), 'wptests_tax' );

$found = get_terms(

array(

'meta_key' => 'somekey',

'meta_value' => 'thevalue',

)

);

$this->assertSameSets( array( $term1 ), wp_list_pluck( $found, 'term_id' ) );

}

/**

* @ticket 35495

*/

public function test_should_accept_an_args_array_containing_taxonomy_for_first_parameter() {

register_taxonomy( 'wptests_tax', 'post' );

$term = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax' ) );

$found = get_terms(

array(

'taxonomy' => 'wptests_tax',

'hide_empty' => false,

'fields' => 'ids',

'update_term_meta_cache' => false,

)

);

$this->assertSameSets( array( $term ), $found );

}

/**

* @ticket 35495

* @ticket 35381

*/

public function test_legacy_params_as_query_string_should_be_properly_parsed() {

register_taxonomy( 'wptests_tax', 'post' );

$term = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax' ) );

$found = get_terms( 'wptests_tax', 'hide_empty=0&fields=ids&update_term_meta_cache=0' );

$this->assertSameSets( array( $term ), $found );

}

/**

* @ticket 35495

* @ticket 35381

*/

public function test_new_params_as_query_string_should_be_properly_parsed() {

register_taxonomy( 'wptests_tax', 'post' );

$term = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax' ) );

$found = get_terms( 'taxonomy=wptests_tax&hide_empty=0&fields=ids&update_term_meta_cache=0' );

$this->assertSameSets( array( $term ), $found );

}

/**

* @ticket 35495

*/

public function test_excluding_taxonomy_arg_should_return_terms_from_all_taxonomies() {

register_taxonomy( 'wptests_tax1', 'post' );

register_taxonomy( 'wptests_tax2', 'post' );

$t1 = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax1' ) );

$t2 = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax2' ) );

$found = get_terms(

array(

'hide_empty' => false,

'fields' => 'ids',

'update_term_meta_cache' => false,

)

);

// There may be other terms lying around, so don't do an exact match.

$this->assertContains( $t1, $found );

$this->assertContains( $t2, $found );

}

/**

* @ticket 23326

*/

public function test_get_terms_cache() {

$this->set_up_three_posts_and_tags();

$num_queries = get_num_queries();

// last_changed and num_queries should bump.

$terms = get_terms( 'post_tag', array( 'update_term_meta_cache' => false ) );

$this->assertCount( 3, $terms );

$time1 = wp_cache_get( 'last_changed', 'terms' );

$this->assertNotEmpty( $time1 );

$this->assertSame( $num_queries + 2, get_num_queries() );

$num_queries = get_num_queries();

// Again. last_changed and num_queries should remain the same.

$terms = get_terms( 'post_tag', array( 'update_term_meta_cache' => false ) );

$this->assertCount( 3, $terms );

$this->assertSame( $time1, wp_cache_get( 'last_changed', 'terms' ) );

$this->assertSame( $num_queries, get_num_queries() );

}

/**

* @ticket 23326

*/

public function test_get_terms_cache_should_be_missed_when_passing_number() {

global $wpdb;

$this->set_up_three_posts_and_tags();

// Prime cache.

$terms = get_terms( 'post_tag' );

$time1 = wp_cache_get( 'last_changed', 'terms' );

$num_queries = get_num_queries();

// num_queries should bump, last_changed should remain the same.

$terms = get_terms( 'post_tag', array( 'number' => 2 ) );

$this->assertCount( 2, $terms );

$this->assertSame( $time1, wp_cache_get( 'last_changed', 'terms' ) );

$this->assertSame( $num_queries + 1, get_num_queries() );

$num_queries = get_num_queries();

// Again. last_changed and num_queries should remain the same.

$terms = get_terms( 'post_tag', array( 'number' => 2 ) );

$this->assertCount( 2, $terms );

$this->assertSame( $time1, wp_cache_get( 'last_changed', 'terms' ) );

$this->assertSame( $num_queries, get_num_queries() );

}

/**

* @ticket 23326

*/

public function test_wp_delete_term_should_invalidate_cache() {

global $wpdb;

$this->set_up_three_posts_and_tags();

// Prime cache.

$terms = get_terms( 'post_tag' );

$time1 = wp_cache_get( 'last_changed', 'terms' );

$num_queries = get_num_queries();

// Force last_changed to bump.

wp_delete_term( $terms[0]->term_id, 'post_tag' );

$num_queries = get_num_queries();

$time2 = wp_cache_get( 'last_changed', 'terms' );

$this->assertNotEquals( $time1, $time2 );

// last_changed and num_queries should bump after a term is deleted.

$terms = get_terms( 'post_tag' );

$this->assertCount( 2, $terms );

$this->assertSame( $time2, wp_cache_get( 'last_changed', 'terms' ) );

$this->assertSame( $num_queries + 1, get_num_queries() );

$num_queries = get_num_queries();

// Again. last_changed and num_queries should remain the same.

$terms = get_terms( 'post_tag' );

$this->assertCount( 2, $terms );

$this->assertSame( $time2, wp_cache_get( 'last_changed', 'terms' ) );

$this->assertSame( $num_queries, get_num_queries() );

// @todo Repeat with term insert and update.

}

/**

* @ticket 23506

*/

public function test_get_terms_should_allow_arbitrary_indexed_taxonomies_array() {

$term_id = self::factory()->tag->create();

$terms = get_terms( array( '111' => 'post_tag' ), array( 'hide_empty' => false ) );

$this->assertSame( $term_id, reset( $terms )->term_id );

}

/**

* @ticket 13661

*/

public function test_get_terms_fields() {

$term_id1 = self::factory()->tag->create(

array(

'slug' => 'woo',

'name' => 'WOO!',

)

);

$term_id2 = self::factory()->tag->create(

array(

'slug' => 'hoo',

'name' => 'HOO!',

'parent' => $term_id1,

)

);

$terms_id_parent = get_terms(

'post_tag',

array(

'hide_empty' => false,

'fields' => 'id=>parent',

)

);

$this->assertSameSetsWithIndex(

array(

$term_id1 => 0,

$term_id2 => $term_id1,

),

$terms_id_parent

);

$terms_ids = get_terms(

'post_tag',

array(

'hide_empty' => false,

'fields' => 'ids',

)

);

$this->assertSameSets( array( $term_id1, $term_id2 ), $terms_ids );

$terms_name = get_terms(

'post_tag',

array(

'hide_empty' => false,

'fields' => 'names',

)

);

$this->assertSameSets( array( 'WOO!', 'HOO!' ), $terms_name );

$terms_id_name = get_terms(

'post_tag',

array(

'hide_empty' => false,

'fields' => 'id=>name',

)

);

$this->assertSameSetsWithIndex(

array(

$term_id1 => 'WOO!',

$term_id2 => 'HOO!',

),

$terms_id_name

);

$terms_id_slug = get_terms(

'post_tag',

array(

'hide_empty' => false,

'fields' => 'id=>slug',

)

);

$this->assertSameSetsWithIndex(

array(

$term_id1 => 'woo',

$term_id2 => 'hoo',

),

$terms_id_slug

);

}

/**

* @ticket 11823

*/

public function test_get_terms_include_exclude() {

global $wpdb;

$term_id1 = self::factory()->tag->create();

$term_id2 = self::factory()->tag->create();

$inc_terms = get_terms(

'post_tag',

array(

'include' => array( $term_id1, $term_id2 ),

'hide_empty' => false,

)

);

$this->assertSame( array( $term_id1, $term_id2 ), wp_list_pluck( $inc_terms, 'term_id' ) );

$exc_terms = get_terms(

'post_tag',

array(

'exclude' => array( $term_id1, $term_id2 ),

'hide_empty' => false,

)

);

$this->assertSame( array(), wp_list_pluck( $exc_terms, 'term_id' ) );

// These should not generate query errors.

get_terms(

'post_tag',

array(

'exclude' => array( 0 ),

'hide_empty' => false,

)

);

$this->assertEmpty( $wpdb->last_error );

get_terms(

'post_tag',

array(

'exclude' => array( 'unexpected-string' ),

'hide_empty' => false,

)

);

$this->assertEmpty( $wpdb->last_error );

get_terms(

'post_tag',

array(

'include' => array( 'unexpected-string' ),

'hide_empty' => false,

)

);

$this->assertEmpty( $wpdb->last_error );

}

/**

* @ticket 30275

*/

public function test_exclude_with_hierarchical_true_for_non_hierarchical_taxonomy() {

register_taxonomy( 'wptests_tax', 'post' );

$terms = self::factory()->term->create_many(

2,

array(

'taxonomy' => 'wptests_tax',

)

);

$found = get_terms(

'wptests_tax',

array(

'taxonomy' => 'wptests_tax',

'hide_empty' => false,

'exclude_tree' => array( $terms[0] ),

'hierarchical' => true,

)

);

$this->assertSame( array( $terms[1] ), wp_list_pluck( $found, 'term_id' ) );

_unregister_taxonomy( 'wptests_tax' );

}

/**

* @ticket 25710

*/

public function test_get_terms_exclude_tree() {

$term_id_uncategorized = get_option( 'default_category' );

$term_id1 = self::factory()->category->create();

$term_id11 = self::factory()->category->create( array( 'parent' => $term_id1 ) );

$term_id2 = self::factory()->category->create();

$term_id22 = self::factory()->category->create( array( 'parent' => $term_id2 ) );

$terms = get_terms(

'category',

array(

'exclude' => $term_id_uncategorized,

'fields' => 'ids',

'hide_empty' => false,

)

);

$this->assertSame( array( $term_id1, $term_id11, $term_id2, $term_id22 ), $terms );

$terms = get_terms(

'category',

array(

'fields' => 'ids',

'exclude_tree' => "$term_id1,$term_id_uncategorized",

'hide_empty' => false,

)

);

$this->assertSame( array( $term_id2, $term_id22 ), $terms );

}

/**

* @ticket 13992

*/

public function test_get_terms_search() {

$term_id1 = self::factory()->tag->create( array( 'slug' => 'burrito' ) );

$term_id2 = self::factory()->tag->create( array( 'name' => 'Wilbur' ) );

$term_id3 = self::factory()->tag->create( array( 'name' => 'Foo' ) );

$terms = get_terms(

'post_tag',

array(

'hide_empty' => false,

'search' => 'bur',

'fields' => 'ids',

)

);

$this->assertSameSets( array( $term_id1, $term_id2 ), $terms );

}

/**

* @ticket 8214

*/

public function test_get_terms_like() {

$term_id1 = self::factory()->tag->create(

array(

'name' => 'burrito',

'description' => 'This is a burrito.',

)

);

$term_id2 = self::factory()->tag->create(

array(

'name' => 'taco',

'description' => 'Burning man.',

)

);

$terms = get_terms(

'post_tag',

array(

'hide_empty' => false,

'name__like' => 'bur',

'fields' => 'ids',

)

);

$this->assertSameSets( array( $term_id1 ), $terms );

$terms2 = get_terms(

'post_tag',

array(

'hide_empty' => false,

'description__like' => 'bur',

'fields' => 'ids',

)

);

$this->assertSameSets( array( $term_id1, $term_id2 ), $terms2 );

$terms3 = get_terms(

'post_tag',

array(

'hide_empty' => false,

'name__like' => 'Bur',

'fields' => 'ids',

)

);

$this->assertSameSets( array( $term_id1 ), $terms3 );

$terms4 = get_terms(

'post_tag',

array(

'hide_empty' => false,

'description__like' => 'Bur',

'fields' => 'ids',

)

);

$this->assertSameSets( array( $term_id1, $term_id2 ), $terms4 );

$terms5 = get_terms(

'post_tag',

array(

'hide_empty' => false,

'name__like' => 'ENCHILADA',

'fields' => 'ids',

)

);

$this->assertEmpty( $terms5 );

$terms6 = get_terms(

'post_tag',

array(

'hide_empty' => false,

'description__like' => 'ENCHILADA',

'fields' => 'ids',

)

);

$this->assertEmpty( $terms6 );

$terms7 = get_terms(

'post_tag',

array(

'hide_empty' => false,

'name__like' => 'o',

'fields' => 'ids',

)

);

$this->assertSameSets( array( $term_id1, $term_id2 ), $terms7 );

$terms8 = get_terms(

'post_tag',

array(

'hide_empty' => false,

'description__like' => '.',

'fields' => 'ids',

)

);

$this->assertSameSets( array( $term_id1, $term_id2 ), $terms8 );

}

/**

* @ticket 26903

*/

public function test_get_terms_parent_zero() {

$tax = 'food';

register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );

$cheese = self::factory()->term->create(

array(

'name' => 'Cheese',

'taxonomy' => $tax,

)

);

$cheddar = self::factory()->term->create(

array(

'name' => 'Cheddar',

'parent' => $cheese,

'taxonomy' => $tax,

)

);

$post_ids = self::factory()->post->create_many( 2 );

foreach ( $post_ids as $id ) {

wp_set_post_terms( $id, $cheddar, $tax );

}

$term = get_term( $cheddar, $tax );

$this->assertSame( 2, $term->count );

$brie = self::factory()->term->create(

array(

'name' => 'Brie',

'parent' => $cheese,

'taxonomy' => $tax,

)

);

$post_id = self::factory()->post->create();

wp_set_post_terms( $post_id, $brie, $tax );

$term = get_term( $brie, $tax );

$this->assertSame( 1, $term->count );

$crackers = self::factory()->term->create(

array(

'name' => 'Crackers',

'taxonomy' => $tax,

)

);

$butter = self::factory()->term->create(

array(

'name' => 'Butter',

'parent' => $crackers,

'taxonomy' => $tax,

)

);

$post_ids = self::factory()->post->create_many( 1 );

foreach ( $post_ids as $id ) {

wp_set_post_terms( $id, $butter, $tax );

}

$term = get_term( $butter, $tax );

$this->assertSame( 1, $term->count );

$multigrain = self::factory()->term->create(

array(

'name' => 'Multigrain',

'parent' => $crackers,

'taxonomy' => $tax,

)

);

$post_ids = self::factory()->post->create_many( 1 );

foreach ( $post_ids as $id ) {

wp_set_post_terms( $id, $multigrain, $tax );

}

$term = get_term( $multigrain, $tax );

$this->assertSame( 1, $term->count );

$fruit = self::factory()->term->create(

array(

'name' => 'Fruit',

'taxonomy' => $tax,

)

);

$cranberries = self::factory()->term->create(

array(

'name' => 'Cranberries',

'parent' => $fruit,

'taxonomy' => $tax,

)

);

$terms = get_terms(

$tax,

array(

'parent' => 0,

'cache_domain' => $tax,

)

);

$this->assertCount( 2, $terms );

$this->assertSame( wp_list_pluck( $terms, 'name' ), array( 'Cheese', 'Crackers' ) );

}

/**

* @ticket 26903

*/

public function test_get_terms_grandparent_zero() {

$tax = 'food';

register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );

$cheese = self::factory()->term->create(

array(

'name' => 'Cheese',

'taxonomy' => $tax,

)

);

$cheddar = self::factory()->term->create(

array(

'name' => 'Cheddar',

'parent' => $cheese,

'taxonomy' => $tax,

)

);

$spread = self::factory()->term->create(

array(

'name' => 'Spread',

'parent' => $cheddar,

'taxonomy' => $tax,

)

);

$post_id = self::factory()->post->create();

wp_set_post_terms( $post_id, $spread, $tax );

$term = get_term( $spread, $tax );

$this->assertSame( 1, $term->count );

$terms = get_terms(

$tax,

array(

'parent' => 0,

'cache_domain' => $tax,

)

);

$this->assertCount( 1, $terms );

$this->assertSame( array( 'Cheese' ), wp_list_pluck( $terms, 'name' ) );

_unregister_taxonomy( $tax );

}

/**

* @ticket 26903

*/

public function test_get_terms_seven_levels_deep() {

$tax = 'deep';

register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );

$parent = 0;

$t = array();

foreach ( range( 1, 7 ) as $depth ) {

$t[ $depth ] = self::factory()->term->create(

array(

'name' => 'term' . $depth,

'taxonomy' => $tax,

'parent' => $parent,

)

);

$parent = $t[ $depth ];

}

$post_id = self::factory()->post->create();

wp_set_post_terms( $post_id, $t[7], $tax );

$term = get_term( $t[7], $tax );

$this->assertSame( 1, $term->count );

$terms = get_terms(

$tax,

array(

'parent' => 0,

'cache_domain' => $tax,

)

);

$this->assertCount( 1, $terms );

$this->assertSame( array( 'term1' ), wp_list_pluck( $terms, 'name' ) );

_unregister_taxonomy( $tax );

}

/**

* @ticket 27123

*/

public function test_get_terms_child_of() {

$parent = self::factory()->category->create();

$child = self::factory()->category->create( array( 'parent' => $parent ) );

$terms = get_terms(

'category',

array(

'child_of' => $parent,

'hide_empty' => false,

)

);

$this->assertCount( 1, $terms );

}

/**

* @ticket 55837

* @covers ::get_terms

*/

public function test_get_terms_child_of_cache() {

$parent = self::factory()->category->create();

self::factory()->category->create( array( 'parent' => $parent ) );

$args = array(

'fields' => 'ids',

'child_of' => $parent,

'hide_empty' => false,

);

$terms = get_terms( 'category', $args );

$this->assertCount( 1, $terms, 'The first call to get_terms() did not return 1 term' );

$terms2 = get_terms( 'category', $args );

$this->assertCount( 1, $terms2, 'The second call to get_terms() did not return 1 term' );

$this->assertSameSets( $terms, $terms2, 'Results are not the same after caching' );

}

/**

* @ticket 46768

*/

public function test_get_terms_child_of_fields_id_name() {

$parent = self::factory()->category->create();

$child = self::factory()->category->create(

array(

'parent' => $parent,

'slug' => 'test-1',

'name' => 'Test 1',

)

);

$child2 = self::factory()->category->create(

array(

'parent' => $parent,

'slug' => 'test-2',

'name' => 'Test 2',

)

);

$terms = get_terms(

'category',

array(

'child_of' => $parent,

'hide_empty' => false,

'fields' => 'id=>name',

)

);

$this->assertSame(

array(

$child => 'Test 1',

$child2 => 'Test 2',

),

$terms

);

}

/**

* @ticket 46768

*/

public function test_get_terms_child_of_fields_id_slug() {

$parent = self::factory()->category->create();

$child = self::factory()->category->create(

array(

'parent' => $parent,

'slug' => 'test-1',

'name' => 'Test 1',

)

);

$child2 = self::factory()->category->create(

array(

'parent' => $parent,

'slug' => 'test-2',

'name' => 'Test 2',

)

);

$terms = get_terms(

'category',

array(

'child_of' => $parent,

'hide_empty' => false,

'fields' => 'id=>slug',

)

);

$this->assertSame(

array(

$child => 'test-1',

$child2 => 'test-2',

),

$terms

);

}

/**

* @ticket 31118

*/

public function test_child_of_should_skip_query_when_specified_parent_is_not_found_in_hierarchy_cache() {

register_taxonomy( 'wptests_tax', 'post', array( 'hierarchical' => true ) );

$terms = self::factory()->term->create_many( 3, array( 'taxonomy' => 'wptests_tax' ) );

$num_queries = get_num_queries();

$found = get_terms(

'wptests_tax',

array(

'hide_empty' => false,

'child_of' => $terms[0],

)

);

$this->assertEmpty( $found );

$this->assertSame( $num_queries, get_num_queries() );

}

/**

* @ticket 31118

*/

public function test_child_of_should_respect_multiple_taxonomies() {

register_taxonomy( 'wptests_tax1', 'post', array( 'hierarchical' => true ) );

register_taxonomy( 'wptests_tax2', 'post', array( 'hierarchical' => true ) );

$t1 = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax1' ) );

$t2 = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax2' ) );

$t3 = self::factory()->term->create(

array(

'taxonomy' => 'wptests_tax2',

'parent' => $t2,

)

);

$found = get_terms(

array( 'wptests_tax1', 'wptests_tax2' ),

array(

'fields' => 'ids',

'hide_empty' => false,

'child_of' => $t2,

)

);

$this->assertSameSets( array( $t3 ), $found );

}

/**

* @ticket 27123

*/

public function test_get_term_children_recursion() {

// Assume there is a way to insert a term with the parent pointing to itself.

// See: https://core.trac.wordpress.org/changeset/15806

remove_filter( 'wp_update_term_parent', 'wp_check_term_hierarchy_for_loops', 10 );

$term = wp_insert_term( 'Test', 'category' );

$term = wp_update_term( $term['term_id'], 'category', array( 'parent' => $term['term_id'] ) );

$term = get_term( $term['term_id'], 'category' );

$this->assertSame( $term->term_id, $term->parent );

$this->assertIsArray( get_term_children( $term->term_id, 'category' ) );

add_filter( 'wp_update_term_parent', 'wp_check_term_hierarchy_for_loops', 10, 3 );

}

/**

* @covers ::_get_term_children

* @ticket 24461

*/

public function test__get_term_children_handles_cycles() {

remove_filter( 'wp_update_term_parent', 'wp_check_term_hierarchy_for_loops', 10 );

$c1 = self::factory()->category->create();

$c2 = self::factory()->category->create( array( 'parent' => $c1 ) );

$c3 = self::factory()->category->create( array( 'parent' => $c2 ) );

wp_update_term( $c1, 'category', array( 'parent' => $c3 ) );

add_filter( 'wp_update_term_parent', 'wp_check_term_hierarchy_for_loops', 10, 3 );

$result = _get_term_children( $c1, array( $c1, $c2, $c3 ), 'category' );

$this->assertSameSets( array( $c2, $c3 ), $result );

}

/**

* @covers ::_get_term_children

* @ticket 24461

*/

public function test__get_term_children_handles_cycles_when_terms_argument_contains_objects() {

remove_filter( 'wp_update_term_parent', 'wp_check_term_hierarchy_for_loops', 10 );

$c1 = self::factory()->category->create_and_get();

$c2 = self::factory()->category->create_and_get( array( 'parent' => $c1->term_id ) );

$c3 = self::factory()->category->create_and_get( array( 'parent' => $c2->term_id ) );

wp_update_term( $c1->term_id, 'category', array( 'parent' => $c3->term_id ) );

add_filter( 'wp_update_term_parent', 'wp_check_term_hierarchy_for_loops', 10, 3 );

$result = _get_term_children( $c1->term_id, array( $c1, $c2, $c3 ), 'category' );

$this->assertSameSets( array( $c2, $c3 ), $result );

}

public function test_get_terms_by_slug() {

$t1 = self::factory()->tag->create( array( 'slug' => 'foo' ) );

$t2 = self::factory()->tag->create( array( 'slug' => 'bar' ) );

$found = get_terms(

'post_tag',

array(

'hide_empty' => false,

'fields' => 'ids',

'slug' => 'foo',

)

);

$this->assertSame( array( $t1 ), $found );

}

/**

* @ticket 23636

*/

public function test_get_terms_by_multiple_slugs() {

$t1 = self::factory()->tag->create( array( 'slug' => 'foo' ) );

$t2 = self::factory()->tag->create( array( 'slug' => 'bar' ) );

$t3 = self::factory()->tag->create( array( 'slug' => 'barry' ) );

$found = get_terms(

'post_tag',

array(

'hide_empty' => false,

'fields' => 'ids',

'slug' => array( 'foo', 'barry' ),

)

);

$this->assertSame( array( $t1, $t3 ), $found );

}

/**

* @ticket 30611

*/

public function test_get_terms_by_name() {

$t1 = self::factory()->tag->create( array( 'name' => 'Foo' ) );

$t2 = self::factory()->tag->create( array( 'name' => 'Bar' ) );

$found = get_terms(

'post_tag',

array(

'hide_empty' => false,

'fields' => 'ids',

'name' => 'Foo',

)

);