WP_UnitTestCase

Complexity

Total Complexity

150

Size/Duplication

Total Lines	842
Duplicated Lines	8.91 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes

0

55 Methods

Rating	Name	Duplication	Size	Complexity
A	__isset()	0	4	1
A	__get()	0	6	2
A	factory()	0	8	2
A	get_called_class()	0	15	3
A	setUpBeforeClass()	13	14	2
A	tearDownAfterClass()	16	17	2
B	setUp()	0	40	6
A	assertPostConditions()	0	4	1
B	tearDown()	0	25	4
A	clean_up_global_scope()	0	6	1
A	reset_post_types()	0	7	2
A	reset_taxonomies()	0	7	2
A	reset_post_statuses()	0	6	2
A	reset__SERVER()	0	4	1
A	_backup_hooks()	0	11	3
B	_restore_hooks()	0	15	5
A	flush_cache()	0	14	2
A	start_transaction()	0	8	1
A	commit_transaction()	0	5	1
A	_create_temporary_tables()	7	7	2
A	_drop_temporary_tables()	7	7	2
A	get_wp_die_handler()	0	4	1
A	wp_die_handler()	0	8	2
A	expectDeprecated()	0	20	4
B	expectedDeprecated()	0	28	6
A	setExpectedDeprecated()	0	4	1
A	setExpectedIncorrectUsage()	0	4	1
A	deprecated_function_run()	0	6	2
A	doing_it_wrong_run()	0	6	2
A	assertWPError()	0	4	1
A	assertNotWPError()	0	7	3
A	assertEqualFields()	0	8	3
A	assertDiscardWhitespace()	0	4	1
A	assertEqualSets()	0	6	1
A	assertEqualSetsWithIndex()	0	6	1
C	go_to()	0	45	7
C	checkRequirements()	0	29	12
A	knownWPBug()	8	9	4
A	knownUTBug()	8	9	4
A	knownPluginBug()	8	9	4
A	forceTicket()	0	4	1
A	prepareTemplate()	0	6	1
B	temp_filename()	0	16	5
C	assertQueryTrue()	0	65	9
A	unlink()	0	10	4
A	rmdir()	0	9	3
A	remove_added_uploads()	0	6	1
A	files_in_dir()	0	14	3
A	scan_user_uploads()	0	11	2
A	delete_folders()	0	13	3
A	scandir()	0	9	4
A	_microtime_to_float()	0	5	1
A	delete_user()	0	8	2
A	set_permalink_structure()	0	8	1
B	_make_attachment()	8	26	3

<?php

require_once dirname(__FILE__) . '/factory.php';
require_once dirname(__FILE__) . '/trac.php';

/**
 * Defines a basic fixture to run multiple tests.
 *
 * Resets the state of the WordPress installation before and after every test.
 *
 * Includes utility functions and assertions useful for testing WordPress.
 *
 * All WordPress unit tests should inherit from this class.
 */
class WP_UnitTestCase extends PHPUnit_Framework_TestCase
{

    protected static $forced_tickets = array();
    protected $expected_deprecated = array();
    protected $caught_deprecated = array();
    protected $expected_doing_it_wrong = array();
    protected $caught_doing_it_wrong = array();

    protected static $hooks_saved = array();
    protected static $ignore_files;

    function __isset( $name ) 
    {
        return 'factory' === $name;
    }

    function __get( $name ) 
    {
        if ('factory' === $name ) {
            return self::factory();
        }
    }

    protected static function factory() 
    {
        static $factory = null;
        if (! $factory ) {

Expected 1 space before "!"; 0 found

            $factory = new WP_UnitTest_Factory();
        }
        return $factory;
    }

    public static function get_called_class() 
    {
        if (function_exists('get_called_class') ) {
            return get_called_class();
        }

        // PHP 5.2 only
        $backtrace = debug_backtrace();
        // [0] WP_UnitTestCase::get_called_class()
        // [1] WP_UnitTestCase::setUpBeforeClass()
        if ('call_user_func' ===  $backtrace[2]['function'] ) {

Expected 1 space after "==="; 2 found

            return $backtrace[2]['args'][0][0];
        }
        return $backtrace[2]['class'];
    }

    public static function setUpBeforeClass() 

The function name setUpBeforeClass is in camel caps, but expected set_up_before_class instead as per the coding standard.

    {
        parent::setUpBeforeClass();

        $c = self::get_called_class();
        if (! method_exists($c, 'wpSetUpBeforeClass') ) {

Expected 1 space before "!"; 0 found

            self::commit_transaction();
            return;
        }

        call_user_func(array( $c, 'wpSetUpBeforeClass' ), self::factory());

        self::commit_transaction();
    }

    public static function tearDownAfterClass() 

The function name tearDownAfterClass is in camel caps, but expected tear_down_after_class instead as per the coding standard.

    {
        parent::tearDownAfterClass();

        _delete_all_data();
        self::flush_cache();

        $c = self::get_called_class();
        if (! method_exists($c, 'wpTearDownAfterClass') ) {

Expected 1 space before "!"; 0 found

            self::commit_transaction();
            return;
        }

        call_user_func(array( $c, 'wpTearDownAfterClass' ));

        self::commit_transaction();
    }

    function setUp() 

The function name setUp is in camel caps, but expected set_up instead as per the coding standard.

    {
        set_time_limit(0);

        if (! self::$ignore_files ) {

Expected 1 space before "!"; 0 found

            self::$ignore_files = $this->scan_user_uploads();
        }

        if (! self::$hooks_saved ) {

The expression self::$hooks_saved of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

Expected 1 space before "!"; 0 found

            $this->_backup_hooks();
        }

        global $wpdb, $wp_rewrite;
        $wpdb->suppress_errors = false;
        $wpdb->show_errors = true;
        $wpdb->db_connect();
        ini_set('display_errors', 1);
        $this->clean_up_global_scope();

        /*
         * When running core tests, ensure that post types and taxonomies
         * are reset for each test. We skip this step for non-core tests,
         * given the large number of plugins that register post types and
         * taxonomies at 'init'.
         */
        if (defined('WP_RUN_CORE_TESTS') && WP_RUN_CORE_TESTS ) {
            $this->reset_post_types();
            $this->reset_taxonomies();
            $this->reset_post_statuses();
            $this->reset__SERVER();

            if ($wp_rewrite->permalink_structure ) {
                $this->set_permalink_structure('');
            }
        }

        $this->start_transaction();
        $this->expectDeprecated();
        add_filter('wp_die_handler', array( $this, 'get_wp_die_handler' ));
    }

    /**
     * Detect post-test failure conditions.
     *
     * We use this method to detect expectedDeprecated and expectedIncorrectUsage annotations.
     *
     * @since 4.2.0
     */
    protected function assertPostConditions() 

The function name assertPostConditions is in camel caps, but expected assert_post_conditions instead as per the coding standard.

    {
        $this->expectedDeprecated();
    }

    /**
     * After a test method runs, reset any state in WordPress the test method might have changed.
     */
    function tearDown() 

The function name tearDown is in camel caps, but expected tear_down instead as per the coding standard.

    {
        global $wpdb, $wp_query, $wp;
        $wpdb->query('ROLLBACK');

Usage of a direct database call is discouraged.

Usage of a direct database call without caching is prohibited. Use wp_cache_get / wp_cache_set.

        if (is_multisite() ) {
            while ( ms_is_switched() ) {
                restore_current_blog();
            }
        }
        $wp_query = new WP_Query();

Overridding WordPress globals is prohibited

        $wp = new WP();

Overridding WordPress globals is prohibited

        // Reset globals related to the post loop and `setup_postdata()`.
        $post_globals = array( 'post', 'id', 'authordata', 'currentday', 'currentmonth', 'page', 'pages', 'multipage', 'more', 'numpages' );
        foreach ( $post_globals as $global ) {
            $GLOBALS[ $global ] = null;
        }

        remove_theme_support('html5');
        remove_filter('query', array( $this, '_create_temporary_tables' ));
        remove_filter('query', array( $this, '_drop_temporary_tables' ));
        remove_filter('wp_die_handler', array( $this, 'get_wp_die_handler' ));
        $this->_restore_hooks();
        wp_set_current_user(0);
    }

    function clean_up_global_scope() 
    {
        $_GET = array();
        $_POST = array();
        self::flush_cache();
    }

    /**
     * Unregister existing post types and register defaults.
     *
     * Run before each test in order to clean up the global scope, in case
     * a test forgets to unregister a post type on its own, or fails before
     * it has a chance to do so.
     */
    protected function reset_post_types() 
    {
        foreach ( get_post_types() as $pt ) {
            _unregister_post_type($pt);
        }
        create_initial_post_types();
    }

    /**
     * Unregister existing taxonomies and register defaults.
     *
     * Run before each test in order to clean up the global scope, in case
     * a test forgets to unregister a taxonomy on its own, or fails before
     * it has a chance to do so.
     */
    protected function reset_taxonomies() 
    {
        foreach ( get_taxonomies() as $tax ) {
            _unregister_taxonomy($tax);
        }
        create_initial_taxonomies();
    }

    /**
     * Unregister non-built-in post statuses.
     */
    protected function reset_post_statuses() 
    {
        foreach ( get_post_stati(array( '_builtin' => false )) as $post_status ) {
            _unregister_post_status($post_status);
        }
    }

    /**
     * Reset `$_SERVER` variables
     */
    protected function reset__SERVER() 

The function name reset__SERVER is in camel caps, but expected reset__s_e_r_v_e_r instead as per the coding standard.

    {
        tests_reset__SERVER();
    }

    /**
     * Saves the action and filter-related globals so they can be restored later.
     *
     * Stores $merged_filters, $wp_actions, $wp_current_filter, and $wp_filter
     * on a class variable so they can be restored on tearDown() using _restore_hooks().
     *
     * @global array $merged_filters
     * @global array $wp_actions
     * @global array $wp_current_filter
     * @global array $wp_filter
     * @return void
     */
    protected function _backup_hooks() 
    {
        $globals = array( 'wp_actions', 'wp_current_filter' );
        foreach ( $globals as $key ) {
            self::$hooks_saved[ $key ] = $GLOBALS[ $key ];
        }
        self::$hooks_saved['wp_filter'] = array();
        foreach ( $GLOBALS['wp_filter'] as $hook_name => $hook_object ) {
            self::$hooks_saved['wp_filter'][ $hook_name ] = clone $hook_object;
        }
    }

    /**
     * Restores the hook-related globals to their state at setUp()
     * so that future tests aren't affected by hooks set during this last test.
     *
     * @global array $merged_filters
     * @global array $wp_actions
     * @global array $wp_current_filter
     * @global array $wp_filter
     * @return void
     */
    protected function _restore_hooks() 
    {
        $globals = array( 'wp_actions', 'wp_current_filter' );
        foreach ( $globals as $key ) {
            if (isset(self::$hooks_saved[ $key ]) ) {
                $GLOBALS[ $key ] = self::$hooks_saved[ $key ];
            }
        }
        if (isset(self::$hooks_saved['wp_filter']) ) {
            $GLOBALS['wp_filter'] = array();

Overridding WordPress globals is prohibited

            foreach ( self::$hooks_saved['wp_filter'] as $hook_name => $hook_object ) {
                $GLOBALS['wp_filter'][ $hook_name ] = clone $hook_object;
            }
        }
    }

    static function flush_cache() 
    {
        global $wp_object_cache;
        $wp_object_cache->group_ops = array();
        $wp_object_cache->stats = array();
        $wp_object_cache->memcache_debug = array();
        $wp_object_cache->cache = array();
        if (method_exists($wp_object_cache, '__remoteset') ) {
            $wp_object_cache->__remoteset();
        }
        wp_cache_flush();
        wp_cache_add_global_groups(array( 'users', 'userlogins', 'usermeta', 'user_meta', 'site-transient', 'site-options', 'site-lookup', 'blog-lookup', 'blog-details', 'rss', 'global-posts', 'blog-id-cache' ));
        wp_cache_add_non_persistent_groups(array( 'comment', 'counts', 'plugins' ));
    }

    function start_transaction() 
    {
        global $wpdb;
        $wpdb->query('SET autocommit = 0;');

Usage of a direct database call is discouraged.

Usage of a direct database call without caching is prohibited. Use wp_cache_get / wp_cache_set.

        $wpdb->query('START TRANSACTION;');

Usage of a direct database call is discouraged.

Usage of a direct database call without caching is prohibited. Use wp_cache_get / wp_cache_set.

        add_filter('query', array( $this, '_create_temporary_tables' ));
        add_filter('query', array( $this, '_drop_temporary_tables' ));
    }

    /**
     * Commit the queries in a transaction.
     *
     * @since 4.1.0
     */
    public static function commit_transaction() 
    {
        global $wpdb;
        $wpdb->query('COMMIT;');

Usage of a direct database call is discouraged.

Usage of a direct database call without caching is prohibited. Use wp_cache_get / wp_cache_set.

    }

    function _create_temporary_tables( $query ) 
    {
        if ('CREATE TABLE' === substr(trim($query), 0, 12) ) {
              return substr_replace(trim($query), 'CREATE TEMPORARY TABLE', 0, 12);
        }
        return $query;
    }

    function _drop_temporary_tables( $query ) 
    {
        if ('DROP TABLE' === substr(trim($query), 0, 10) ) {
              return substr_replace(trim($query), 'DROP TEMPORARY TABLE', 0, 10);
        }
        return $query;
    }

    function get_wp_die_handler( $handler ) 
    {
        return array( $this, 'wp_die_handler' );
    }

    function wp_die_handler( $message ) 
    {
        if (! is_scalar($message) ) {

Expected 1 space before "!"; 0 found

            $message = '0';
        }

        throw new WPDieException($message);
    }

    function expectDeprecated() 

The function name expectDeprecated is in camel caps, but expected expect_deprecated instead as per the coding standard.

    {
        $annotations = $this->getAnnotations();
        foreach ( array( 'class', 'method' ) as $depth ) {
            if (! empty($annotations[ $depth ]['expectedDeprecated']) ) {

Expected 1 space before "!"; 0 found

                $this->expected_deprecated = array_merge($this->expected_deprecated, $annotations[ $depth ]['expectedDeprecated']);
            }
            if (! empty($annotations[ $depth ]['expectedIncorrectUsage']) ) {

Expected 1 space before "!"; 0 found

                $this->expected_doing_it_wrong = array_merge($this->expected_doing_it_wrong, $annotations[ $depth ]['expectedIncorrectUsage']);
            }
        }
        add_action('deprecated_function_run', array( $this, 'deprecated_function_run' ));
        add_action('deprecated_argument_run', array( $this, 'deprecated_function_run' ));
        add_action('deprecated_hook_run', array( $this, 'deprecated_function_run' ));
        add_action('doing_it_wrong_run', array( $this, 'doing_it_wrong_run' ));
        add_action('deprecated_function_trigger_error', '__return_false');
        add_action('deprecated_argument_trigger_error', '__return_false');
        add_action('deprecated_hook_trigger_error',     '__return_false');
        add_action('doing_it_wrong_trigger_error',      '__return_false');
    }

    function expectedDeprecated() 

The function name expectedDeprecated is in camel caps, but expected expected_deprecated instead as per the coding standard.

    {
        $errors = array();

        $not_caught_deprecated = array_diff($this->expected_deprecated, $this->caught_deprecated);
        foreach ( $not_caught_deprecated as $not_caught ) {
            $errors[] = "Failed to assert that $not_caught triggered a deprecated notice";
        }

        $unexpected_deprecated = array_diff($this->caught_deprecated, $this->expected_deprecated);
        foreach ( $unexpected_deprecated as $unexpected ) {
            $errors[] = "Unexpected deprecated notice for $unexpected";
        }

        $not_caught_doing_it_wrong = array_diff($this->expected_doing_it_wrong, $this->caught_doing_it_wrong);
        foreach ( $not_caught_doing_it_wrong as $not_caught ) {
            $errors[] = "Failed to assert that $not_caught triggered an incorrect usage notice";
        }

        $unexpected_doing_it_wrong = array_diff($this->caught_doing_it_wrong, $this->expected_doing_it_wrong);
        foreach ( $unexpected_doing_it_wrong as $unexpected ) {
            $errors[] = "Unexpected incorrect usage notice for $unexpected";
        }

        if (! empty($errors) ) {

Expected 1 space before "!"; 0 found

            $this->fail(implode("\n", $errors));
        }
    }

    /**
     * Declare an expected `_deprecated_function()` or `_deprecated_argument()` call from within a test.
     *
     * @since 4.2.0
     *
     * @param string $deprecated Name of the function, method, class, or argument that is deprecated. Must match
     *                           first parameter of the `_deprecated_function()` or `_deprecated_argument()` call.
     */
    public function setExpectedDeprecated( $deprecated ) 

The function name setExpectedDeprecated is in camel caps, but expected set_expected_deprecated instead as per the coding standard.

    {
        array_push($this->expected_deprecated, $deprecated);
    }

    /**
     * Declare an expected `_doing_it_wrong()` call from within a test.
     *
     * @since 4.2.0
     *
     * @param string $deprecated Name of the function, method, or class that appears in the first argument of the

There is no parameter named $deprecated. Was it maybe removed?

     *                           source `_doing_it_wrong()` call.
     */
    public function setExpectedIncorrectUsage( $doing_it_wrong ) 

The function name setExpectedIncorrectUsage is in camel caps, but expected set_expected_incorrect_usage instead as per the coding standard.

    {
        array_push($this->expected_doing_it_wrong, $doing_it_wrong);
    }

    function deprecated_function_run( $function ) 
    {
        if (! in_array($function, $this->caught_deprecated) ) {

Expected 1 space before "!"; 0 found

              $this->caught_deprecated[] = $function;
        }
    }

    function doing_it_wrong_run( $function ) 
    {
        if (! in_array($function, $this->caught_doing_it_wrong) ) {

Expected 1 space before "!"; 0 found

              $this->caught_doing_it_wrong[] = $function;
        }
    }

    function assertWPError( $actual, $message = '' ) 

The function name assertWPError is in camel caps, but expected assert_w_p_error instead as per the coding standard.

    {
        $this->assertInstanceOf('WP_Error', $actual, $message);
    }

    function assertNotWPError( $actual, $message = '' ) 

The function name assertNotWPError is in camel caps, but expected assert_not_w_p_error instead as per the coding standard.

    {
        if (is_wp_error($actual) && '' === $message ) {
            $message = $actual->get_error_message();
        }
        $this->assertNotInstanceOf('WP_Error', $actual, $message);
    }

    function assertEqualFields( $object, $fields ) 

The function name assertEqualFields is in camel caps, but expected assert_equal_fields instead as per the coding standard.

    {
        foreach( $fields as $field_name => $field_value ) {

Space after opening control structure is required

No space before opening parenthesis is prohibited

            if ($object->$field_name != $field_value ) {
                $this->fail();
            }
        }
    }

    function assertDiscardWhitespace( $expected, $actual ) 

The function name assertDiscardWhitespace is in camel caps, but expected assert_discard_whitespace instead as per the coding standard.

    {
        $this->assertEquals(preg_replace('/\s*/', '', $expected), preg_replace('/\s*/', '', $actual));
    }

    function assertEqualSets( $expected, $actual ) 

The function name assertEqualSets is in camel caps, but expected assert_equal_sets instead as per the coding standard.

    {
        sort($expected);
        sort($actual);
        $this->assertEquals($expected, $actual);
    }

    function assertEqualSetsWithIndex( $expected, $actual ) 

The function name assertEqualSetsWithIndex is in camel caps, but expected assert_equal_sets_with_index instead as per the coding standard.

    {
        ksort($expected);
        ksort($actual);
        $this->assertEquals($expected, $actual);
    }

    /**
     * Modify WordPress's query internals as if a given URL has been requested.
     *
     * @param string $url The URL for the request.
     */
    function go_to( $url ) 
    {
        // note: the WP and WP_Query classes like to silently fetch parameters
        // from all over the place (globals, GET, etc), which makes it tricky
        // to run them more than once without very carefully clearing everything
        $_GET = $_POST = array();
        foreach (array('query_string', 'id', 'postdata', 'authordata', 'day', 'currentmonth', 'page', 'pages', 'multipage', 'more', 'numpages', 'pagenow') as $v) {

No space before closing parenthesis is prohibited

            if (isset($GLOBALS[$v]) ) {

Array keys should be surrounded by spaces unless they contain a string or an integer.

                unset($GLOBALS[$v]);

Array keys should be surrounded by spaces unless they contain a string or an integer.

            }
        }
        $parts = parse_url($url);
        if (isset($parts['scheme'])) {

No space before closing parenthesis is prohibited

            $req = isset($parts['path']) ? $parts['path'] : '';
            if (isset($parts['query'])) {

No space before closing parenthesis is prohibited

                $req .= '?' . $parts['query'];
                // parse the url query vars into $_GET
                parse_str($parts['query'], $_GET);

Detected access of super global var $_GET, probably need manual inspection.

            }
        } else {
            $req = $url;
        }
        if (! isset($parts['query']) ) {

Expected 1 space before "!"; 0 found

            $parts['query'] = '';
        }

        $_SERVER['REQUEST_URI'] = $req;
        unset($_SERVER['PATH_INFO']);

        self::flush_cache();
        unset($GLOBALS['wp_query'], $GLOBALS['wp_the_query']);
        $GLOBALS['wp_the_query'] = new WP_Query();

Overridding WordPress globals is prohibited

        $GLOBALS['wp_query'] = $GLOBALS['wp_the_query'];

Overridding WordPress globals is prohibited

        $public_query_vars  = $GLOBALS['wp']->public_query_vars;
        $private_query_vars = $GLOBALS['wp']->private_query_vars;

        $GLOBALS['wp'] = new WP();

Overridding WordPress globals is prohibited

        $GLOBALS['wp']->public_query_vars  = $public_query_vars;
        $GLOBALS['wp']->private_query_vars = $private_query_vars;

        _cleanup_query_vars();

        $GLOBALS['wp']->main($parts['query']);
    }

    protected function checkRequirements() 

The function name checkRequirements is in camel caps, but expected check_requirements instead as per the coding standard.

    {
        parent::checkRequirements();

        // Core tests no longer check against open Trac tickets, but others using WP_UnitTestCase may do so.
        if (defined('WP_RUN_CORE_TESTS') && WP_RUN_CORE_TESTS ) {
            return;
        }

        if (WP_TESTS_FORCE_KNOWN_BUGS ) {
              return;
        }
        $tickets = PHPUnit_Util_Test::getTickets(get_class($this), $this->getName(false));

Consider using $this->name. There is an issue with getName() and APC-enabled PHP versions.

        foreach ( $tickets as $ticket ) {
            if (is_numeric($ticket) ) {
                $this->knownWPBug($ticket);
            } elseif ('UT' == substr($ticket, 0, 2) ) {
                $ticket = substr($ticket, 2);
                if ($ticket && is_numeric($ticket) ) {
                     $this->knownUTBug($ticket);
                }
            } elseif ('Plugin' == substr($ticket, 0, 6) ) {
                $ticket = substr($ticket, 6);
                if ($ticket && is_numeric($ticket) ) {
                     $this->knownPluginBug($ticket);
                }
            }
        }
    }

    /**
     * Skips the current test if there is an open WordPress ticket with id $ticket_id
     */
    function knownWPBug( $ticket_id ) 

The function name knownWPBug is in camel caps, but expected known_w_p_bug instead as per the coding standard.

    {
        if (WP_TESTS_FORCE_KNOWN_BUGS || in_array($ticket_id, self::$forced_tickets) ) {
              return;
        }
        if (! TracTickets::isTracTicketClosed('https://core.trac.wordpress.org', $ticket_id) ) {

The expression \TracTickets::isTracTicketClosed('https://core.trac.wordpress.org', $ticket_id) of type boolean|null is loosely compared to false; this is ambiguous if the boolean can be false. You might want to explicitly use !== null instead.

Expected 1 space before "!"; 0 found

              $this->markTestSkipped(sprintf('WordPress Ticket #%d is not fixed', $ticket_id));
        }
    }

    /**
     * Skips the current test if there is an open unit tests ticket with id $ticket_id
     */
    function knownUTBug( $ticket_id ) 

The function name knownUTBug is in camel caps, but expected known_u_t_bug instead as per the coding standard.

    {
        if (WP_TESTS_FORCE_KNOWN_BUGS || in_array('UT' . $ticket_id, self::$forced_tickets) ) {
              return;
        }
        if (! TracTickets::isTracTicketClosed('https://unit-tests.trac.wordpress.org', $ticket_id) ) {

The expression \TracTickets::isTracTicketClosed('https://unit-tests.trac.wordpress.org', $ticket_id) of type boolean|null is loosely compared to false; this is ambiguous if the boolean can be false. You might want to explicitly use !== null instead.

Expected 1 space before "!"; 0 found

              $this->markTestSkipped(sprintf('Unit Tests Ticket #%d is not fixed', $ticket_id));
        }
    }

    /**
     * Skips the current test if there is an open plugin ticket with id $ticket_id
     */
    function knownPluginBug( $ticket_id ) 

The function name knownPluginBug is in camel caps, but expected known_plugin_bug instead as per the coding standard.

    {
        if (WP_TESTS_FORCE_KNOWN_BUGS || in_array('Plugin' . $ticket_id, self::$forced_tickets) ) {
              return;
        }
        if (! TracTickets::isTracTicketClosed('https://plugins.trac.wordpress.org', $ticket_id) ) {

The expression \TracTickets::isTracTicketClosed('https://plugins.trac.wordpress.org', $ticket_id) of type boolean|null is loosely compared to false; this is ambiguous if the boolean can be false. You might want to explicitly use !== null instead.

Expected 1 space before "!"; 0 found

              $this->markTestSkipped(sprintf('WordPress Plugin Ticket #%d is not fixed', $ticket_id));
        }
    }

    public static function forceTicket( $ticket ) 

The function name forceTicket is in camel caps, but expected force_ticket instead as per the coding standard.

    {
        self::$forced_tickets[] = $ticket;
    }

    /**
     * Define constants after including files.
     */
    function prepareTemplate( Text_Template $template ) 

The function name prepareTemplate is in camel caps, but expected prepare_template instead as per the coding standard.

    {
        $template->setVar(array( 'constants' => '' ));
        $template->setVar(array( 'wp_constants' => PHPUnit_Util_GlobalState::getConstantsAsString() ));
        parent::prepareTemplate($template);
    }

    /**
     * Returns the name of a temporary file
     */
    function temp_filename() 
    {
        $tmp_dir = '';
        $dirs = array( 'TMP', 'TMPDIR', 'TEMP' );
        foreach( $dirs as $dir ) {

Space after opening control structure is required

No space before opening parenthesis is prohibited

            if (isset($_ENV[$dir]) && !empty($_ENV[$dir]) ) {

Array keys should be surrounded by spaces unless they contain a string or an integer.

Expected 1 space after "!"; 0 found

                $tmp_dir = $dir;
            }
             break;
        }
        if (empty($tmp_dir) ) {
            $tmp_dir = '/tmp';
        }
        $tmp_dir = realpath($tmp_dir);
        return tempnam($tmp_dir, 'wpunit');

Filesystem writes are forbidden, you should not be using tempnam()

    }

    /**
     * Check each of the WP_Query is_* functions/properties against expected boolean value.
     *
     * Any properties that are listed by name as parameters will be expected to be true; any others are
     * expected to be false. For example, assertQueryTrue('is_single', 'is_feed') means is_single()
     * and is_feed() must be true and everything else must be false to pass.
     *
     * @param string $prop,... Any number of WP_Query properties that are expected to be true for the current request.

There is no parameter named $prop,.... Was it maybe removed?

     */
    function assertQueryTrue(/* ... */) 

The function name assertQueryTrue is in camel caps, but expected assert_query_true instead as per the coding standard.

    {
        global $wp_query;
        $all = array(
         'is_404',
         'is_admin',
         'is_archive',
         'is_attachment',
         'is_author',
         'is_category',
         'is_comment_feed',
         'is_date',
         'is_day',
         'is_embed',
         'is_feed',
         'is_front_page',
         'is_home',
         'is_month',
         'is_page',
         'is_paged',
         'is_post_type_archive',
         'is_posts_page',
         'is_preview',
         'is_robots',
         'is_search',
         'is_single',
         'is_singular',
         'is_tag',
         'is_tax',
         'is_time',
         'is_trackback',
         'is_year',
        );
        $true = func_get_args();

        foreach ( $true as $true_thing ) {
               $this->assertContains($true_thing, $all, "{$true_thing}() is not handled by assertQueryTrue().");
        }

        $passed = true;
        $not_false = $not_true = array(); // properties that were not set to expected values

        foreach ( $all as $query_thing ) {
             $result = is_callable($query_thing) ? call_user_func($query_thing) : $wp_query->$query_thing;

            if (in_array($query_thing, $true) ) {
                if (! $result ) {

Expected 1 space before "!"; 0 found

                    array_push($not_true, $query_thing);
                    $passed = false;
                }
            } else if ($result ) {
                array_push($not_false, $query_thing);
                $passed = false;
            }
        }

        $message = '';
        if (count($not_true) ) {
               $message .= implode($not_true, ', ') . ' is expected to be true. ';
        }
        if (count($not_false) ) {
               $message .= implode($not_false, ', ') . ' is expected to be false.';
        }
        $this->assertTrue($passed, $message);
    }

    function unlink( $file ) 
    {
        $exists = is_file($file);
        if ($exists && ! in_array($file, self::$ignore_files) ) {
            //error_log( $file );
            unlink($file);

Filesystem writes are forbidden, you should not be using unlink()

        } elseif (! $exists ) {

Expected 1 space before "!"; 0 found

            $this->fail("Trying to delete a file that doesn't exist: $file");
        }
    }

    function rmdir( $path ) 
    {
        $files = $this->files_in_dir($path);
        foreach ( $files as $file ) {
            if (! in_array($file, self::$ignore_files) ) {

Expected 1 space before "!"; 0 found

                $this->unlink($file);
            }
        }
    }

    function remove_added_uploads() 
    {
        // Remove all uploads.
        $uploads = wp_upload_dir();
        $this->rmdir($uploads['basedir']);
    }

    function files_in_dir( $dir ) 
    {
        $files = array();

        $iterator = new RecursiveDirectoryIterator($dir);
        $objects = new RecursiveIteratorIterator($iterator);
        foreach ( $objects as $name => $object ) {
            if (is_file($name) ) {
                $files[] = $name;
            }
        }

        return $files;
    }

    function scan_user_uploads() 
    {
        static $files = array();
        if (! empty($files) ) {

Expected 1 space before "!"; 0 found

            return $files;
        }

        $uploads = wp_upload_dir();
        $files = $this->files_in_dir($uploads['basedir']);
        return $files;
    }

    function delete_folders( $path ) 
    {
        $this->matched_dirs = array();
        if (! is_dir($path) ) {

Expected 1 space before "!"; 0 found

            return;
        }

        $this->scandir($path);
        foreach ( array_reverse($this->matched_dirs) as $dir ) {
            rmdir($dir);

Filesystem writes are forbidden, you should not be using rmdir()

        }
        rmdir($path);

Filesystem writes are forbidden, you should not be using rmdir()

    }

    function scandir( $dir ) 
    {
        foreach ( scandir($dir) as $path ) {
            if (0 !== strpos($path, '.') && is_dir($dir . '/' . $path) ) {
                $this->matched_dirs[] = $dir . '/' . $path;
                $this->scandir($dir . '/' . $path);
            }
        }
    }

    /**
     * Helper to Convert a microtime string into a float
     */
    protected function _microtime_to_float($microtime )
    {
        $time_array = explode(' ', $microtime);
        return array_sum($time_array);
    }

    /**
     * Multisite-agnostic way to delete a user from the database.
     *
     * @since 4.3.0
     */
    public static function delete_user( $user_id ) 
    {
        if (is_multisite() ) {
            return wpmu_delete_user($user_id);
        } else {
            return wp_delete_user($user_id);
        }
    }

    /**
     * Utility method that resets permalinks and flushes rewrites.
     *
     * @since 4.4.0
     *
     * @global WP_Rewrite $wp_rewrite
     *
     * @param string $structure Optional. Permalink structure to set. Default empty.
     */
    public function set_permalink_structure( $structure = '' ) 
    {
        global $wp_rewrite;

        $wp_rewrite->init();
        $wp_rewrite->set_permalink_structure($structure);
        $wp_rewrite->flush_rules();
    }

    function _make_attachment($upload, $parent_post_id = 0) 
    {
        $type = '';
        if (!empty($upload['type']) ) {

This code seems to be duplicated across your project.

Expected 1 space after "!"; 0 found

Expected 1 space before "!"; 0 found

            $type = $upload['type'];
        } else {
            $mime = wp_check_filetype($upload['file']);
            if ($mime) {

No space before closing parenthesis is prohibited

                $type = $mime['type'];
            }
        }

        $attachment = array(
         'post_title' => basename($upload['file']),
         'post_content' => '',
         'post_type' => 'attachment',
         'post_parent' => $parent_post_id,
         'post_mime_type' => $type,
         'guid' => $upload[ 'url' ],

Array keys should NOT be surrounded by spaces if they only contain a string or an integer.

        );

        // Save the data
        $id = wp_insert_attachment($attachment, $upload[ 'file' ], $parent_post_id);

Array keys should NOT be surrounded by spaces if they only contain a string or an integer.

        wp_update_attachment_metadata($id, wp_generate_attachment_metadata($id, $upload['file']));
        return $id;
    }
}