{

/**

protected $ftp = null;

/**

protected $config = array(

'type' => 'ftp',

'port' => 21,

'timeout' => 90,

'user' => 'anonymous',

'password' => '',

'tmp' => 'tests/_data',

'passive' => false,

'cleanup' => true);

/**

protected $requiredFields = array('host');

// ----------- SETUP METHODS BELOW HERE -------------------------//

/**

public function _before(\Codeception\TestCase $test)

{

// Login using config settings

$this->loginAs($this->config['user'], $this->config['password']);

}

/**

public function _after()

{

$this->_closeConnection();

// Clean up temp files

if ($this->config['cleanup'])

{

if (file_exists($this->config['tmp'] . '/ftp_data_file.tmp'))

unlink($this->config['tmp'] . '/ftp_data_file.tmp');

}

}

/**

public function loginAs($user = 'anonymous', $password = '')

{

$this->_openConnection($user, $password); // Create new connection and login.

}

/**

public function amInPath($path)

{

$this->_changeDirectory($this->path = $this->absolutizePath($path) . ($path == '/' ? '' : DIRECTORY_SEPARATOR));

$this->debug('Moved to ' . $this->path);

}

/**

protected function absolutizePath($path)

{

if (strpos($path, '/') === 0) return $path;

return $this->path . $path;

}

// ----------- SEARCH METHODS BELOW HERE ------------------------//

/**

public function seeFileFound($filename, $path = '')

{

$files = $this->grabFileList($path);

$this->debug("see file: {$filename}");

\PHPUnit_Framework_Assert::assertContains($filename, $files, "file {$filename} not found in {$path}");

}

/**

public function seeFileFoundMatches($regex, $path = '')

{

foreach ($this->grabFileList($path) as $filename)

{

preg_match($regex, $filename, $matches);

if (!empty($matches)) {

$this->debug("file '{$filename}' matches '{$regex}'");

return;

}

}

\PHPUnit_Framework_Assert::fail("no file matches found for '{$regex}'");

}

/**

public function dontSeeFileFound($filename, $path = '')

{

$files = $this->grabFileList($path);

$this->debug("don't see file: {$filename}");

\PHPUnit_Framework_Assert::assertNotContains($filename, $files);

}

/**

public function dontSeeFileFoundMatches($regex, $path = '')

{

foreach ($this->grabFileList($path) as $filename)

{

preg_match($regex, $filename, $matches);

if (!empty($matches)) {

\PHPUnit_Framework_Assert::fail("file matches found for {$regex}");

return;

}

}

$this->debug("no files match '{$regex}'");

}

// ----------- UTILITY METHODS BELOW HERE -------------------------//

/**

public function openFile($filename)

{

$this->_openFile($this->absolutizePath($filename));

}

/**

public function writeToFile($filename, $contents)

{

$this->_writeToFile($this->absolutizePath($filename), $contents);

}

/**

public function makeDir($dirname)

{

$this->_makeDirectory($this->absolutizePath($dirname));

}

/**

public function copyDir($src, $dst) {

\PHPUnit_Framework_Assert::fail('copyDir() currently unsupported by FTP module');

}

/**

public function renameFile($filename, $rename)

{

$this->_renameDirectory($this->absolutizePath($filename), $this->absolutizePath($rename));

}

/**

public function renameDir($dirname, $rename)

{

$this->_renameDirectory($this->absolutizePath($dirname), $this->absolutizePath($rename));

}

/**

public function deleteFile($filename)

{

$this->_deleteFile($this->absolutizePath($filename));

}

/**

public function deleteDir($dirname)

{

$this->_deleteDirectory($this->absolutizePath($dirname));

}

/**

public function cleanDir($dirname)

{

$this->_clearDirectory($this->absolutizePath($dirname));

}

// ----------- GRABBER METHODS BELOW HERE -----------------------//

/**

public function grabFileList($path = '', $ignore = true)

{

$absolutize_path = $this->absolutizePath($path) . ($path != '' && substr($path, -1) != '/' ? DIRECTORY_SEPARATOR : '');

$files = $this->_listFiles($absolutize_path);

$display_files = array();

if (is_array($files) && !empty($files)) {

$this->debug('File List:');

foreach ($files as &$file) {

if (strtolower($file) != '.' &&

strtolower($file) != '..' &&

strtolower($file) != 'thumbs.db') { // Ignore '.', '..' and 'thumbs.db'

$file = str_replace($absolutize_path, '', $file); // Replace full path from file listings if returned in listing

$display_files[] = $file;

$this->debug(' - ' . $file);

}

}

return $ignore ? $display_files : $files;

}

$this->debug("File List: <empty>");

return array();

}

/**

public function grabFileCount($path = '', $ignore = true)

{

$count = count($this->grabFileList($path, $ignore));

$this->debug("File Count: {$count}");

return $count;

}

/**

public function grabFileSize($filename)

{

$filesize = $this->_size($filename);

$this->debug("{$filename} has a file size of {$filesize}");

return $filesize;

}

/**

public function grabFileModified($filename)

{

$time = $this->_modified($filename);

$this->debug("{$filename} was last modified at {$time}");

return $time;

}

/**

public function grabDirectory()

{

$pwd = $this->_directory();

$this->debug("PWD: {$pwd}");

return $pwd;

}

// ----------- SERVER CONNECTION METHODS BELOW HERE -------------//

/**

private function _openConnection($user = 'anonymous', $password = '')

{

$this->_closeConnection(); // Close connection if already open

switch(strtolower($this->config['type']))

{

case 'sftp':

$this->ftp = new \Net_SFTP($this->config['host'], $this->config['port'], $this->config['timeout']) or \PHPUnit_Framework_Assert::fail('failed to connect to ftp server');

if (!$this->ftp->login($user, $password)) {

\PHPUnit_Framework_Assert::fail('failed to authenticate user');

}

break;

default:

$this->ftp = ftp_connect($this->config['host'], $this->config['port'], $this->config['timeout']) or \PHPUnit_Framework_Assert::fail('failed to connect to ftp server');

// Set passive mode option (ftp only option)

if (isset($this->config['passive']))

{

ftp_pasv($this->ftp, strtolower($this->config['passive']) == 'enabled');

}

// Login using given access details

if (!@ftp_login($this->ftp, $user, $password))

{

\PHPUnit_Framework_Assert::fail('failed to authenticate user');

}

}

$pwd = $this->grabDirectory();

$this->path = $pwd . ($pwd == '/' ? '' : DIRECTORY_SEPARATOR);

}

/**

private function _closeConnection()

{

if (!is_null($this->ftp)) {

switch(strtolower($this->config['type']))

{

case 'sftp':

break;

default:

ftp_close($this->ftp);

}

}

}

/**

private function _listFiles($path)

{

switch(strtolower($this->config['type']))

{

case 'sftp':

$files = @$this->ftp->nlist($path);

if ($files !== false)

return $files;

break;

default:

$files = @ftp_nlist($this->ftp, $path);

if ($files !== false)

return $files;

}

\PHPUnit_Framework_Assert::fail("couldn't list files");

}

/**

private function _directory()

{

switch(strtolower($this->config['type']))

{

case 'sftp':

if ($pwd = @$this->ftp->pwd())

return $pwd;// == DIRECTORY_SEPARATOR ? '' : $pwd;

break;

default:

if ($pwd = @ftp_pwd($this->ftp))

return $pwd;

}

\PHPUnit_Framework_Assert::fail("couldn't get current directory");

}

/**

private function _changeDirectory($path)

{

switch(strtolower($this->config['type']))

{

case 'sftp':

if (@$this->ftp->chdir($path))

return;

break;

default:

if (@ftp_chdir($this->ftp, $path))

return;

}

\PHPUnit_Framework_Assert::fail("couldn't change directory {$path}");

}

/**

private function _openFile($filename)

{

// Check local tmp directory

if (!is_dir($this->config['tmp']) || !is_writeable($this->config['tmp'])) {

\PHPUnit_Framework_Assert::fail('tmp directory not found or is not writable');

}

// Download file to local tmp directory

$tmp_file = $this->config['tmp'] . "/ftp_data_file.tmp";

switch(strtolower($this->config['type']))

{

case 'sftp':

if (!@$this->ftp->get($filename, $tmp_file))

\PHPUnit_Framework_Assert::fail('failed to download file to tmp directory');

break;

default:

if (!@ftp_get($this->ftp, $tmp_file, $filename, FTP_BINARY))

\PHPUnit_Framework_Assert::fail('failed to download file to tmp directory');

}

// Open file content to variable

if($this->file = file_get_contents($tmp_file)){

$this->filepath = $filename;

} else {

\PHPUnit_Framework_Assert::fail('failed to open tmp file');

}

}

/**

private function _writeToFile($filename, $contents)

{

// Check local tmp directory

if (!is_dir($this->config['tmp']) || !is_writeable($this->config['tmp'])) {

\PHPUnit_Framework_Assert::fail('tmp directory not found or is not writable');

}

// Build temp file

$tmp_file = $this->config['tmp'] . "/ftp_data_file.tmp";

file_put_contents($tmp_file, $contents);

// Update variables

$this->filepath = $tmp_file;

$this->file = $contents;

// Upload the file to server

switch(strtolower($this->config['type']))

{

case 'sftp':

if (!@$this->ftp->put($filename, $tmp_file, NET_SFTP_LOCAL_FILE))

\PHPUnit_Framework_Assert::fail('failed to upload file to server');

break;

default:

if (!ftp_put($this->ftp, $filename, $tmp_file, FTP_BINARY))

\PHPUnit_Framework_Assert::fail('failed to upload file to server');

}

}

/**

private function _makeDirectory($path)

{

switch(strtolower($this->config['type']))

{

case 'sftp':

if (!@$this->ftp->mkdir($path, true))

\PHPUnit_Framework_Assert::fail("couldn't make directory {$path}");

break;

default:

if (!@ftp_mkdir($this->ftp, $path))

\PHPUnit_Framework_Assert::fail("couldn't make directory {$path}");

}

$this->debug("Make directory: {$path}");

}

/**

private function _renameDirectory($path, $rename)

{

switch(strtolower($this->config['type']))

{

case 'sftp':

if (!@$this->ftp->rename($path, $rename))

\PHPUnit_Framework_Assert::fail("couldn't rename directory {$path} to {$rename}");

break;

default:

if (!@ftp_rename($this->ftp, $path, $rename))

\PHPUnit_Framework_Assert::fail("couldn't rename directory {$path} to {$rename}");

}

$this->debug("Renamed directory: {$path} to {$rename}");

}

/**

private function _deleteFile($filename)

{

switch(strtolower($this->config['type']))

{

case 'sftp':

if (!@$this->ftp->delete($filename))

\PHPUnit_Framework_Assert::fail("couldn't delete {$filename}");

break;

default:

if (!@ftp_delete($this->ftp, $filename))

\PHPUnit_Framework_Assert::fail("couldn't delete {$filename}");

}

$this->debug("Deleted file: {$filename}");

}

/**

private function _deleteDirectory($path)

{

switch(strtolower($this->config['type']))

{

case 'sftp':

if (!@$this->ftp->delete($path, true))

\PHPUnit_Framework_Assert::fail("couldn't delete directory {$path}");

break;

default:

if (!@$this->_ftp_delete($path))

\PHPUnit_Framework_Assert::fail("couldn't delete directory {$path}");

}

$this->debug("Deleted directory: {$path}");

}

/**

private function _ftp_delete($directory)

{

# here we attempt to delete the file/directory

if( !(@ftp_rmdir($this->ftp, $directory) || @ftp_delete($this->ftp, $directory)) )

{

# if the attempt to delete fails, get the file listing

$filelist = @ftp_nlist($this->ftp, $directory);

# loop through the file list and recursively delete the FILE in the list

foreach($filelist as $file)

{

$this->_ftp_delete($file);

}

#if the file list is empty, delete the DIRECTORY we passed

$this->_ftp_delete($directory);

}

return true;

}

/**

private function _clearDirectory($path)

{

$this->debug("Clear directory: {$path}");

$this->_deleteDirectory($path);

$this->_makeDirectory($path);

}

/**

private function _size($filename)

{

switch(strtolower($this->config['type']))

{

case 'sftp':

if ($size = @$this->ftp->size($filename))

return $size;

break;

default:

if ($size = @ftp_size($this->ftp, $filename) > 0)

return $size;

}

\PHPUnit_Framework_Assert::fail("couldn't get the file size for {$filename}");

}

/**

private function _modified($filename)

{

switch(strtolower($this->config['type']))

{

case 'sftp':

if ($info = @$this->ftp->lstat($filename))

return $info['mtime'];

break;

default:

if ($time = @ftp_mdtm($this->ftp, $filename))

return $time;

}

\PHPUnit_Framework_Assert::fail("couldn't get the file size for {$filename}");

}

}