Ticket #31616: 31616.4.diff

src/wp-admin/includes/file.php

@@ -910 +910 @@
 
         $context = trailingslashit( $context );
 
-        if ( ! $method ) {
+        static $results = array();
 
-                $temp_file_name = $context . 'temp-write-test-' . time();
-                $temp_handle = @fopen($temp_file_name, 'w');
-                if ( $temp_handle ) {
+        // saving hash for static cache; file reads/writes are to be avoided when possible
+        $hash = md5(serialize($args) . $context . $allow_relaxed_file_ownership);
+        if ( ! isset($results[$hash])) {
 
-                        // Attempt to determine the file owner of the WordPress files, and that of newly created files
-                        $wp_file_owner = $temp_file_owner = false;
-                        if ( function_exists('fileowner') ) {
-                                $wp_file_owner = @fileowner( __FILE__ );
-                                $temp_file_owner = @fileowner( $temp_file_name );
+                if ( ! $method ) {
+
+                        $temp_file_name = $context . 'temp-write-test-' . time();
+                        $temp_handle    = @fopen( $temp_file_name, 'w' );
+                        if ( $temp_handle ) {
+
+                                // Attempt to determine the file owner of the WordPress files, and that of newly created files
+                                $wp_file_owner = $temp_file_owner = false;
+                                if ( function_exists( 'fileowner' ) ) {
+                                        $wp_file_owner   = @fileowner( __FILE__ );
+                                        $temp_file_owner = @fileowner( $temp_file_name );
+                                }
+
+                                if ( $wp_file_owner !== false && $wp_file_owner === $temp_file_owner ) {
+                                        // WordPress is creating files as the same owner as the WordPress files,
+                                        // this means it's safe to modify & create new files via PHP.
+                                        $method                                  = 'direct';
+                                        $GLOBALS['_wp_filesystem_direct_method'] = 'file_owner';
+                                } elseif ( $allow_relaxed_file_ownership ) {
+                                        // The $context directory is writable, and $allow_relaxed_file_ownership is set, this means we can modify files
+                                        // safely in this directory. This mode doesn't create new files, only alter existing ones.
+                                        $method                                  = 'direct';
+                                        $GLOBALS['_wp_filesystem_direct_method'] = 'relaxed_ownership';
+                                }
+
+                                @fclose( $temp_handle );
+                                @unlink( $temp_file_name );
                         }
+                }
 
-                        if ( $wp_file_owner !== false && $wp_file_owner === $temp_file_owner ) {
-                                // WordPress is creating files as the same owner as the WordPress files,
-                                // this means it's safe to modify & create new files via PHP.
-                                $method = 'direct';
-                                $GLOBALS['_wp_filesystem_direct_method'] = 'file_owner';
-                        } elseif ( $allow_relaxed_file_ownership ) {
-                                // The $context directory is writable, and $allow_relaxed_file_ownership is set, this means we can modify files
-                                // safely in this directory. This mode doesn't create new files, only alter existing ones.
-                                $method = 'direct';
-                                $GLOBALS['_wp_filesystem_direct_method'] = 'relaxed_ownership';
+                if ( ! $method && isset($args['connection_type']) && 'ssh' == $args['connection_type'] && extension_loaded('ssh2') && function_exists('stream_get_contents') ) $method = 'ssh2';
+                if ( ! $method && extension_loaded('ftp') ) $method = 'ftpext';
+                if ( ! $method && ( extension_loaded('sockets') || function_exists('fsockopen') ) ) $method = 'ftpsockets'; //Sockets: Socket extension; PHP Mode: FSockopen / fwrite / fread
+
+                /**
+                 * Filter the filesystem method to use.
+                 *
+                 * @since 2.6.0
+                 *
+                 * @param string $method  Filesystem method to return.
+                 * @param array  $args    An array of connection details for the method.
+                 * @param string $context Full path to the directory that is tested for being writable.
+                 * @param bool   $allow_relaxed_file_ownership Whether to allow Group/World writable.
+                 */
+                $results[$hash] = apply_filters( 'filesystem_method', $method, $args, $context, $allow_relaxed_file_ownership );
+        }
+
+        return $results[$hash];
+}
+
+/**
+ * Collects the filesystem credentials set in defines, $_POST data and database options.
+ *
+ * If no type is specified, a filesystem check will be done to see what
+ * type is available to use.
+ *
+ * If direct file access is possible, no credentials are needed.
+ *
+ * The variables of the credentials are collected using this order:
+ *
+ *     1. Defines - Preceed everything if they are set they are used
+ *     2. $_POST - Information submitted by the request form
+ *     3. Saved - Previously entered data that is saved will be used last
+ *
+ * Note: this function does not check if a specified type is available on this system
+ * it merly collects data based on available variables.
+ *
+ * @since 4.2.0
+ *
+ * @param array $args {
+ *      Optional. Arguments to define the environment. Default empty array.
+ *          @type string $form_post the URL to post the form to. Default ''. Accepts URL.
+ *          @type string $type the chosen Filesystem method in use. Default ''.
+ *              @type string $context The directory which is needed access to,
+ *                                    the write-test will be performed on this
+ *                                    directory by get_filesystem_method(). Default False.
+ *              @type bool $allow_relaxed_file_ownership Whether to allow Group/World writable. Default False.
+ * }
+ * @return array {
+ *    Optional. Credentials that are set on the system. Default empty array.
+ *      @type string $connection_type Type of connection the credentials are meant for.
+ *      @type string $hostname Optional.
+ *      @type string $username Optional.
+ *      @type string $password Optional.
+ *      @type string $public_key Optional. SSH public key.
+ *      @type string $private_key Optional. SSH private key.
+ *      @type int $port Optional.
+ * }
+ */
+function get_filesystem_credentials( $args = array() ) {
+        $defaults = array(
+                'form_post' => '',
+                'type' => '',
+                'context' => false,
+                'allow_relaxed_file_ownership' => false
+        );
+
+        $args = wp_parse_args( $args, $defaults );
+
+        // extract items
+        $type = $args['type'];
+        $context = $args['context'];
+        $allow_relaxed_file_ownership = $args['allow_relaxed_file_ownership'];
+
+        // For the direct method no credentials are needed
+        if ( empty($type) ) {
+                $type = get_filesystem_method( array(), $context, $allow_relaxed_file_ownership );
+        }
+
+        if ( 'direct' == $type ) {
+                return array( 'connection_type' => 'direct' );
+        }
+
+        // Retrieve saved information
+        $credentials = get_option('ftp_credentials', array( 'hostname' => '', 'username' => ''));
+
+        // If defined, set it to that, Else, If POST'd, set it to that, If not, Set it to whatever it previously was(saved details in option)
+        $credentials['hostname'] = defined('FTP_HOST') ? FTP_HOST : (!empty($_POST['hostname']) ? wp_unslash( $_POST['hostname'] ) : $credentials['hostname']);
+        $credentials['username'] = defined('FTP_USER') ? FTP_USER : (!empty($_POST['username']) ? wp_unslash( $_POST['username'] ) : $credentials['username']);
+        $credentials['password'] = defined('FTP_PASS') ? FTP_PASS : (!empty($_POST['password']) ? wp_unslash( $_POST['password'] ) : '');
+
+        // Check to see if we are setting the public/private keys for ssh
+        $credentials['public_key'] = defined('FTP_PUBKEY') ? FTP_PUBKEY : (!empty($_POST['public_key']) ? wp_unslash( $_POST['public_key'] ) : '');
+        $credentials['private_key'] = defined('FTP_PRIKEY') ? FTP_PRIKEY : (!empty($_POST['private_key']) ? wp_unslash( $_POST['private_key'] ) : '');
+
+        // Sanitize the hostname, Some people might pass in odd-data:
+        $credentials['hostname'] = preg_replace('|\w+://|', '', $credentials['hostname']); //Strip any schemes off
+
+        // If hostname contains a port, check it and separate it
+        if ( strpos($credentials['hostname'], ':') ) {
+                list( $credentials['hostname'], $credentials['port'] ) = explode(':', $credentials['hostname'], 2);
+                if ( ! is_numeric($credentials['port']) )
+                        unset($credentials['port']);
+        } else {
+                unset($credentials['port']);
+        }
+
+        // Determine connection type available
+        if ( ( defined( 'FTP_SSH' ) && FTP_SSH ) || ( defined( 'FS_METHOD' ) && 'ssh2' == FS_METHOD ) ) {
+                $credentials['connection_type'] = 'ssh';
+        } elseif ( ( defined( 'FTP_SSL' ) && FTP_SSL ) && 'ftpext' == $type ) { //Only the FTP Extension understands SSL
+                $credentials['connection_type'] = 'ftps';
+        } elseif ( ! empty( $_POST['connection_type'] ) ) {
+                $credentials['connection_type'] = wp_unslash( $_POST['connection_type'] );
+        } elseif ( ! isset( $credentials['connection_type'] ) ) { //All else fails (And it's not defaulted to something else saved), Default to FTP
+                $credentials['connection_type'] = 'ftp';
+        }
+
+        return $credentials;
+}
+
+/**
+ * Check credentials for required parameters.
+ *
+ * Depending on the connection_type certain information is needed to be able to
+ * attempt a connection.
+ *
+ * Type of connection:
+ *
+ * - direct: needs no information
+ * - ssh: public and private keys
+ * - other: hostname(:port), username and password
+ *
+ * Plugins may override this check by returning true|false via the
+ * {@see 'request_filesystem_credentials'} filter.
+ *
+ * @since 4.2.0
+ *
+ * @param array $credentials the data to verify entered parameters on.
+ *
+ * @param array $args {
+ *      Optional. Arguments to feed to the filter. Default empty array.
+ *          @type string $form_post the URL to post the form to. Default ''. Accepts URL.
+ *          @type string $type the chosen Filesystem method in use. Default ''.
+ *              @type bool $error if the current request has failed to connect. Default False.
+ *              @type string $context The directory which is needed access to, the write-test will be performed on this
+ *                                    directory by get_filesystem_method(). Default False.
+ *              @type array $extra_fields Extra POST fields which should be checked for to be included in the post. Default null.
+ *              @type bool $allow_relaxed_file_ownership Whether to allow Group/World writable. Default False.
+ * }
+ *
+ * @return bool True when all required parameters have been set for supplied type,
+ *              False when parameter is missing or empty.
+ */
+function usable_filesystem_credentials($credentials, $args = array()) {
+        $defaults = array(
+                'form_post' => '',
+                'type' => '',
+                'error' => false,
+                'context' => false,
+                'extra_fields' => null,
+                'allow_relaxed_file_ownership' => false
+        );
+
+        $args = wp_parse_args( $args, $defaults );
+
+        // extract items
+        $form_post = $args['form_post'];
+        $type = $args['type'];
+        $error = $args['error'];
+        $context = $args['context'];
+        $extra_fields = $args['extra_fields'];
+        $allow_relaxed_file_ownership = $args['allow_relaxed_file_ownership'];
+
+        /** This filter is documented in wp-includes/file.php */
+        $req_cred = apply_filters( 'request_filesystem_credentials', '', $form_post, $type, $error, $context, $extra_fields, $allow_relaxed_file_ownership );
+        if ( '' !== $req_cred )
+                return $req_cred;
+
+
+        // We need something to check against
+        if ( empty( $credentials ) ) {
+                return false;
+        }
+
+        // All the checks required an array for parameters; exit if we got something else
+        if ( ! is_array( $credentials ) ) {
+                return false;
+        }
+
+        if ( isset( $credentials['connection_type'] ) ) {
+                if ( 'direct' == $credentials['connection_type'] ) {
+                        return true;
+                }
+
+                // SSH needs public and private key
+                if ( 'ssh' == $credentials['connection_type'] ) {
+                        if ( ! isset( $credentials['public_key'], $credentials['private_key'] ) ) {
+                                return false;
                         }
 
-                        @fclose($temp_handle);
-                        @unlink($temp_file_name);
+                        return ( ! empty( $credentials['public_key'] ) && ! empty( $credentials['private_key'] ) );
                 }
-        }
+        }
 
-        if ( ! $method && isset($args['connection_type']) && 'ssh' == $args['connection_type'] && extension_loaded('ssh2') && function_exists('stream_get_contents') ) $method = 'ssh2';
-        if ( ! $method && extension_loaded('ftp') ) $method = 'ftpext';
-        if ( ! $method && ( extension_loaded('sockets') || function_exists('fsockopen') ) ) $method = 'ftpsockets'; //Sockets: Socket extension; PHP Mode: FSockopen / fwrite / fread
+        // Other connection methods need hostname, password and username
+        if ( ! isset( $credentials['password'], $credentials['username'], $credentials['hostname'] ) ) {
+                return false;
+        }
 
-        /**
-         * Filter the filesystem method to use.
-         *
-         * @since 2.6.0
-         *
-         * @param string $method  Filesystem method to return.
-         * @param array  $args    An array of connection details for the method.
-         * @param string $context Full path to the directory that is tested for being writable.
-         * @param bool   $allow_relaxed_file_ownership Whether to allow Group/World writable.
-         */
-        return apply_filters( 'filesystem_method', $method, $args, $context, $allow_relaxed_file_ownership );
+        return ( ! empty( $credentials['password'] ) && ! empty( $credentials['username'] ) && ! empty( $credentials['hostname'] ) );
 }
 
 /**
@@ -971 +1173 @@
  *
  * @since 2.5.
  *
- * @todo Properly mark optional arguments as such
- *
- * @param string $form_post the URL to post the form to
- * @param string $type the chosen Filesystem method in use
- * @param boolean $error if the current request has failed to connect
- * @param string $context The directory which is needed access to, The write-test will be performed on this directory by get_filesystem_method()
- * @param array $extra_fields Extra POST fields which should be checked for to be included in the post.
- * @param bool $allow_relaxed_file_ownership Whether to allow Group/World writable.
+ * @param string $form_post the URL to post the form to.
+ * @param string $type Optional. the chosen Filesystem method in use.
+ * @param boolean $error Optional. if the current request has failed to connect.
+ * @param string $context Optional. The directory which is needed access to,The write-test will be performed on this directory by get_filesystem_method().
+ * @param array $extra_fields Optional. Extra POST fields which should be checked for to be included in the post.
+ * @param bool $allow_relaxed_file_ownership Optional. Whether to allow Group/World writable.
  * @return boolean False on failure. True on success.
  */
 function request_filesystem_credentials($form_post, $type = '', $error = false, $context = false, $extra_fields = null, $allow_relaxed_file_ownership = false ) {
-
         /**
          * Filter the filesystem credentials form output.
          *
@@ -1005 +1204 @@
         if ( '' !== $req_cred )
                 return $req_cred;
 
-        if ( empty($type) ) {
+
+        // If no type is supplied, check to see if 'direct' method can be used.
+        if ( empty( $type ) ) {
                 $type = get_filesystem_method( array(), $context, $allow_relaxed_file_ownership );
         }
 
-        if ( 'direct' == $type )
+        if ( 'direct' == $type ) {
                 return true;
+        }
 
-        if ( is_null( $extra_fields ) )
-                $extra_fields = array( 'version', 'locale' );
+        $args = array(
+                'form_post' => $form_post,
+                'type' => $type,
+                'error' => $error,
+                'context' => $context,
+                'extra_fields' => $extra_fields,
+                'allow_relaxed_file_ownership' => $allow_relaxed_file_ownership
+        );
 
-        $credentials = get_option('ftp_credentials', array( 'hostname' => '', 'username' => ''));
+        $credentials = get_filesystem_credentials( $args );
 
-        // If defined, set it to that, Else, If POST'd, set it to that, If not, Set it to whatever it previously was(saved details in option)
-        $credentials['hostname'] = defined('FTP_HOST') ? FTP_HOST : (!empty($_POST['hostname']) ? wp_unslash( $_POST['hostname'] ) : $credentials['hostname']);
-        $credentials['username'] = defined('FTP_USER') ? FTP_USER : (!empty($_POST['username']) ? wp_unslash( $_POST['username'] ) : $credentials['username']);
-        $credentials['password'] = defined('FTP_PASS') ? FTP_PASS : (!empty($_POST['password']) ? wp_unslash( $_POST['password'] ) : '');
+        if ( 'direct' == $credentials['connection_type'] ) {
+                return true;
+        }
 
-        // Check to see if we are setting the public/private keys for ssh
-        $credentials['public_key'] = defined('FTP_PUBKEY') ? FTP_PUBKEY : (!empty($_POST['public_key']) ? wp_unslash( $_POST['public_key'] ) : '');
-        $credentials['private_key'] = defined('FTP_PRIKEY') ? FTP_PRIKEY : (!empty($_POST['private_key']) ? wp_unslash( $_POST['private_key'] ) : '');
+        if ( ! $error && usable_filesystem_credentials( $credentials ) ) {
 
-        // Sanitize the hostname, Some people might pass in odd-data:
-        $credentials['hostname'] = preg_replace('|\w+://|', '', $credentials['hostname']); //Strip any schemes off
-
-        if ( strpos($credentials['hostname'], ':') ) {
-                list( $credentials['hostname'], $credentials['port'] ) = explode(':', $credentials['hostname'], 2);
-                if ( ! is_numeric($credentials['port']) )
-                        unset($credentials['port']);
-        } else {
-                unset($credentials['port']);
-        }
-
-        if ( ( defined( 'FTP_SSH' ) && FTP_SSH ) || ( defined( 'FS_METHOD' ) && 'ssh2' == FS_METHOD ) ) {
-                $credentials['connection_type'] = 'ssh';
-        } elseif ( ( defined( 'FTP_SSL' ) && FTP_SSL ) && 'ftpext' == $type ) { //Only the FTP Extension understands SSL
-                $credentials['connection_type'] = 'ftps';
-        } elseif ( ! empty( $_POST['connection_type'] ) ) {
-                $credentials['connection_type'] = wp_unslash( $_POST['connection_type'] );
-        } elseif ( ! isset( $credentials['connection_type'] ) ) { //All else fails (And it's not defaulted to something else saved), Default to FTP
-                $credentials['connection_type'] = 'ftp';
-        }
-        if ( ! $error &&
-                        (
-                                ( !empty($credentials['password']) && !empty($credentials['username']) && !empty($credentials['hostname']) ) ||
-                                ( 'ssh' == $credentials['connection_type'] && !empty($credentials['public_key']) && !empty($credentials['private_key']) )
-                        ) ) {
                 $stored_credentials = $credentials;
-                if ( !empty($stored_credentials['port']) ) //save port as part of hostname to simplify above code.
+                if ( ! empty( $stored_credentials['port'] ) ) //save port as part of hostname to simplify retrievement code
+                {
                         $stored_credentials['hostname'] .= ':' . $stored_credentials['port'];
+                }
 
-                unset($stored_credentials['password'], $stored_credentials['port'], $stored_credentials['private_key'], $stored_credentials['public_key']);
+                unset( $stored_credentials['password'], $stored_credentials['port'], $stored_credentials['private_key'], $stored_credentials['public_key'] );
+
                 if ( ! defined( 'WP_INSTALLING' ) ) {
                         update_option( 'ftp_credentials', $stored_credentials );
                 }
+
                 return $credentials;
         }
+
+        // Output the request for credentials to the user
+        $args = array(
+                'form_post' => $form_post,
+                'credentials' => $credentials,
+                'type' => $type,
+                'error' => $error,
+                'context' => $context,
+                'extra_fiels' => $extra_fields,
+                'allow_relaxed_file_ownership' => $allow_relaxed_file_ownership
+        );
+
+        request_filesystem_credentials_form( $args );
+
+        // Nothing usable has been found yet.
+        return false;
+}
+
+/**
+ * Displays the form to request needed credentials in order to have sufficient
+ * filesystem control.
+ *
+ * @since 4.2.0
+ *
+ * @param array $args {
+ *   Optional. Arguments for pre-filling the form. Default empty array.
+ *      @type string $form_post the URL to post the form to. Default ''. Accepts URL.
+ *      @type array $credentials credentials that will be pre-filled in the form. Default empty array.
+ *      @type bool $error if the current request has failed to connect. Default False.
+ *      @type string $context The directory which is needed access to,
+ *                            The write-test will be performed on this directory
+ *                            by get_filesystem_method(). Default false.
+ *      @type array $extra_fields Extra POST fields which should be checked for to be included in the post. Default null.
+ *      @type bool $allow_relaxed_file_ownership Whether to allow Group/World writable. Default False.
+ * }
+ */
+function request_filesystem_credentials_form($args = array()) {
+        $defaults = array(
+                'form_post' => '',
+                'credentials' => array(),
+                'type' => '',
+                'error' => false,
+                'context' => false,
+                'extra_fields' => null,
+                'allow_relaxed_file_ownership' => false
+        );
+
+        $args = wp_parse_args( $args, $defaults );
+
+        // extract variables from args
+        $form_post = $args['form_post'];
+        $credentials = $args['credentials'];
+        $type = $args['type'];
+        $error = $args['error'];
+        $context = $args['context'];
+        $extra_fields = $args['extra_fields'];
+        $allow_relaxed_file_ownership = $args['allow_relaxed_file_ownership'];
+
+        if ( empty( $type ) ) {
+                $type = get_filesystem_method( array(), $context, $allow_relaxed_file_ownership );
+        }
+
+        if ( ! is_array($credentials)) {
+                $credentials = array();
+        }
+
         $hostname = isset( $credentials['hostname'] ) ? $credentials['hostname'] : '';
         $username = isset( $credentials['username'] ) ? $credentials['username'] : '';
         $public_key = isset( $credentials['public_key'] ) ? $credentials['public_key'] : '';
@@ -1068 +1318 @@
         $port = isset( $credentials['port'] ) ? $credentials['port'] : '';
         $connection_type = isset( $credentials['connection_type'] ) ? $credentials['connection_type'] : '';
 
+        if ( is_null( $args['extra_fields'] ) )
+                $extra_fields = array( 'version', 'locale' );
+
         if ( $error ) {
                 $error_string = __('<strong>ERROR:</strong> There was an error connecting to the server, Please verify the settings are correct.');
                 if ( is_wp_error($error) )
@@ -1075 +1328 @@
                 echo '<div id="message" class="error"><p>' . $error_string . '</p></div>';
         }
 
+
+        // Detect available types by extension
         $types = array();
         if ( extension_loaded('ftp') || extension_loaded('sockets') || function_exists('fsockopen') )
                 $types[ 'ftp' ] = __('FTP');
@@ -1190 +1445 @@
 </div>
 </form>
 <?php
-        return false;
+
 }

tests/phpunit/tests/filesystem/credentials.php

@@ +1 @@
+<?php
+
+/**
+ * @group filesystem
+ * @group wp-filesystem
+ */
+
+/**
+ * Verification of filesystem credentials retrievement and validation.
+ *
+ * We cannot use WP_Filesystem_UnitTestCase because filesystem method 'MockFS' will influence test results.
+ */
+class Tests_Filesystem_Credentials extends WP_UnitTestCase {
+
+        public function tearDown() {
+                $this->clear_credentials_option();
+        }
+
+        /**
+         * Direct type does not need credentials
+         */
+        function test_direct_credentials_retrievement() {
+                // test direct type
+                $credentials = get_filesystem_credentials( array('type' => 'direct' ) );
+                $this->assertInternalType( 'array', $credentials );
+                $this->assertArrayHasKey( 'connection_type', $credentials );
+                $this->assertEquals( 'direct', $credentials['connection_type'] );
+        }
+
+        function test_credentials_retrievement_filter_override() {
+                add_filter( 'filesystem_method', array($this, 'filter_filesystem_method') );
+
+                $credentials = get_filesystem_credentials();
+
+                $this->assertInternalType( 'array', $credentials );
+                $this->assertArrayHasKey( 'connection_type', $credentials );
+                $this->assertNotEquals( 'direct', $credentials['connection_type'] );
+
+                remove_filter( 'filesystem_method', array($this, 'filter_filesystem_method') );
+        }
+
+        /**
+         * No variables set; test for expected parameters
+         */
+        function test_credentials_retrievement() {
+                // setting type to anything but 'direct'
+                $credentials = get_filesystem_credentials( array('type' => 'ssh') );
+
+                $this->assertInternalType( 'array', $credentials );
+
+                $this->assertArrayHasKey( 'connection_type', $credentials );
+                $this->assertArrayHasKey( 'private_key', $credentials );
+                $this->assertArrayHasKey( 'public_key', $credentials );
+                $this->assertArrayHasKey( 'hostname', $credentials );
+                $this->assertArrayHasKey( 'username', $credentials );
+                $this->assertArrayHasKey( 'password', $credentials );
+
+                $this->assertEquals( '', $credentials['private_key'] );
+                $this->assertEquals( '', $credentials['public_key'] );
+                $this->assertEquals( '', $credentials['hostname'] );
+                $this->assertEquals( '', $credentials['username'] );
+                $this->assertEquals( '', $credentials['password'] );
+        }
+
+        /**
+         * When credentials are saved to options; these should be applied
+         */
+        function test_saved_credentials_retrievement() {
+                // test saved variables
+
+                $this->set_credentials_option();
+
+                $credentials = get_filesystem_credentials( array('type' => 'ftp') );
+
+                $this->assertEquals( '', $credentials['private_key'] );
+                $this->assertEquals( '', $credentials['public_key'] );
+                $this->assertEquals( '', $credentials['password'] );
+                $this->assertEquals( 'wordpress.org', $credentials['hostname'] );
+                $this->assertEquals( 'wordpress', $credentials['username'] );
+                $this->assertEquals( 'ftp', $credentials['connection_type'] );
+        }
+
+        /**
+         * When credentials are submitted to the page; these take precedence over saved variables;
+         */
+        function test_submitted_credentials_retrievement() {
+                // test retrieving of submitted data
+                $_POST['hostname'] = rand_str();
+                $_POST['private_key'] = rand_str();
+                $_POST['public_key'] = rand_str();
+                $_POST['username'] = rand_str();
+                $_POST['password'] = rand_str();
+
+                // set option variables; to see if they aren't used
+                $this->set_credentials_option();
+
+                $credentials = get_filesystem_credentials( array('type' => 'ftp') );
+
+                // saved variables are set but should be ignored!
+                $this->assertEquals( $_POST['private_key'], $credentials['private_key'] );
+                $this->assertEquals( $_POST['public_key'], $credentials['public_key'] );
+                $this->assertEquals( $_POST['hostname'], $credentials['hostname'] );
+                $this->assertEquals( $_POST['username'], $credentials['username'] );
+                $this->assertEquals( $_POST['password'], $credentials['password'] );
+                $this->assertEquals( 'ftp', $credentials['connection_type'] );
+
+                unset($_POST['hostname'], $_POST['private_key'], $_POST['public_key'], $_POST['username'], $_POST['password']);
+        }
+
+        /**
+         * Direct connection does not need credentials, passing only the connection_type is sufficient
+         */
+        function test_usable_direct_credentials() {
+                $credentials = array('connection_type' => 'direct');
+                $this->assertTrue( usable_filesystem_credentials( $credentials ) );
+        }
+
+        /**
+         * Test for SSH parameter checks
+         */
+        function test_usable_ssh_credentials() {
+                // ssh:
+                $credentials = get_filesystem_credentials( array('type' => 'ssh' ) );
+                $credentials['connection_type'] = 'ssh';
+
+                // missing private_key & public_key
+                $this->assertFalse( usable_filesystem_credentials( $credentials ) );
+
+                // set private_key & public_key
+                $credentials['private_key'] = 'private';
+                $credentials['public_key'] = 'public';
+                $this->assertTrue( usable_filesystem_credentials( $credentials ) );
+        }
+
+        /**
+         * Test for SSH2 parameter checks
+         */
+        function test_usable_ssh2_credentials() {
+                // ssh2
+                $credentials = array(
+                        'connection_type' => 'ssh2'
+                );
+
+                $this->assertFalse( usable_filesystem_credentials( $credentials ) );
+
+                $credentials = array(
+                        'public_key' => 'a',
+                        'private_key' => 'b',
+                        'connection_type' => 'ssh2'
+                );
+                $this->assertFalse( usable_filesystem_credentials( $credentials ) );
+
+                $credentials = array(
+                        'hostname' => 'a',
+                        'username' => 'b',
+                        'password' => 'c',
+                        'connection_type' => 'ssh2'
+                );
+                $this->assertTrue( usable_filesystem_credentials( $credentials ) );
+        }
+
+        /**
+         * Test for expected results with FTP or other credentials
+         */
+        function test_usable_ftp_credentials() {
+                // required elements are empty
+                $credentials = array(
+                        'hostname' => '',
+                        'username' => '',
+                        'password' => '',
+                        'connection_type' => 'ftp'
+                );
+                $this->assertFalse( usable_filesystem_credentials( $credentials ) );
+
+                // required elements are missing
+                $credentials = array(
+                        'hostname' => 'localhost',
+                        'connection_type' => 'ftp'
+                );
+                $this->assertFalse( usable_filesystem_credentials( $credentials ) );
+
+                // required elements are set
+                $credentials = array(
+                        'hostname' => 'a',
+                        'username' => 'b',
+                        'password' => 'c',
+                        'connection_type' => 'ftp'
+                );
+                $this->assertTrue( usable_filesystem_credentials( $credentials ) );
+        }
+
+        /**
+         * Test if the 'request_filesystem_credentials' filter is applied properly
+         */
+        function test_usable_credentials_filter_override() {
+                // sufficient credentials:
+                $credentials = array(
+                        'hostname' => 'a',
+                        'username' => 'b',
+                        'password' => 'c',
+                        'connection_type' => 'ftp'
+                );
+
+                $this->assertTrue( usable_filesystem_credentials( $credentials, array('type' => 'ftp') ) );
+
+                // force a failure
+                add_filter( 'request_filesystem_credentials', '__return_false' );
+
+                $usable = usable_filesystem_credentials( $credentials, array('type' => 'ftp') );
+                $this->assertFalse( $usable );
+
+                remove_filter( 'request_filesystem_credentials', '__return_false' );
+
+
+
+                // insufficient credentials:
+                $credentials = array(
+                        'public_key' => '',
+                        'private_key' => '',
+                        'connection_type' => 'ssh'
+                );
+
+                $this->assertFalse( usable_filesystem_credentials( $credentials, array('type' => 'ssh') ) );
+
+                // force a success
+                add_filter( 'request_filesystem_credentials', '__return_true' );
+
+                $usable = usable_filesystem_credentials( $credentials, array('type' => 'ssh') );
+                $this->assertTrue( $usable );
+
+                // clean up filter
+                remove_filter( 'request_filesystem_credentials', '__return_true' );
+        }
+
+        /** Helper functions */
+        function set_credentials_option() {
+                $credentials = array();
+                $credentials['username'] = 'wordpress';
+                $credentials['hostname'] = 'wordpress.org';
+                update_option('ftp_credentials', $credentials);
+        }
+
+        function clear_credentials_option() {
+                delete_option('ftp_credentials');
+        }
+
+        public static function filter_filesystem_method() {
+                // anything but 'direct'
+                return 'ftp';
+        }
+}