WordPress.org
Get WordPress

Make WordPress Core


Ignore:
Timestamp:
09/30/2014 02:59:10 PM (10 years ago)
Author:
boonebgorges
Message:

Improve unit test coverage for duplicate term creation.

These include an exhaustive set of tests for term_exists(), as well as tests
for wp_insert_term() that demonstrate failure when attempting to create a
duplicate term.

Props simonwheatley for an initial patch.

See #22023.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/tests/phpunit/tests/term.php

    r29196 r29798  
    5454    }
    5555
     56    public function test_term_exists_term_0() {
     57        $this->assertSame( 0, term_exists( 0 ) );
     58    }
     59
     60    public function test_term_exists_term_int_taxonomy_nonempty_term_exists() {
     61        $t = $this->factory->term->create( array(
     62            'taxonomy' => 'post_tag',
     63        ) );
     64
     65        $found = term_exists( intval( $t ), 'post_tag' );
     66        $this->assertEquals( $t, $found['term_id'] );
     67    }
     68
     69    public function test_term_exists_term_int_taxonomy_nonempty_term_does_not_exist() {
     70        $this->assertNull( term_exists( 54321, 'post_tag' ) );
     71    }
     72
     73    public function test_term_exists_term_int_taxonomy_nonempty_wrong_taxonomy() {
     74        $t = $this->factory->term->create( array(
     75            'taxonomy' => 'post_tag',
     76        ) );
     77
     78        $this->assertNull( term_exists( intval( $t ), 'foo' ) );
     79    }
     80
     81    public function test_term_exists_term_int_taxonomy_empty_term_exists() {
     82        $t = $this->factory->term->create( array(
     83            'taxonomy' => 'post_tag',
     84        ) );
     85
     86        $found = term_exists( intval( $t ), 'post_tag' );
     87        $this->assertEquals( $t, $found['term_id'] );
     88    }
     89
     90    public function test_term_exists_term_int_taxonomy_empty_term_does_not_exist() {
     91        $this->assertNull( term_exists( 54321 ) );
     92    }
     93
     94    public function test_term_exists_unslash_term() {
     95        $t = $this->factory->term->create( array(
     96            'taxonomy' => 'post_tag',
     97            'name' => 'I "love" WordPress\'s taxonomy system',
     98        ) );
     99
     100        $found = term_exists( 'I \"love\" WordPress\\\'s taxonomy system' );
     101        $this->assertEquals( $t, $found );
     102    }
     103
     104    public function test_term_exists_trim_term() {
     105        $t = $this->factory->term->create( array(
     106            'taxonomy' => 'post_tag',
     107            'slug' => 'foo',
     108        ) );
     109
     110        $found = term_exists( '  foo  ' );
     111        $this->assertEquals( $t, $found );
     112    }
     113
     114    public function test_term_exists_term_trimmed_to_empty_string() {
     115        $this->assertSame( 0, term_exists( '   ' ) );
     116    }
     117
     118    public function test_term_exists_taxonomy_nonempty_parent_nonempty_match_slug() {
     119        register_taxonomy( 'foo', 'post', array(
     120            'hierarchical' => true,
     121        ) );
     122
     123        $parent_term = $this->factory->term->create( array(
     124            'taxonomy' => 'foo',
     125        ) );
     126
     127        $t = $this->factory->term->create( array(
     128            'taxonomy' => 'foo',
     129            'parent' => $parent_term,
     130            'slug' => 'child-term',
     131        ) );
     132
     133        $found = term_exists( 'child-term', 'foo', $parent_term );
     134
     135        _unregister_taxonomy( 'foo' );
     136
     137        $this->assertInternalType( 'array', $found );
     138        $this->assertEquals( $t, $found['term_id'] );
     139    }
     140
     141    public function test_term_exists_taxonomy_nonempty_parent_nonempty_match_name() {
     142        register_taxonomy( 'foo', 'post', array(
     143            'hierarchical' => true,
     144        ) );
     145
     146        $parent_term = $this->factory->term->create( array(
     147            'taxonomy' => 'foo',
     148        ) );
     149
     150        $t = $this->factory->term->create( array(
     151            'taxonomy' => 'foo',
     152            'parent' => $parent_term,
     153            'name' => 'Child Term',
     154        ) );
     155
     156        $found = term_exists( 'Child Term', 'foo', $parent_term );
     157
     158        _unregister_taxonomy( 'foo' );
     159
     160        $this->assertInternalType( 'array', $found );
     161        $this->assertEquals( $t, $found['term_id'] );
     162    }
     163
     164    public function test_term_exists_taxonomy_nonempty_parent_empty_match_slug() {
     165        register_taxonomy( 'foo', 'post', array() );
     166
     167        $t = $this->factory->term->create( array(
     168            'taxonomy' => 'foo',
     169            'slug' => 'kewl-dudez',
     170        ) );
     171
     172        $found = term_exists( 'kewl-dudez', 'foo' );
     173
     174        _unregister_taxonomy( 'foo' );
     175
     176        $this->assertInternalType( 'array', $found );
     177        $this->assertEquals( $t, $found['term_id'] );
     178    }
     179
     180    public function test_term_exists_taxonomy_nonempty_parent_empty_match_name() {
     181        register_taxonomy( 'foo', 'post', array() );
     182
     183        $t = $this->factory->term->create( array(
     184            'taxonomy' => 'foo',
     185            'name' => 'Kewl Dudez',
     186        ) );
     187
     188        $found = term_exists( 'Kewl Dudez', 'foo' );
     189
     190        _unregister_taxonomy( 'foo' );
     191
     192        $this->assertInternalType( 'array', $found );
     193        $this->assertEquals( $t, $found['term_id'] );
     194    }
     195
     196    public function test_term_exists_taxonomy_empty_parent_empty_match_slug() {
     197        register_taxonomy( 'foo', 'post', array() );
     198
     199        $t = $this->factory->term->create( array(
     200            'taxonomy' => 'foo',
     201            'name' => 'juicy-fruit',
     202        ) );
     203
     204        $found = term_exists( 'juicy-fruit' );
     205
     206        _unregister_taxonomy( 'foo' );
     207
     208        $this->assertInternalType( 'string', $found );
     209        $this->assertEquals( $t, $found );
     210    }
     211
     212    public function test_term_exists_taxonomy_empty_parent_empty_match_name() {
     213        register_taxonomy( 'foo', 'post', array() );
     214
     215        $t = $this->factory->term->create( array(
     216            'taxonomy' => 'foo',
     217            'name' => 'Juicy Fruit',
     218        ) );
     219
     220        $found = term_exists( 'Juicy Fruit' );
     221
     222        _unregister_taxonomy( 'foo' );
     223
     224        $this->assertInternalType( 'string', $found );
     225        $this->assertEquals( $t, $found );
     226    }
     227
    56228    function test_term_exists_known() {
    57229        // insert a term
    … …  
    71243        $this->assertEquals( 0, term_exists('') );
    72244        $this->assertEquals( 0, term_exists(NULL) );
     245    }
     246
     247    public function test_wp_insert_term_duplicate_name_slug_non_hierarchical() {
     248        register_taxonomy( 'foo', 'post', array() );
     249
     250        $existing_term = $this->factory->term->create( array(
     251            'slug' => 'new-term',
     252            'name' => 'New Term',
     253            'taxonomy' => 'foo',
     254        ) );
     255
     256        $found = wp_insert_term( 'New Term', 'foo', array(
     257            'slug' => 'new-term',
     258        ) );
     259
     260        _unregister_taxonomy( 'foo' );
     261
     262        $this->assertTrue( is_wp_error( $found ) );
     263        $this->assertEquals( $existing_term, $found->get_error_data() );
     264    }
     265
     266    public function test_wp_insert_term_duplicate_name_hierarchical() {
     267        register_taxonomy( 'foo', 'post', array(
     268            'hierarchical' => true,
     269        ) );
     270
     271        $parent_term = $this->factory->term->create( array(
     272            'taxonomy' => 'foo',
     273        ) );
     274
     275        $existing_term = $this->factory->term->create( array(
     276            'name' => 'New Term',
     277            'taxonomy' => 'foo',
     278            'parent' => $parent_term,
     279        ) );
     280
     281        $found = wp_insert_term( 'New Term', 'foo', array(
     282            'parent' => $parent_term,
     283        ) );
     284
     285        _unregister_taxonomy( 'foo' );
     286
     287        $this->assertTrue( is_wp_error( $found ) );
     288        $this->assertEquals( $existing_term, $found->get_error_data() );
     289    }
     290
     291    public function test_wp_insert_term_duplicate_name_slug_hierarchical() {
     292        register_taxonomy( 'foo', 'post', array(
     293            'hierarchical' => true,
     294        ) );
     295
     296        $parent_term = $this->factory->term->create( array(
     297            'taxonomy' => 'foo',
     298        ) );
     299
     300        $existing_term = $this->factory->term->create( array(
     301            'name' => 'New Term',
     302            'slug' => 'new-term-slug',
     303            'taxonomy' => 'foo',
     304            'parent' => $parent_term,
     305        ) );
     306
     307        $found = wp_insert_term( 'New Term', 'foo', array(
     308            'parent' => $parent_term,
     309            'slug' => 'new-term-slug',
     310        ) );
     311
     312        _unregister_taxonomy( 'foo' );
     313
     314        $this->assertTrue( is_wp_error( $found ) );
     315        $this->assertEquals( $existing_term, $found->get_error_data() );
    73316    }
    74317
Note: See TracChangeset for help on using the changeset viewer.