2.5.3 - Update LOG()

v2.5.2 add support for psr/log ^1
v2.5.1 - Update psr/log reqs
2025-07-01 13:42:22 +00:00 · 2025-06-08 15:20:22 +12:00 · 2025-06-08 14:21:33 +12:00 · 2025-06-08 13:59:27 +12:00 · 2025-06-08 13:49:16 +12:00 · 2024-12-11 14:31:58 +13:00
61 changed files with 3781 additions and 1357 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -0,0 +1,36 @@
+name: CI
+on: [push]
+jobs:
+  Linter:
+    runs-on: ubuntu-latest
+    container: php:8.2
+    steps:
+    - uses: actions/checkout@v3
+    - name: Install composer
+      run: apt-get update -yq && apt-get install git wget procps unzip -y && pecl install -o -f redis && rm -rf /tmp/pear && docker-php-ext-enable redis && wget https://getcomposer.org/composer.phar && php composer.phar install --dev
+    - name: Validate composer.json and composer.lock
+      run: php composer.phar validate --strict
+    - name: Install dependencies
+      run: php composer.phar install --dev --prefer-dist --no-progress
+    - name: Run PHPCS Linter
+      run: php -d memory_limit=256M vendor/bin/phpcs -s --standard=ruleset.xml
+  PHPTest:
+    runs-on: ubuntu-latest
+    container: php:${{ matrix.php_version }}
+    strategy:
+      matrix:
+        php_version: [8.1, 8.2,8.3,8.4]
+    services:
+      redis:
+        image: redis:7.0
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    steps:
+    - uses: actions/checkout@v3
+    - name: Install composer
+      run: apt-get update -yq && apt-get install git wget procps unzip -y && pecl install -o -f redis && rm -rf /tmp/pear && docker-php-ext-enable redis && wget https://getcomposer.org/composer.phar && php composer.phar install --dev
+    - name: Run PHP ${{ matrix.php_version }}} Unit Tests
+      run: php vendor/bin/phpunit --verbose --configuration phpunit.xml
--- a/.gitignore
+++ b/.gitignore
@ -1,3 +1,2 @@
 vendor/
-*.swp
-phpunit.xml
+.phpunit.result.cache
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -0,0 +1,43 @@
+.docker_boostrap: &docker_boostrap |
+  [[ ! -e /.dockerenv ]] && exit 0
+  set -xe
+    
+  # Install git (the php image doesn't have it) which is required by composer
+  apt-get update -yq
+  apt-get install git wget procps unzip -y
+
+  # Install pcntl and redis extentions
+  pecl install -o -f redis \
+  && rm -rf /tmp/pear \
+  && docker-php-ext-enable redis
+  docker-php-ext-install pcntl
+
+  # Install Composer
+  wget https://getcomposer.org/composer.phar
+  php composer.phar install --dev
+
+services:
+  - redis:7
+
+# Test PHP
+test:
+  image: php:$PHP_VERSION
+  parallel:
+    matrix:
+      - PHP_VERSION: [ "7.4", "8.0", "8.1", "8.2" ]
+  before_script:
+    - *docker_boostrap
+  script:
+    - php vendor/bin/phpunit --verbose --configuration phpunit.xml
+  tags:
+    - docker
+
+# Codestandards
+lint:
+  image: php:8.2
+  allow_failure: true
+  script:
+    - apt update && apt install -y wget unzip git
+    - wget https://getcomposer.org/composer.phar
+    - php composer.phar install --dev
+    - php -d memory_limit=256M vendor/bin/phpcs -s --standard=ruleset.xml
--- a/.travis.yml
+++ b/.travis.yml
@ -1,13 +0,0 @@
-language: php
-
-php:
-  - 7.0
-  - 7.1
-  - 7.2
-
-services:
-  - redis-server
-
-before_script:
-  - echo "extension = redis.so" >> ~/.phpenv/versions/$(phpenv version-name)/etc/php.ini
-  - composer install
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,3 +1,75 @@
+# 2.5.3 (2025-06-08)
+- Update typing of Log() to support all psr\log versions
+
+- # 2.5.2 (2025-06-08)
+- Update typing of Log() to support all psr\log versions
+
+# 2.5.1 (2025-06-08)
+- Update psr/log version requirements
+
+# 2.5.0 (2025-06-08)
+- Update packages
+
+# 2.4.0 (2024-12-11)
+- Update packages (psr/log ^3.0.2)
+
+# 2.3.0 (2024-09-04)
+- Update packages
+
+# 2.2.0 (2023-03-20)
+- Update pacakges
+- Bump requirements to PHP >= 8.1
+
+# 2.1.3 (2023-11-15)
+- Resolved issue with SET EX TTL's using unix-timestamps
+
+# 2.1.2 (2023-03-22)
+- Update composer packages
+- Update git information (GitHub)
+
+# 2.1.1 (2023-03-20)
+- Changed setex to set with EX values
+- Added TTLs to missing keys
+
+## 2.1.0 (2023-02-07)
+- Add PHP 8.1 / 8.2 unit tests
+- Updated code to be PHP 8.2 compliant
+
+## 2.0.3 (2022-09-12)
+- Update composer packages
+- Added WoodpeckerCI tests
+- Updated links in composer package
+- Stricter typing
+
+## 2.0.2 (2022-02-15)
+- Replace strftime with strtotime for PHP8.1 support
+- Added processing class into proc line for easier debugging
+
+## 2.0.1 (2022-02-08)
+- Fixed issue with lingering keys causing constant memory growth
+- Add PHP8 support
+- Composer upgrade
+
+## 2.0.0 (2021-02-19)
+- Moved to PSR-4
+- Namespaced codebase
+- Added more comments throughout
+
+## 1.4.7 (2020-04-11)
+- Update PHPUnit to 9
+- Start adding return types
+
+## 1.4.6 (2020-01-10)
+- Switched IF Statement order to prevent excess calls to redis.
+
+## 1.4.5 (2019-08-28)
+- Added 'replaced' composer tag.
+- Formatting changes.
+
+## 1.4.4 (2019-06-02)
+- Updated tests to run on GitLab CI.
+- Can now run tests locally using `gitlab-runner exec docker test:7.0`
+
 ## 1.4.3 (2018-07-16)
 - Updated README to include supervisor configuration.
 - Change logfile date format to `%Y-%m-%d %T`.
@ -78,7 +150,7 @@ Changes by iskandar introduce improved support for using DSNs to connect to Redi
 * Pass queue name to afterEvent callback
 * Only declare RedisException if it doesn't already exist (Matt Heath)
 * Add support for Composer
-* Fix missing and incorrect paths for Resque and Resque_Job_Status classes in demo (jjfrey)
+* Fix missing and incorrect paths for Resque and \Resque\Job\Status classes in demo (jjfrey)
 * Disable autoload for the RedisException class_exists call (scragg0x)
 * General tidy up of comments and files/folders

--- a/HOWITWORKS.md
+++ b/HOWITWORKS.md
@ -14,9 +14,9 @@ What happens when you call `Resque::enqueue()`?
 4. `Resque_Job::create()` pushes the job to the requested queue (first
   argument)
 5. `Resque_Job::create()`, if status monitoring is enabled for the job (fourth
-   argument), calls `Resque_Job_Status::create()` with the job ID as its only
+   argument), calls `\Resque\Job\Status::create()` with the job ID as its only
   argument
-6. `Resque_Job_Status::create()` creates a key in Redis with the job ID in its
+6. `\Resque\Job\Status::create()` creates a key in Redis with the job ID in its
   name, and the current status (as well as a couple of timestamps) as its
   value, then returns control to `Resque_Job::create()`
 7. `Resque_Job::create()` returns control to `Resque::enqueue()`, with the job
@ -85,15 +85,15 @@ How do the workers process the queues?
      * Worker
        1. The worker waits for the job process to complete
        2. If the exit status is not 0, the worker calls `Resque_Job->fail()` with
-           a `Resque_Job_DirtyExitException` as its only argument.
+           a `Resque\Job\DirtyExitException` as its only argument.
        3. `Resque_Job->fail()` triggers an `onFailure` event
        4. `Resque_Job->fail()` updates the job status from `RUNNING` to `FAILED`
        5. `Resque_Job->fail()` calls `Resque_Failure::create()` with the job
-           payload, the `Resque_Job_DirtyExitException`, the internal ID of the
+           payload, the `Resque\Job\DirtyExitException`, the internal ID of the
           worker, and the queue name as arguments
        6. `Resque_Failure::create()` creates a new object of whatever type has
           been set as the `Resque_Failure` "backend" handler; by default, this is
-           a `Resque_Failure_Redis` object, whose constructor simply collects the
+           a `ResqueFailureRedis` object, whose constructor simply collects the
           data passed into `Resque_Failure::create()` and pushes it into Redis
           in the `failed` queue
        7. `Resque_Job->fail()` increments two failure counters in Redis: one for
--- a/README.md
+++ b/README.md
@ -1,4 +1,4 @@
-php-resque: PHP Resque Worker (and Enqueue)  [![Build Status](https://travis-ci.org/iDanoo/php-resque.svg?branch=master)](https://travis-ci.org/iDanoo/php-resque)
+php-resque: PHP Background (Resque) Worker
 ===========================================

 Resque is a Redis-backed library for creating background jobs, placing
@ -34,9 +34,15 @@ not exit with a status code as 0
 * Has built in support for `setUp` and `tearDown` methods, called
 pre and post jobs

+On top of the original fork (chrisboulton/php-resque) I have added:
+
+* Custom log levels
+* PHP7.0+ compatibility
+
+
 ## Requirements ##

-* PHP 7.0+ (May work with 5.6+, Untested)
+* PHP 8.1+
 * phpredis
 * Redis 2.2+

@ -47,19 +53,9 @@ Composer package inside your project.

 If you're not familiar with Composer, please see <http://getcomposer.org/>.

-1. Add php-resque to your application's composer.json.
+1. Run `composer require idanoo/php-resque`.

-```json
-{
-    "require": {
-        "idanoo/php-resque": "^1.4"
-    }
-}
-```
-
-2. Run `composer install`.
-
-3. If you haven't already, add the Composer autoload to your project's
+2. If you haven't already, add the Composer autoload to your project's
   initialization file. (example)

 ```sh
@ -74,11 +70,11 @@ Jobs are queued as follows:

 ```php
 // Required if redis is located elsewhere
-Resque::setBackend('localhost:6379');
+Resque::setBackend('redis:6379');

 $args = ['name' => 'TestName'];

-Resque::enqueue('default', 'My_Job', $args);
+Resque::enqueue('default', '\App\MyJobClass', $args);
 ```

 ### Defining Jobs ###
@ -86,7 +82,9 @@ Resque::enqueue('default', 'My_Job', $args);
 Each job should be in its own class, and include a `perform` method.

 ```php
-class My_Job
+namespace \App;
+
+class MyJobClass
 {
    public function perform()
    {
@ -109,7 +107,9 @@ The `tearDown` method, if defined, will be called after the job finishes.


 ```php
-class My_Job
+namespace App;
+
+class MyJobClass
 {
    public function setUp()
    {
@ -133,17 +133,17 @@ class My_Job
 This method can be used to conveniently remove a job from a queue.

 ```php
-// Removes job class 'My_Job' of queue 'default'
-Resque::dequeue('default', ['My_Job']);
+// Removes job class '\App\MyJobClass' of queue 'default'
+Resque::dequeue('default', ['\App\MyJobClass']);

-// Removes job class 'My_Job' with Job ID '087df5819a790ac666c9608e2234b21e' of queue 'default'
-Resque::dequeue('default', ['My_Job' => '087df5819a790ac666c9608e2234b21e']);
+// Removes job class '\App\MyJobClass' with Job ID '087df5819a790ac666c9608e2234b21e' of queue 'default'
+Resque::dequeue('default', ['\App\MyJobClass' => '087df5819a790ac666c9608e2234b21e']);

-// Removes job class 'My_Job' with arguments of queue 'default'
-Resque::dequeue('default', ['My_Job' => ['foo' => 1, 'bar' => 2]]);
+// Removes job class '\App\MyJobClass' with arguments of queue 'default'
+Resque::dequeue('default', ['\App\MyJobClass' => ['foo' => 1, 'bar' => 2]]);

 // Removes multiple jobs
-Resque::dequeue('default', ['My_Job', 'My_Job2']);
+Resque::dequeue('default', ['\App\MyJobClass', '\App\MyJobClass2']);
 ```

 If no jobs are given, this method will dequeue all jobs matching the provided queue.
@ -164,7 +164,7 @@ To track the status of a job, pass `true` as the fourth argument to
 returned:

 ```php
-$token = Resque::enqueue('default', 'My_Job', $args, true);
+$token = Resque::enqueue('default', '\App\MyJobClass', $args, true);
 echo $token;
 ```

@ -361,8 +361,6 @@ your `APP_INCLUDE` script should initialize and register any listeners required
 for operation. If you have rolled your own worker manager, then it is again your
 responsibility to register listeners.

-A sample plugin is included in the `extras` directory.
-
 ### Events ###

 #### beforeFirstFork ####
@ -464,7 +462,7 @@ needing to directly examine the code), have a look at `HOWITWORKS.md`.
 ## Contributors ##

 ### Current Maintainers ###
-* @iDanoo
+* @idanoo

 ### Past Maintainer / Forked From ###

--- a/bin/resque
+++ b/bin/resque
@ -9,7 +9,6 @@ $files = [
    __DIR__ . '/../vendor/autoload.php',
 ];

-$found = false;
 foreach ($files as $file) {
    if (file_exists($file)) {
        require_once $file;
@ -25,6 +24,7 @@ if (!class_exists('Composer\Autoload\ClassLoader', false)) {
    );
 }

+// Set which queues to monitor '*'
 $QUEUE = getenv('QUEUE');
 if (empty($QUEUE)) {
    die("Set QUEUE env var containing the list of queues to work.\n");
@ -38,22 +38,26 @@ if (empty($QUEUE)) {
 */
 $REDIS_BACKEND = getenv('REDIS_BACKEND');

-// A redis database number
+/**
+ * REDIS_BACKEND_DB overrides default Redis DB
+ */
 $REDIS_BACKEND_DB = getenv('REDIS_BACKEND_DB');
 if (!empty($REDIS_BACKEND)) {
    if (empty($REDIS_BACKEND_DB)) {
-        Resque::setBackend($REDIS_BACKEND);
+        \Resque\Resque::setBackend($REDIS_BACKEND);
    } else {
-        Resque::setBackend($REDIS_BACKEND, $REDIS_BACKEND_DB);
+        \Resque\Resque::setBackend($REDIS_BACKEND, $REDIS_BACKEND_DB);
    }
 }

+// Set Logging level
 $logLevel = false;
 $LOGGING = getenv('LOGLEVEL');
 if (!empty($LOGGING)) {
    $logLevel = $LOGGING;
 }

+// Bootstrap file
 $APP_INCLUDE = getenv('APP_INCLUDE');
 if ($APP_INCLUDE) {
    if (!file_exists($APP_INCLUDE)) {
@ -66,41 +70,45 @@ if ($APP_INCLUDE) {
 // See if the APP_INCLUDE containes a logger object,
 // If none exists, fallback to internal logger
 if (!isset($logger) || !is_object($logger)) {
-    $logger = new Resque_Log($logLevel);
+    $logger = new \Resque\Log($logLevel);
 }

+// Determines if blocking or not
 $BLOCKING = getenv('BLOCKING') !== FALSE;

+// Interval to check for jobs
 $interval = 5;
 $INTERVAL = getenv('INTERVAL');
 if (!empty($INTERVAL)) {
    $interval = $INTERVAL;
 }

+// Sets worker count
 $count = 1;
 $COUNT = getenv('COUNT');
 if (!empty($COUNT) && $COUNT > 1) {
    $count = $COUNT;
 }

+// Determines redis key prefix
 $PREFIX = getenv('PREFIX');
 if (!empty($PREFIX)) {
-    $logger->log(Psr\Log\LogLevel::INFO, 'Prefix set to {prefix}', ['prefix' => $PREFIX]);
-    Resque_Redis::prefix($PREFIX);
+    $logger->log(\Psr\Log\LogLevel::INFO, 'Prefix set to {prefix}', ['prefix' => $PREFIX]);
+    \Resque\Redis::prefix($PREFIX);
 }

 if ($count > 1) {
    for ($i = 0; $i < $count; ++$i) {
-        $pid = Resque::fork();
+        $pid = \Resque\Resque::fork();
        if ($pid === false || $pid === -1) {
-            $logger->log(Psr\Log\LogLevel::EMERGENCY, 'Could not fork worker {count}', ['count' => $i]);
+            $logger->log(\Psr\Log\LogLevel::EMERGENCY, 'Could not fork worker {count}', ['count' => $i]);
            die();
        } elseif (!$pid) {
            // Child, start the worker
            $queues = explode(',', $QUEUE);
-            $worker = new Resque_Worker($queues);
+            $worker = new \Resque\Worker($queues);
            $worker->setLogger($logger);
-            $logger->log(Psr\Log\LogLevel::NOTICE, 'Starting worker {worker}', ['worker' => $worker]);
+            $logger->log(\Psr\Log\LogLevel::NOTICE, 'Starting worker {worker}', ['worker' => $worker]);
            $worker->work($interval, $BLOCKING);
            break;
        }
@ -108,7 +116,7 @@ if ($count > 1) {
 } else {
    // Start a single worker
    $queues = explode(',', $QUEUE);
-    $worker = new Resque_Worker($queues);
+    $worker = new \Resque\Worker($queues);
    $worker->setLogger($logger);

    $PIDFILE = getenv('PIDFILE');
@ -117,6 +125,6 @@ if ($count > 1) {
        die('Could not write PID information to ' . $PIDFILE);
    }

-    $logger->log(Psr\Log\LogLevel::NOTICE, 'Starting worker {worker}', ['worker' => $worker]);
+    $logger->log(\Psr\Log\LogLevel::NOTICE, 'Starting worker {worker}', ['worker' => $worker]);
    $worker->work($interval, $BLOCKING);
 }
--- a/build.xml
+++ b/build.xml
@ -1,18 +0,0 @@
-<!--suppress PhingDomInspection -->
-<project name="php-resque" default="build">
-	<target name="clean">
-		<delete dir="${basedir}/build" />
-	</target>
-	<target name="prepare">
-		<mkdir dir="${basedir}/build" />
-		<mkdir dir="${basedir}/build/logs" />
-	</target>
-	<target name="phpunit">
-		<exec dir="${basedir}" executable="phpunit">
-			<arg line="--log-junit         ${basedir}/build/logs/phpunit.xml
-				--coverage-clover ${basedir}/build/logs/clover.xml
-				--coverage-html   ${basedir}/build/coverage" />
-		</exec>
-	</target>
-	<target name="build" depends="clean,prepare,phpunit" />
-</project>
--- a/composer.json
+++ b/composer.json
@ -1,10 +1,13 @@
 {
 	"name": "idanoo/php-resque",
-	"version": "1.4.3",
 	"type": "library",
+	"replace": {
+		"chrisboulton/php-resque":  "*",
+		"danhunsaker/php-resque": "*"
+	},
 	"description": "Redis backed library for creating background jobs and processing them later. Based on resque for Ruby. Originally forked from chrisboulton/php-resque.",
-	"keywords": ["job", "background", "redis", "resque"],
-	"homepage": "http://www.github.com/idanoo/php-resque/",
+	"keywords": ["job", "background", "redis", "resque", "php"],
+	"homepage": "https://github.com/idanoo/php-resque",
 	"license": "MIT",
 	"authors": [
 		{
@ -13,25 +16,36 @@
 		}
 	],
 	"require": {
-		"php": "^7.0",
-		"ext-pcntl": "*",
-		"ext-redis": "*",
-		"psr/log": "~1.0",
-		"colinmollenhour/credis": "^1.10"
+		"php": ">=8.1",
+		"psr/log": "^1.1 || ^2.0 || ^3.0",
+		"colinmollenhour/credis": "^1.14.0"
 	},
 	"require-dev": {
-		"phpunit/phpunit": "^6"
+		"phpunit/phpunit": "^9",
+		"squizlabs/php_codesniffer": "3.*",
+		"phpcompatibility/php-compatibility": "^9.3",
+		"dealerdirect/phpcodesniffer-composer-installer": "^1.0"
 	},
 	"bin": [
 		"bin/resque"
 	],
 	"autoload": {
-		"psr-0": {
-			"Resque": "lib"
+		"psr-4": {
+			"Resque\\": "src/Resque"
+		}
+	},
+	"autoload-dev": {
+		"psr-4": {
+			"Resque\\Test\\": "tests/Resque/Tests"
 		}
 	},
 	"support": {
 		"issues": "https://github.com/idanoo/php-resque/issues",
 		"source": "https://github.com/idanoo/php-resque"
+	},
+	"config": {
+		"allow-plugins": {
+			"dealerdirect/phpcodesniffer-composer-installer": true
+		}
 	}
 }
--- a/composer.lock
+++ b/composer.lock
--- a/demo/bad_job.php
+++ b/demo/bad_job.php
@ -1,8 +0,0 @@
-<?php
-class Bad_PHP_Job
-{
-	public function perform()
-	{
-		throw new Exception('Unable to run this job!');
-	}
-}
--- a/demo/php_error_job.php
+++ b/demo/php_error_job.php
@ -1,9 +0,0 @@
-<?php /** @noinspection PhpUndefinedFunctionInspection */
-
-class PHP_Error_Job
-{
-    public function perform()
-    {
-        callToUndefinedFunction();
-    }
-}
--- a/demo/resque.php
+++ b/demo/resque.php
@ -1,7 +0,0 @@
-<?php
-date_default_timezone_set('GMT');
-require 'bad_job.php';
-require 'job.php';
-require 'php_error_job.php';
-
-require '../bin/resque';
--- a/examples/BadPHPJob.php
+++ b/examples/BadPHPJob.php
@ -0,0 +1,11 @@
+<?php
+
+namespace Resque\Example;
+
+class BadPHPJob
+{
+    public function perform()
+    {
+        throw new \Exception('Unable to run this job!');
+    }
+}
--- a/examples/CheckStatus.php
+++ b/examples/CheckStatus.php
@ -1,4 +1,7 @@
 <?php
+
+namespace Resque\Example;
+
 if (empty($argv[1])) {
    die('Specify the ID of a job to monitor the status of.');
 }
@ -6,12 +9,12 @@ if (empty($argv[1])) {
 require __DIR__ . '/init.php';

 date_default_timezone_set('GMT');
-Resque::setBackend('127.0.0.1:6379');
+\Resque\Resque::setBackend('127.0.0.1:6379');
 // You can also use a DSN-style format:
 //Resque::setBackend('redis://user:pass@127.0.0.1:6379');
 //Resque::setBackend('redis://user:pass@a.host.name:3432/2');

-$status = new Resque_Job_Status($argv[1]);
+$status = new \Resque\Job\Status($argv[1]);
 if (!$status->isTracking()) {
    die("Resque is not tracking the status of this job.\n");
 }
@ -20,4 +23,4 @@ echo "Tracking status of " . $argv[1] . ". Press [break] to stop.\n\n";
 while (true) {
    fwrite(STDOUT, "Status of " . $argv[1] . " is: " . $status->get() . "\n");
    sleep(1);
-}
+}
--- a/examples/Init.php
+++ b/examples/Init.php
@ -1,4 +1,7 @@
 <?php
+
+namespace Resque\Example;
+
 // Find and initialize Composer
 // NOTE: You should NOT use this when developing against php-resque.
 // The autoload code below is specifically for this demo.
@ -8,7 +11,6 @@ $files = [
    __DIR__ . '/../vendor/autoload.php',
 ];

-$found = false;
 foreach ($files as $file) {
    if (file_exists($file)) {
        require_once $file;
@ -22,4 +24,4 @@ if (!class_exists('Composer\Autoload\ClassLoader', false)) {
        'curl -s http://getcomposer.org/installer | php' . PHP_EOL .
        'php composer.phar install' . PHP_EOL
    );
-}
+}
--- a/examples/LongPHPJob.php
+++ b/examples/LongPHPJob.php
@ -1,9 +1,11 @@
 <?php

-class Long_PHP_Job
+namespace Resque\Example;
+
+class LongPHPJob
 {
    public function perform()
    {
        sleep(600);
    }
-}
+}
--- a/examples/PHPErrorJob.php
+++ b/examples/PHPErrorJob.php
@ -0,0 +1,13 @@
+<?php
+
+/** @noinspection PhpUndefinedFunctionInspection */
+
+namespace Resque\Example;
+
+class PHPErrorJob
+{
+    public function perform()
+    {
+        callToUndefinedFunction();
+    }
+}
--- a/examples/PHPJob.php
+++ b/examples/PHPJob.php
@ -1,6 +1,8 @@
 <?php

-class PHP_Job
+namespace Resque\Example;
+
+class PHPJob
 {
    public function perform()
    {
@ -8,4 +10,4 @@ class PHP_Job
        sleep(1);
        fwrite(STDOUT, 'Job ended!' . PHP_EOL);
    }
-}
+}
--- a/examples/SampleResquePlugin.php
+++ b/examples/SampleResquePlugin.php
@ -1,14 +1,17 @@
 <?php
-// Somewhere in our application, we need to register:
-Resque_Event::listen('afterEnqueue', ['My_Resque_Plugin', 'afterEnqueue']);
-Resque_Event::listen('beforeFirstFork', ['My_Resque_Plugin', 'beforeFirstFork']);
-Resque_Event::listen('beforeFork', ['My_Resque_Plugin', 'beforeFork']);
-Resque_Event::listen('afterFork', ['My_Resque_Plugin', 'afterFork']);
-Resque_Event::listen('beforePerform', ['My_Resque_Plugin', 'beforePerform']);
-Resque_Event::listen('afterPerform', ['My_Resque_Plugin', 'afterPerform']);
-Resque_Event::listen('onFailure', ['My_Resque_Plugin', 'onFailure']);

-class Sample_Resque_Plugin
+namespace Resque\Example;
+
+// Somewhere in our application, we need to register:
+// \Resque\Event::listen('afterEnqueue', ['My_Resque_Plugin', 'afterEnqueue']);
+// \Resque\Event::listen('beforeFirstFork', ['My_Resque_Plugin', 'beforeFirstFork']);
+// \Resque\Event::listen('beforeFork', ['My_Resque_Plugin', 'beforeFork']);
+// \Resque\Event::listen('afterFork', ['My_Resque_Plugin', 'afterFork']);
+// \Resque\Event::listen('beforePerform', ['My_Resque_Plugin', 'beforePerform']);
+// \Resque\Event::listen('afterPerform', ['My_Resque_Plugin', 'afterPerform']);
+// \Resque\Event::listen('onFailure', ['My_Resque_Plugin', 'onFailure']);
+
+class SampleResquePlugin
 {
    public static function afterEnqueue($class, $arguments)
    {
@ -34,7 +37,7 @@ class Sample_Resque_Plugin
    public static function beforePerform($job)
    {
        echo "Cancelling " . $job . "\n";
-        //	throw new Resque_Job_DontPerform;
+        // throw new Resque_Job_DontPerform;
    }

    public static function afterPerform($job)
@ -46,4 +49,4 @@ class Sample_Resque_Plugin
    {
        echo $job . " threw an exception:\n" . $exception;
    }
-}
+}
--- a/examples/queue.php
+++ b/examples/queue.php
@ -1,11 +1,14 @@
 <?php
+
+namespace Resque\Example;
+
 if (empty($argv[1])) {
-    die('Specify the name of a job to add. e.g, php queue.php PHP_Job');
+    die('Specify the name of a job to add. e.g, php queue.php PHPJob');
 }

 require __DIR__ . '/init.php';
 date_default_timezone_set('GMT');
-Resque::setBackend('127.0.0.1:6379');
+\Resque\Resque::setBackend('127.0.0.1:6379');

 // You can also use a DSN-style format:
 //Resque::setBackend('redis://user:pass@127.0.0.1:6379');
@ -18,9 +21,9 @@ $args = [
    ],
 ];
 if (empty($argv[2])) {
-    $jobId = Resque::enqueue('default', $argv[1], $args, true);
+    $jobId = \Resque\Resque::enqueue('default', $argv[1], $args, true);
 } else {
-    $jobId = Resque::enqueue($argv[1], $argv[2], $args, true);
+    $jobId = \Resque\Resque::enqueue($argv[1], $argv[2], $args, true);
 }

 echo "Queued job " . $jobId . "\n\n";
--- a/examples/resque.logrotate
+++ b/examples/resque.logrotate
@ -5,6 +5,6 @@
        compress
        compressoptions -4
        notifempty
-        create 640 root adm
+        create 640 root www-data
        copytruncate
 }
--- a/extras/resque.monit
+++ b/extras/resque.monit
@ -1,15 +0,0 @@
-# Borrowed with modifications from
-#    https://github.com/defunkt/resque/blob/master/examples/monit/resque.monit
-# Replace these with your own:
-# [QUEUE]
-# [PATH/TO/RESQUE]
-# [UID]
-# [GID]
-# [APP_INCLUDE]
-
-check process resque_worker_[QUEUE]
-  with pidfile /var/run/resque/worker_[QUEUE].pid
-  start program = "/bin/sh -c 'APP_INCLUDE=[APP_INCLUDE] QUEUE=[QUEUE] VERBOSE=1 PIDFILE=/var/run/resque/worker_[QUEUE].pid nohup php -f [PATH/TO/RESQUE]/bin/resque > /var/log/resque/worker_[QUEUE].log &'" as uid [UID] and gid [GID]
-  stop program = "/bin/sh -c 'kill -s QUIT `cat /var/run/resque/worker_[QUEUE].pid` && rm -f /var/run/resque/worker_[QUEUE].pid; exit 0;'"
-  if totalmem is greater than 300 MB for 10 cycles then restart  # eating up memory?
-  group resque_workers
--- a/lib/Resque/Job/Factory.php
+++ b/lib/Resque/Job/Factory.php
@ -1,32 +0,0 @@
-<?php
-
-class Resque_Job_Factory implements Resque_Job_FactoryInterface
-{
-
-    /**
-     * @param $className
-     * @param array $args
-     * @param $queue
-     * @return Resque_JobInterface
-     * @throws \Resque_Exception
-     */
-    public function create($className, $args, $queue)
-    {
-        if (!class_exists($className)) {
-            throw new Resque_Exception(
-                'Could not find job class ' . $className . '.'
-            );
-        }
-
-        if (!method_exists($className, 'perform')) {
-            throw new Resque_Exception(
-                'Job class ' . $className . ' does not contain a perform method.'
-            );
-        }
-
-        $instance = new $className;
-        $instance->args = $args;
-        $instance->queue = $queue;
-        return $instance;
-    }
-}
--- a/lib/Resque/Job/FactoryInterface.php
+++ b/lib/Resque/Job/FactoryInterface.php
@ -1,12 +0,0 @@
-<?php
-
-interface Resque_Job_FactoryInterface
-{
-    /**
-     * @param $className
-     * @param array $args
-     * @param $queue
-     * @return Resque_JobInterface
-     */
-    public function create($className, $args, $queue);
-}
--- a/lib/Resque/RedisException.php
+++ b/lib/Resque/RedisException.php
@ -1,14 +0,0 @@
-<?php
-
-/**
- * Redis related exceptions
- *
- * @package        Resque
- * @author        Chris Boulton <chris@bigcommerce.com>
- * @license        http://www.opensource.org/licenses/mit-license.php
- */
-
-class Resque_RedisException extends Resque_Exception
-{
-
-}
--- a/phpunit.xml.dist
+++ b/phpunit.xml.dist
@ -1,24 +1,17 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <phpunit backupGlobals="false"
-	bootstrap="test/bootstrap.php"
+	bootstrap="tests/bootstrap.php"
 	backupStaticAttributes="false"
 	colors="true"
 	convertErrorsToExceptions="true"
 	convertNoticesToExceptions="true"
 	convertWarningsToExceptions="true"
-	processIsolation="false"
+	processIsolation="true"
 	stopOnFailure="false"
-	syntaxCheck="false"
 >
 	<testsuites>
 		<testsuite name="Resque Test Suite">
-			<directory>./test/Resque/</directory>
+			<directory>./tests/Resque/</directory>
 		</testsuite>
 	</testsuites>
-
-	<filter>
-		<whitelist>
-			<directory suffix=".php">./lib/Resque/</directory>
-		</whitelist>
-	</filter>
 </phpunit>
--- a/ruleset.xml
+++ b/ruleset.xml
@ -0,0 +1,29 @@
+<?xml version="1.0"?>
+<ruleset name="PHP82" namespace="ezyVet\PHPCS">
+    <description>PHP8.2 Ruleset</description>
+
+    <file>.</file>
+    <exclude-pattern>vendor</exclude-pattern>
+    <exclude-pattern>tests/</exclude-pattern>
+
+    <arg name="extensions" value="php" />
+    <arg name="colors"/>
+    <arg value="sp"/>
+    <arg name="parallel" value="16"/>
+    <arg name="report-width" value="140" />
+    <arg name="error-severity" value="1" />
+    <!-- Setting warning-severity here overrides both the '-n' CLI option and 'config-set show_warnings 0', so we
+         can't use it. -->
+
+    <ini name="memory_limit" value="256M"/>
+
+    <!-- Check for version support for PHP 8.2 and higher. -->
+    <config name="testVersion" value="8.2-"/>
+
+
+    <rule ref="PSR12">
+    </rule>
+
+    <rule ref="PHPCompatibility">
+    </rule>
+</ruleset>
--- a/src/Resque/Event.php
+++ b/src/Resque/Event.php
@ -1,14 +1,16 @@
 <?php

+namespace Resque;
+
 /**
 * Resque event/plugin system class
 *
 * @package        Resque/Event
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */

-class Resque_Event
+class Event
 {
    /**
     * @var array Array containing all registered callbacks, indexked by event name.
@ -20,6 +22,7 @@ class Resque_Event
     *
     * @param string $event Name of event to be raised.
     * @param mixed $data Optional, any data that should be passed to each callback.
+     *
     * @return true
     */
    public static function trigger($event, $data = null)
@ -36,7 +39,8 @@ class Resque_Event
            if (!is_callable($callback)) {
                continue;
            }
-            call_user_func_array($callback, $data);
+
+            call_user_func_array($callback, array_values($data));
        }

        return true;
@ -46,7 +50,8 @@ class Resque_Event
     * Listen in on a given event to have a specified callback fired.
     *
     * @param string $event Name of event to listen on.
-     * @param mixed $callback Any callback callable by call_user_func_array.
+     * @param mixed $callback Any callback callable by call_user_func_array
+     *
     * @return true
     */
    public static function listen($event, $callback)
@ -64,6 +69,7 @@ class Resque_Event
     *
     * @param string $event Name of event.
     * @param mixed $callback The callback as defined when listen() was called.
+     *
     * @return true
     */
    public static function stopListening($event, $callback)
@ -82,8 +88,10 @@ class Resque_Event

    /**
     * Call all registered listeners.
+     *
+     * @return void
     */
-    public static function clearListeners()
+    public static function clearListeners(): void
    {
        self::$events = [];
    }
--- a/src/Resque/Exception.php
+++ b/src/Resque/Exception.php
@ -1,13 +1,15 @@
 <?php

+namespace Resque;
+
 /**
 * Resque exception.
 *
 * @package        Resque
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */

-class Resque_Exception extends Exception
+class Exception extends \Exception
 {
 }
--- a/src/Resque/Failure/Failure.php
+++ b/src/Resque/Failure/Failure.php
@ -1,14 +1,16 @@
 <?php

+namespace Resque\Failure;
+
 /**
 * Failed Resque job.
 *
 * @package        Resque/Failure
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */

-class Resque_Failure
+class Failure
 {
    /**
     * @var string Class name representing the backend to pass failed jobs off to.
@ -20,11 +22,15 @@ class Resque_Failure
     *
     * @param array $payload The contents of the job that has just failed.
     * @param \Exception $exception The exception generated when the job failed to run.
-     * @param \Resque_Worker $worker Instance of Resque_Worker that was running this job when it failed.
+     * @param \Resque\Worker $worker Instance of Resque_Worker that was running this job when it failed.
     * @param string $queue The name of the queue that this job was fetched from.
     */
-    public static function create($payload, Exception $exception, Resque_Worker $worker, $queue)
-    {
+    public static function create(
+        $payload,
+        \Exception $exception,
+        \Resque\Worker $worker,
+        $queue
+    ) {
        $backend = self::getBackend();
        new $backend($payload, $exception, $worker, $queue);
    }
@ -32,12 +38,12 @@ class Resque_Failure
    /**
     * Return an instance of the backend for saving job failures.
     *
-     * @return object|string
+     * @return string
     */
    public static function getBackend()
    {
-        if (self::$backend === null) {
-            self::$backend = 'Resque_Failure_Redis';
+        if (is_null(self::$backend)) {
+            self::$backend = '\\Resque\\Failure\\ResqueFailureRedis';
        }

        return self::$backend;
@ -49,9 +55,11 @@ class Resque_Failure
     * It is your responsibility to have the backend class loaded (or autoloaded)
     *
     * @param string $backend The class name of the backend to pipe failures to.
+     *
+     * @return void
     */
-    public static function setBackend($backend)
+    public static function setBackend(string $backend): void
    {
        self::$backend = $backend;
    }
-}
+}
--- a/src/Resque/Failure/ResqueFailureInterface.php
+++ b/src/Resque/Failure/ResqueFailureInterface.php
@ -1,13 +1,15 @@
 <?php

+namespace Resque\Failure;
+
 /**
 * Interface that all failure backends should implement.
 *
- * @package        Resque/Failure
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @package        Resque\Failure
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */
-interface Resque_Failure_Interface
+interface ResqueFailureInterface
 {
    /**
     * Initialize a failed job class and save it (where appropriate).
--- a/src/Resque/Failure/ResqueFailureRedis.php
+++ b/src/Resque/Failure/ResqueFailureRedis.php
@ -1,13 +1,16 @@
 <?php
+
+namespace Resque\Failure;
+
 /**
 * Redis backend for storing failed Resque jobs.
 *
- * @package        Resque/Failure
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @package        Resque\Failure
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */

-class Resque_Failure_Redis implements Resque_Failure_Interface
+class ResqueFailureRedis implements ResqueFailureInterface
 {
    /**
     * Initialize a failed job class and save it (where appropriate).
@ -16,12 +19,12 @@ class Resque_Failure_Redis implements Resque_Failure_Interface
     * @param object $exception Instance of the exception that was thrown by the failed job.
     * @param object $worker Instance of Resque_Worker that received the job.
     * @param string $queue The name of the queue the job was fetched from.
-     * @throws Resque_RedisException
+     * @throws \Resque\RedisException
     */
    public function __construct($payload, $exception, $worker, $queue)
    {
-        $data = new stdClass;
-        $data->failed_at = strftime('%a %b %d %H:%M:%S %Z %Y');
+        $data = new \stdClass();
+        $data->failed_at = date('D M d H:i:s T Y');
        $data->payload = $payload;
        $data->exception = get_class($exception);
        $data->error = $exception->getMessage();
@ -29,6 +32,6 @@ class Resque_Failure_Redis implements Resque_Failure_Interface
        $data->worker = (string)$worker;
        $data->queue = $queue;
        $data = json_encode($data);
-        Resque::redis()->rpush('failed', $data);
+        \Resque\Resque::redis()->rpush('failed', $data);
    }
 }
--- a/src/Resque/Job/DirtyExitException.php
+++ b/src/Resque/Job/DirtyExitException.php
@ -1,13 +1,14 @@
 <?php

+namespace Resque\Job;
+
 /**
 * Runtime exception class for a job that does not exit cleanly.
 *
 * @package        Resque/Job
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */
-class Resque_Job_DirtyExitException extends RuntimeException
+class DirtyExitException extends \RuntimeException
 {
-
 }
--- a/src/Resque/Job/DontCreate.php
+++ b/src/Resque/Job/DontCreate.php
@ -1,13 +1,14 @@
 <?php

+namespace Resque\Job;
+
 /**
 * Exception to be thrown if while enqueuing a job it should not be created.
 *
 * @package        Resque/Job
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */
-class Resque_Job_DontCreate extends Exception
+class DontCreate extends \Exception
 {
-
 }
--- a/src/Resque/Job/DontPerform.php
+++ b/src/Resque/Job/DontPerform.php
@ -1,14 +1,14 @@
 <?php

+namespace Resque\Job;
+
 /**
 * Exception to be thrown if a job should not be performed/run.
 *
 * @package        Resque/Job
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */
-
-class Resque_Job_DontPerform extends Exception
+class DontPerform extends \Exception
 {
-
 }
--- a/src/Resque/Job/Factory.php
+++ b/src/Resque/Job/Factory.php
@ -0,0 +1,50 @@
+<?php
+
+namespace Resque\Job;
+
+/**
+ * Job Factory!
+ *
+ * @package        Resque/Job
+ * @author         Daniel Mason <daniel@m2.nz>
+ * @license        http://www.opensource.org/licenses/mit-license.php
+ */
+
+class Factory implements FactoryInterface
+{
+    public ?Job $job;
+    public string $queue;
+    public array $args;
+
+    /**
+     * Create job factory
+     *
+     * @param $className
+     * @param array $args
+     * @param $queue
+     *
+     * @return \Resque\Job\JobInterface
+     *
+     * @throws \Resque\Exception
+     */
+    public function create($className, $args, $queue)
+    {
+        if (!class_exists($className)) {
+            throw new \Resque\Exception(
+                'Could not find job class ' . $className . '.'
+            );
+        }
+
+        if (!method_exists($className, 'perform')) {
+            throw new \Resque\Exception(
+                'Job class ' . $className . ' does not contain a perform() method.'
+            );
+        }
+
+        $instance = new $className();
+        $instance->args = $args;
+        $instance->queue = $queue;
+
+        return $instance;
+    }
+}
--- a/src/Resque/Job/FactoryInterface.php
+++ b/src/Resque/Job/FactoryInterface.php
@ -0,0 +1,22 @@
+<?php
+
+namespace Resque\Job;
+
+/**
+ * Job Interface
+ *
+ * @package        Resque/Job
+ * @author         Daniel Mason <daniel@m2.nz>
+ * @license        http://www.opensource.org/licenses/mit-license.php
+ */
+interface FactoryInterface
+{
+    /**
+     * @param $className
+     * @param array $args
+     * @param $queue
+     *
+     * @return \Resque\Job\JobInterface
+     */
+    public function create($className, $args, $queue);
+}
--- a/src/Resque/Job/Job.php
+++ b/src/Resque/Job/Job.php
@ -1,14 +1,16 @@
 <?php

+namespace Resque\Job;
+
 /**
 * Resque job.
 *
 * @package        Resque/Job
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */

-class Resque_Job
+class Job
 {
    /**
     * @var string The name of the queue that this job belongs to.
@ -16,7 +18,7 @@ class Resque_Job
    public $queue;

    /**
-     * @var Resque_Worker Instance of the Resque worker running this job.
+     * @var \Resque\Worker Instance of the Resque worker running this job.
     */
    public $worker;

@ -26,12 +28,12 @@ class Resque_Job
    public $payload;

    /**
-     * @var object|Resque_JobInterface Instance of the class performing work for this job.
+     * @var object|\Resque\Job\JobInterface Instance of the class performing work for this job.
     */
    private $instance;

    /**
-     * @var Resque_Job_FactoryInterface
+     * @var \Resque\Job\FactoryInterface
     */
    private $jobFactory;

@ -57,20 +59,21 @@ class Resque_Job
     * @param string $id Unique identifier for tracking the job. Generated if not supplied.
     *
     * @return string
+     *
     * @throws \InvalidArgumentException
     */
-    public static function create($queue, $class, $args = null, $monitor = false, $id = null)
+    public static function create($queue, $class, $args = null, $monitor = false, $id = null): string
    {
        if (is_null($id)) {
-            $id = Resque::generateJobId();
+            $id = \Resque\Resque::generateJobId();
        }

        if ($args !== null && !is_array($args)) {
-            throw new InvalidArgumentException(
+            throw new \InvalidArgumentException(
                'Supplied $args must be an array.'
            );
        }
-        Resque::push($queue, [
+        \Resque\Resque::push($queue, [
            'class' => $class,
            'args' => [$args],
            'id' => $id,
@ -78,7 +81,7 @@ class Resque_Job
        ]);

        if ($monitor) {
-            Resque_Job_Status::create($id);
+            Status::create($id);
        }

        return $id;
@ -86,43 +89,47 @@ class Resque_Job

    /**
     * Find the next available job from the specified queue and return an
-     * instance of Resque_Job for it.
+     * instance of \Resque\Job\Job for it.
     *
     * @param string $queue The name of the queue to check for a job in.
-     * @return false|object Null when there aren't any waiting jobs, instance of Resque_Job when a job was found.
+     *
+     * @return Job|null Null when there aren't any waiting jobs, instance of \Resque\Job\Job when a job was found.
     */
-    public static function reserve($queue)
+    public static function reserve($queue): ?Job
    {
-        $payload = Resque::pop($queue);
+        $payload = \Resque\Resque::pop($queue);
        if (!is_array($payload)) {
-            return false;
+            return null;
        }

-        return new Resque_Job($queue, $payload);
+        return new Job($queue, $payload);
    }

    /**
     * Find the next available job from the specified queues using blocking list pop
-     * and return an instance of Resque_Job for it.
+     * and return an instance of \Resque\Job\Job for it.
     *
     * @param array $queues
     * @param int $timeout
-     * @return false|object Null when there aren't any waiting jobs, instance of Resque_Job when a job was found.
+     *
+     * @return Job|null Null when there aren't any waiting jobs, instance of \Resque\Job\Job when a job was found.
     */
-    public static function reserveBlocking(array $queues, $timeout = null)
+    public static function reserveBlocking(array $queues, $timeout = null): ?Job
    {
-        $item = Resque::blpop($queues, $timeout);
+        $item = \Resque\Resque::blpop($queues, $timeout);
        if (!is_array($item)) {
-            return false;
+            return null;
        }

-        return new Resque_Job($item['queue'], $item['payload']);
+        return new Job($item['queue'], $item['payload']);
    }

    /**
     * Update the status of the current job.
     *
-     * @param int $status Status constant from Resque_Job_Status indicating the current status of a job.
+     * @param int $status Status constant from \Resque\Job\Status indicating the current status of a job.
+     *
+     * @return bool
     */
    public function updateStatus($status): bool
    {
@ -130,7 +137,7 @@ class Resque_Job
            return false;
        }

-        $statusInstance = new Resque_Job_Status($this->payload['id']);
+        $statusInstance = new Status($this->payload['id']);
        $statusInstance->update($status);
        return true;
    }
@ -138,11 +145,11 @@ class Resque_Job
    /**
     * Return the status of the current job.
     *
-     * @return int The status of the job as one of the Resque_Job_Status constants.
+     * @return int The status of the job as one of the \Resque\Job\Status constants.
     */
    public function getStatus()
    {
-        $status = new Resque_Job_Status($this->payload['id']);
+        $status = new Status($this->payload['id']);
        return $status->get();
    }

@ -162,11 +169,12 @@ class Resque_Job

    /**
     * Get the instantiated object for this job that will be performing work.
-     * @return Resque_JobInterface Instance of the object that this job belongs to.
+     *
+     * @return \Resque\Job\JobInterface Instance of the object that this job belongs to.
     */
    public function getInstance()
    {
-        if (!is_null($this->instance)) {
+        if (isset($this->instance) && !is_null($this->instance)) {
            return $this->instance;
        }

@ -180,12 +188,13 @@ class Resque_Job
     * associated with the job with the supplied arguments.
     *
     * @return bool
-     * @throws Resque_Exception When the job's class could not be found or it does not contain a perform method.
+     *
+     * @throws \Resque\Exception When the job's class could not be found or it does not contain a perform method.
     */
    public function perform()
    {
        try {
-            Resque_Event::trigger('beforePerform', $this);
+            \Resque\Event::trigger('beforePerform', $this);

            $instance = $this->getInstance();
            if (method_exists($instance, 'setUp')) {
@ -198,9 +207,9 @@ class Resque_Job
                $instance->tearDown();
            }

-            Resque_Event::trigger('afterPerform', $this);
-        } // beforePerform/setUp have said don't perform this job. Return.
-            /** @noinspection PhpRedundantCatchClauseInspection */ catch (Resque_Job_DontPerform $e) {
+            \Resque\Event::trigger('afterPerform', $this);
+        } catch (DontPerform $e) {
+            /** @noinspection PhpRedundantCatchClauseInspection */
            return false;
        }

@ -214,29 +223,30 @@ class Resque_Job
     */
    public function fail($exception)
    {
-        Resque_Event::trigger('onFailure', [
+        \Resque\Event::trigger('onFailure', [
            'exception' => $exception,
            'job' => $this,
        ]);

-        $this->updateStatus(Resque_Job_Status::STATUS_FAILED);
-        Resque_Failure::create(
+        $this->updateStatus(Status::STATUS_FAILED);
+        \Resque\Failure\Failure::create(
            $this->payload,
            $exception,
            $this->worker,
            $this->queue
        );
-        Resque_Stat::incr('failed');
-        Resque_Stat::incr('failed:' . $this->worker);
+        \Resque\Stat::incr('failed');
+        \Resque\Stat::incr('failed:' . $this->worker);
    }

    /**
     * Re-queue the current job.
+     *
     * @return string
     */
    public function recreate()
    {
-        $status = new Resque_Job_Status($this->payload['id']);
+        $status = new Status($this->payload['id']);
        $monitor = false;
        if ($status->isTracking()) {
            $monitor = true;
@ -266,10 +276,11 @@ class Resque_Job
    }

    /**
-     * @param Resque_Job_FactoryInterface $jobFactory
-     * @return Resque_Job
+     * @param FactoryInterface $jobFactory
+     *
+     * @return Job
     */
-    public function setJobFactory(Resque_Job_FactoryInterface $jobFactory)
+    public function setJobFactory(FactoryInterface $jobFactory)
    {
        $this->jobFactory = $jobFactory;

@ -277,13 +288,14 @@ class Resque_Job
    }

    /**
-     * @return Resque_Job_FactoryInterface
+     * @return FactoryInterface
     */
    public function getJobFactory()
    {
-        if ($this->jobFactory === null) {
-            $this->jobFactory = new Resque_Job_Factory();
+        if (is_null($this->jobFactory)) {
+            $this->jobFactory = new Factory();
        }
+
        return $this->jobFactory;
    }
 }
--- a/src/Resque/Job/JobInterface.php
+++ b/src/Resque/Job/JobInterface.php
@ -1,6 +1,8 @@
 <?php

-interface Resque_JobInterface
+namespace Resque\Job;
+
+interface JobInterface
 {
    /**
     * @return bool
--- a/src/Resque/Job/Status.php
+++ b/src/Resque/Job/Status.php
@ -1,19 +1,21 @@
 <?php

+namespace Resque\Job;
+
 /**
 * Status tracker/information for a job.
 *
 * @package        Resque/Job
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */

-class Resque_Job_Status
+class Status
 {
-    const STATUS_WAITING = 1;
-    const STATUS_RUNNING = 2;
-    const STATUS_FAILED = 3;
-    const STATUS_COMPLETE = 4;
+    public const STATUS_WAITING = 1;
+    public const STATUS_RUNNING = 2;
+    public const STATUS_FAILED = 3;
+    public const STATUS_COMPLETE = 4;

    /**
     * @var string The ID of the job this status class refers back to.
@ -57,7 +59,11 @@ class Resque_Job_Status
            'updated' => time(),
            'started' => time(),
        ];
-        Resque::redis()->set('job:' . $id . ':status', json_encode($statusPacket));
+        \Resque\Resque::redis()->set(
+            'job:' . $id . ':status',
+            json_encode($statusPacket),
+            ['ex' => \Resque\Redis::DEFAULT_REDIS_TTL],
+        );
    }

    /**
@ -72,7 +78,7 @@ class Resque_Job_Status
            return false;
        }

-        if (!Resque::redis()->exists((string)$this)) {
+        if (!\Resque\Resque::redis()->exists((string)$this)) {
            $this->isTracking = false;
            return false;
        }
@ -84,7 +90,7 @@ class Resque_Job_Status
    /**
     * Update the status indicator for the current job with a new status.
     *
-     * @param int The status of the job (see constants in Resque_Job_Status)
+     * @param int The status of the job (see constants in \Resque\Job\Status)
     */
    public function update($status)
    {
@ -96,19 +102,19 @@ class Resque_Job_Status
            'status' => $status,
            'updated' => time(),
        ];
-        Resque::redis()->set((string)$this, json_encode($statusPacket));

-        // Expire the status for completed jobs after 24 hours
-        if (in_array($status, self::$completeStatuses)) {
-            Resque::redis()->expire((string)$this, 86400);
-        }
+        \Resque\Resque::redis()->set(
+            (string)$this,
+            json_encode($statusPacket),
+            ['ex' => \Resque\Redis::DEFAULT_REDIS_TTL],
+        );
    }

    /**
     * Fetch the status for the job being monitored.
     *
     * @return mixed False if the status is not being monitored, otherwise the status as
-     *    as an integer, based on the Resque_Job_Status constants.
+     *    as an integer, based on the \Resque\Job\Status constants.
     */
    public function get()
    {
@ -116,7 +122,7 @@ class Resque_Job_Status
            return false;
        }

-        $statusPacket = json_decode(Resque::redis()->get((string)$this), true);
+        $statusPacket = json_decode(\Resque\Resque::redis()->get((string)$this), true);
        if (!$statusPacket) {
            return false;
        }
@ -126,10 +132,12 @@ class Resque_Job_Status

    /**
     * Stop tracking the status of a job.
+     *
+     * @return void
     */
-    public function stop()
+    public function stop(): void
    {
-        Resque::redis()->del((string)$this);
+        \Resque\Resque::redis()->del((string)$this);
    }

    /**
--- a/src/Resque/Log.php
+++ b/src/Resque/Log.php
@ -1,18 +1,20 @@
 <?php

+namespace Resque;
+
 /**
 * Resque default logger PSR-3 compliant
 *
- * @package        Resque/Stat
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @package        Resque
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */

-class Resque_Log extends Psr\Log\AbstractLogger
+class Log extends \Psr\Log\AbstractLogger
 {
    public $logLevel;

-    public function __construct($logLevel = "warning")
+    public function __construct($logLevel = 'warning')
    {
        $this->logLevel = strtolower($logLevel);
    }
@ -23,21 +25,22 @@ class Resque_Log extends Psr\Log\AbstractLogger
     * @param mixed $level PSR-3 log level constant, or equivalent string
     * @param string $message Message to log, may contain a { placeholder }
     * @param array $context Variables to replace { placeholder }
+     *
     * @return null
     */
-    public function log($level, $message, array $context = [])
+    public function log($level, $message, array $context = []): void
    {
        $logLevels = [
-            "emergency", 
-            "alert", 
-            "critical", 
-            "error", 
-            "warning", 
-            "notice", 
-            "info", 
-            "debug"
+            'emergency',
+            'alert',
+            'critical',
+            'error',
+            'warning',
+            'notice',
+            'info',
+            'debug',
        ];
-        
+
        /**
         *  Only log things with a higher level than the current log level.
         *  e.g If set as 'alert' will only alert for 'emergency' and 'alert' logs.
@ -45,11 +48,11 @@ class Resque_Log extends Psr\Log\AbstractLogger
        if (array_search($level, $logLevels) <= array_search($this->logLevel, $logLevels)) {
            fwrite(
                STDOUT,
-                '[' . $level . '][' . strftime('%Y-%m-%d %T') . '] ' . $this->interpolate($message, $context) . PHP_EOL
+                '[' . $level . '][' . date('Y-m-d H:i:s') . '] ' .
+                    $this->interpolate($message, $context) . PHP_EOL
            );
        }
        return;
-
    }

    /**
--- a/src/Resque/Redis.php
+++ b/src/Resque/Redis.php
@ -1,23 +1,27 @@
 <?php

+namespace Resque;
+
 /**
 * Set up phpredis connection
 *
 * @package        Resque/Redis
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */

-class Resque_Redis
+class Redis
 {
    /**
     * Redis Client
-     * @var Credis_Client
+     *
+     * @var \Credis_Client
     */
    private $driver;

    /**
     * Redis namespace
+     *
     * @var string
     */
    private static $defaultNamespace = 'resque:';
@ -25,17 +29,22 @@ class Resque_Redis
    /**
     * A default host to connect to
     */
-    const DEFAULT_HOST = 'localhost';
+    public const DEFAULT_HOST = 'localhost';

    /**
     * The default Redis port
     */
-    const DEFAULT_PORT = 6379;
+    public const DEFAULT_PORT = 6379;

    /**
     * The default Redis Database number
     */
-    const DEFAULT_DATABASE = 0;
+    public const DEFAULT_DATABASE = 0;
+
+    /**
+     * Default Redis TTL (2 days)
+     */
+    public const DEFAULT_REDIS_TTL = 172800;

    /**
     * @var array List of all commands in Redis that supply a key as their
@ -88,27 +97,20 @@ class Resque_Redis
        'rename',
        'rpoplpush'
    ];
-    // sinterstore
-    // sunion
-    // sunionstore
-    // sdiff
-    // sdiffstore
-    // sinter
-    // smove
-    // mget
-    // msetnx
-    // mset
-    // renamenx

    /**
     * Set Redis namespace (prefix) default: resque
+     *
     * @param string $namespace
+     *
+     * @return void
     */
-    public static function prefix($namespace)
+    public static function prefix(string $namespace): void
    {
        if (substr($namespace, -1) !== ':' && $namespace != '') {
            $namespace .= ':';
        }
+
        self::$defaultNamespace = $namespace;
    }

@ -116,8 +118,9 @@ class Resque_Redis
     * @param string|array $server A DSN or array
     * @param int $database A database number to select. However, if we find a valid database number in the DSN the
     *                      DSN-supplied value will be used instead and this parameter is ignored.
-     * @param object $client Optional Credis_Client instance instantiated by you
-     * @throws Resque_RedisException
+     * @param object $client Optional \Credis_Client instance instantiated by you
+     *
+     * @throws \Resque\RedisException
     */
    public function __construct($server, $database = null, $client = null)
    {
@ -131,7 +134,7 @@ class Resque_Redis
                $timeout = isset($options['timeout']) ? intval($options['timeout']) : null;
                $persistent = isset($options['persistent']) ? $options['persistent'] : '';
                $maxRetries = isset($options['max_connect_retries']) ? $options['max_connect_retries'] : 0;
-                $this->driver = new Credis_Client($host, $port, $timeout, $persistent);
+                $this->driver = new \Credis_Client($host, $port, $timeout, $persistent);
                $this->driver->setMaxConnectRetries($maxRetries);
                if ($password) {
                    $this->driver->auth($password);
@ -145,8 +148,8 @@ class Resque_Redis
            if ($database !== null) {
                $this->driver->select($database);
            }
-        } catch (Exception $e) {
-            throw new Resque_RedisException('Error communicating with Redis: ' . $e->getMessage(), 0, $e);
+        } catch (\Exception $e) {
+            throw new RedisException('Error communicating with Redis: ' . $e->getMessage(), 0, $e);
        }
    }

@ -161,10 +164,11 @@ class Resque_Redis
     * Note: the 'user' part of the DSN is not used.
     *
     * @param string $dsn A DSN string
+     *
     * @return array An array of DSN compotnents, with 'false' values for any unknown components. e.g.
     *               [host, port, db, user, pass, options]
     */
-    public static function parseDsn($dsn)
+    public static function parseDsn($dsn): array
    {
        if ($dsn == '') {
            // Use a sensible default for an empty DNS string
@ -231,14 +235,16 @@ class Resque_Redis
     *
     * @param string $name The name of the method called.
     * @param array $args Array of supplied arguments to the method.
+     *
     * @return mixed Return value from Resident::call() based on the command.
+     *
     * @throws Resque_RedisException
     */
    public function __call($name, $args)
    {
        if (in_array($name, $this->keyCommands)) {
            if (is_array($args[0])) {
-                foreach ($args[0] AS $i => $v) {
+                foreach ($args[0] as $i => $v) {
                    $args[0][$i] = self::$defaultNamespace . $v;
                }
            } else {
@ -247,23 +253,18 @@ class Resque_Redis
        }
        try {
            return $this->driver->__call($name, $args);
-        } catch (CredisException $e) {
-            throw new Resque_RedisException('Error communicating with Redis: ' . $e->getMessage(), 0, $e);
+        } catch (\Exception $e) {
+            throw new RedisException('Error communicating with Redis: ' . $e->getMessage(), 0, $e);
        }
    }

+    /**
+     * Returns redis prefix
+     *
+     * @return string
+     */
    public static function getPrefix(): string
    {
        return self::$defaultNamespace;
    }
-
-    public static function removePrefix($string): string
-    {
-        $prefix = self::getPrefix();
-
-        if (substr($string, 0, strlen($prefix)) == $prefix) {
-            $string = substr($string, strlen($prefix), strlen($string));
-        }
-        return $string;
-    }
 }
--- a/src/Resque/RedisException.php
+++ b/src/Resque/RedisException.php
@ -0,0 +1,15 @@
+<?php
+
+namespace Resque;
+
+/**
+ * Redis exceptions
+ *
+ * @package        Resque
+ * @author         Daniel Mason <daniel@m2.nz>
+ * @license        http://www.opensource.org/licenses/mit-license.php
+ */
+
+class RedisException extends \Exception
+{
+}
--- a/src/Resque/Resque.php
+++ b/src/Resque/Resque.php
@ -1,18 +1,20 @@
 <?php

+namespace Resque;
+
 /**
 * Base Resque class.
 *
 * @package        Resque
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */

 class Resque
 {
-    const VERSION = '1.4.3';
+    public const VERSION = '2.5.3';

-    const DEFAULT_INTERVAL = 5;
+    public const DEFAULT_INTERVAL = 5;

    /**
     * @var Resque_Redis Instance of Resque_Redis that talks to redis.
@ -50,19 +52,20 @@ class Resque
    /**
     * Return an instance of the Resque_Redis class instantiated for Resque.
     *
-     * @return Resque_Redis Instance of Resque_Redis.
-     * @throws Resque_RedisException
+     * @return \Resque\Redis Instance of Resque_Redis.
+     *
+     * @throws \Resque\RedisException
     */
    public static function redis()
    {
-        if (self::$redis !== null) {
+        if (!is_null(self::$redis)) {
            return self::$redis;
        }

        if (is_callable(self::$redisServer)) {
            self::$redis = call_user_func(self::$redisServer, self::$redisDatabase);
        } else {
-            self::$redis = new Resque_Redis(self::$redisServer, self::$redisDatabase);
+            self::$redis = new \Resque\Redis(self::$redisServer, self::$redisDatabase);
        }

        return self::$redis;
@ -89,7 +92,7 @@ class Resque

        $pid = pcntl_fork();
        if ($pid === -1) {
-            throw new RuntimeException('Unable to fork child worker.');
+            throw new \RuntimeException('Unable to fork child worker.');
        }

        return $pid;
@ -101,19 +104,23 @@ class Resque
     *
     * @param string $queue The name of the queue to add the job to.
     * @param array $item Job description as an array to be JSON encoded.
+     *
     * @return bool
     */
-    public static function push($queue, $item)
+    public static function push($queue, $item): bool
    {
        $encodedItem = json_encode($item);
        if ($encodedItem === false) {
            return false;
        }
+
        self::redis()->sadd('queues', $queue);
+
        $length = self::redis()->rpush('queue:' . $queue, $encodedItem);
        if ($length < 1) {
            return false;
        }
+
        return true;
    }

@ -122,6 +129,7 @@ class Resque
     * return it.
     *
     * @param string $queue The name of the queue to fetch an item from.
+     *
     * @return mixed Decoded item from the queue.
     */
    public static function pop($queue)
@ -142,7 +150,7 @@ class Resque
     * @param array $items
     * @return integer number of deleted items
     */
-    public static function dequeue($queue, $items = Array())
+    public static function dequeue($queue, $items = [])
    {
        if (count($items) > 0) {
            return self::removeItems($queue, $items);
@ -155,13 +163,14 @@ class Resque
     * Remove specified queue
     *
     * @param string $queue The name of the queue to remove.
-     * @return integer Number of deleted items
+     *
+     * @return int Number of deleted items
     */
-    public static function removeQueue($queue)
+    public static function removeQueue($queue): int
    {
        $num = self::removeList($queue);
        self::redis()->srem('queues', $queue);
-        return $num;
+        return intval($num);
    }

    /**
@ -170,12 +179,13 @@ class Resque
     *
     * @param array $queues
     * @param int $timeout
+     *
     * @return array|null|void
     */
    public static function blpop(array $queues, $timeout)
    {
-        $list = array();
-        foreach ($queues AS $queue) {
+        $list = [];
+        foreach ($queues as $queue) {
            $list[] = 'queue:' . $queue;
        }

@ -192,10 +202,10 @@ class Resque
         */
        $queue = substr($item[0], strlen(self::redis()->getPrefix() . 'queue:'));

-        return array(
+        return [
            'queue' => $queue,
            'payload' => json_decode($item[1], true)
-        );
+        ];
    }

    /**
@ -205,9 +215,9 @@ class Resque
     *
     * @return int The size of the queue.
     */
-    public static function size($queue)
+    public static function size($queue): int
    {
-        return self::redis()->llen('queue:' . $queue);
+        return intval(self::redis()->llen('queue:' . $queue));
    }

    /**
@ -223,20 +233,20 @@ class Resque
    public static function enqueue($queue, $class, $args = null, $trackStatus = false)
    {
        $id = Resque::generateJobId();
-        $hookParams = array(
+        $hookParams = [
            'class' => $class,
            'args' => $args,
            'queue' => $queue,
            'id' => $id,
-        );
+        ];
        try {
-            Resque_Event::trigger('beforeEnqueue', $hookParams);
-        } catch (Resque_Job_DontCreate $e) {
+            \Resque\Event::trigger('beforeEnqueue', $hookParams);
+        } catch (\Resque\Job\DontCreate $e) {
            return false;
        }

-        Resque_Job::create($queue, $class, $args, $trackStatus, $id);
-        Resque_Event::trigger('afterEnqueue', $hookParams);
+        \Resque\Job\Job::create($queue, $class, $args, $trackStatus, $id);
+        \Resque\Event::trigger('afterEnqueue', $hookParams);

        return $id;
    }
@ -245,11 +255,12 @@ class Resque
     * Reserve and return the next available job in the specified queue.
     *
     * @param string $queue Queue to fetch next available job from.
-     * @return false|object|Resque_Job
+     *
+     * @return \Resque\Job\Job|null
     */
-    public static function reserve($queue)
+    public static function reserve($queue): ?\Resque\Job\Job
    {
-        return Resque_Job::reserve($queue);
+        return \Resque\Job\Job::reserve($queue);
    }

    /**
@ -257,13 +268,10 @@ class Resque
     *
     * @return array Array of queues.
     */
-    public static function queues()
+    public static function queues(): array
    {
        $queues = self::redis()->smembers('queues');
-        if (!is_array($queues)) {
-            $queues = array();
-        }
-        return $queues;
+        return is_array($queues) ? $queues : [];
    }

    /**
@ -276,9 +284,10 @@ class Resque
     *
     * @param string $queue The name of the queue
     * @param array $items
-     * @return integer number of deleted items
+     *
+     * @return int number of deleted items
     */
-    private static function removeItems($queue, $items = Array())
+    private static function removeItems($queue, $items = []): int
    {
        $counter = 0;
        $originalQueue = 'queue:' . $queue;
@ -343,8 +352,11 @@ class Resque
                # class name with args , example: item[0] = ['class' => {'foo' => 1, 'bar' => 2}]
            } elseif (is_array($val)) {
                $decodedArgs = (array)$decoded['args'][0];
-                if ($decoded['class'] == $key &&
-                    count($decodedArgs) > 0 && count(array_diff($decodedArgs, $val)) == 0) {
+                if (
+                    $decoded['class'] == $key
+                    && count($decodedArgs) > 0
+                    && count(array_diff($decodedArgs, $val)) == 0
+                ) {
                    return true;
                }
                # class name with ID, example: item[0] = ['class' => 'id']
@ -365,7 +377,7 @@ class Resque
     * @params string $queue the name of the queue
     * @param $queue
     * @return integer number of deleted items belongs to this list
-     * @throws Resque_RedisException
+     * @throws \Resque\RedisException
     */
    private static function removeList($queue)
    {
--- a/src/Resque/Stat.php
+++ b/src/Resque/Stat.php
@ -1,22 +1,25 @@
 <?php

+namespace Resque;
+
 /**
 * Resque statistic management (jobs processed, failed, etc)
 *
- * @package        Resque/Stat
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @package        Resque
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */

-class Resque_Stat
+class Stat
 {
    /**
     * Get the value of the supplied statistic counter for the specified statistic.
     *
     * @param string $stat The name of the statistic to get the stats for.
-     * @return mixed Value of the statistic.
+     *
+     * @return int Value of the statistic.
     */
-    public static function get($stat): int
+    public static function get(string $stat): int
    {
        return (int)Resque::redis()->get('stat:' . $stat);
    }
@ -26,11 +29,24 @@ class Resque_Stat
     *
     * @param string $stat The name of the statistic to increment.
     * @param int $by The amount to increment the statistic by.
-     * @return boolean True if successful, false if not.
+     *
+     * @return bool True if successful, false if not.
     */
-    public static function incr($stat, $by = 1): bool
+    public static function incr(string $stat, int $by = 1): bool
    {
-        return (bool)Resque::redis()->incrby('stat:' . $stat, $by);
+        // Make sure we set a TTL by default
+        $set = Resque::redis()->set(
+            'stat:' . $stat,
+            $by,
+            ['ex' => Redis::DEFAULT_REDIS_TTL,  'nx'],
+        );
+
+        // If it already exists, return the incrby value
+        if (!$set) {
+            return (bool)Resque::redis()->incrby('stat:' . $stat, $by);
+        }
+
+        return true;
    }

    /**
@ -38,9 +54,10 @@ class Resque_Stat
     *
     * @param string $stat The name of the statistic to decrement.
     * @param int $by The amount to decrement the statistic by.
-     * @return boolean True if successful, false if not.
+     *
+     * @return bool True if successful, false if not.
     */
-    public static function decr($stat, $by = 1): bool
+    public static function decr(string $stat, int $by = 1): bool
    {
        return (bool)Resque::redis()->decrby('stat:' . $stat, $by);
    }
@ -49,10 +66,11 @@ class Resque_Stat
     * Delete a statistic with the given name.
     *
     * @param string $stat The name of the statistic to delete.
-     * @return boolean True if successful, false if not.
+     *
+     * @return bool True if successful, false if not.
     */
-    public static function clear($stat): bool
+    public static function clear(string $stat): bool
    {
        return (bool)Resque::redis()->del('stat:' . $stat);
    }
-}
+}
--- a/src/Resque/Worker.php
+++ b/src/Resque/Worker.php
@ -1,17 +1,20 @@
 <?php
+
 declare(ticks=1);

+namespace Resque;
+
 use Psr\Log\LoggerInterface;

 /**
 * Resque worker that handles checking queues for jobs, fetching them
 * off the queues, running them and handling the result.
 *
- * @package        Resque/Worker
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @package        Resque
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */
-class Resque_Worker
+class Worker
 {
    /**
     * @var LoggerInterface Logging object that impliments the PSR-3 LoggerInterface
@ -44,7 +47,7 @@ class Resque_Worker
    private $id;

    /**
-     * @var Resque_Job Current job, if any, being processed by this worker.
+     * @var \Resque\Job\Job Current job, if any, being processed by this worker.
     */
    private $currentJob = null;

@ -66,7 +69,7 @@ class Resque_Worker
     */
    public function __construct($queues)
    {
-        $this->logger = new Resque_Log();
+        $this->logger = new Log();

        if (!is_array($queues)) {
            $queues = [$queues];
@ -80,6 +83,7 @@ class Resque_Worker

    /**
     * Return all workers known to Resque as instantiated instances.
+     *
     * @return array
     */
    public static function all(): array
@ -93,14 +97,17 @@ class Resque_Worker
        foreach ($workers as $workerId) {
            $instances[] = self::find($workerId);
        }
+
        return $instances;
    }

    /**
     * Given a worker ID, check if it is registered/valid.
     *
-     * @param string $workerId ID of the worker.
-     * @return boolean True if the worker exists, false if not.
+     * @param string $workerId ID of the worker
+     *
+     * @return boolean True if the worker exists, false if not
+     *
     * @throws Resque_RedisException
     */
    public static function exists($workerId): bool
@ -111,20 +118,24 @@ class Resque_Worker
    /**
     * Given a worker ID, find it and return an instantiated worker class for it.
     *
-     * @param string $workerId The ID of the worker.
-     * @return bool|Resque_Worker
+     * @param string $workerId The ID of the worker
+     *
+     * @return Resque_Worker|bool
+     *
     * @throws Resque_RedisException
     */
    public static function find($workerId)
    {
-        if (!self::exists($workerId) || false === strpos($workerId, ":")) {
+        if (false === strpos($workerId, ":") || !self::exists($workerId)) {
            return false;
        }
+
        /** @noinspection PhpUnusedLocalVariableInspection */
        list($hostname, $pid, $queues) = explode(':', $workerId, 3);
        $queues = explode(',', $queues);
        $worker = new self($queues);
        $worker->setId($workerId);
+
        return $worker;
    }

@ -132,8 +143,10 @@ class Resque_Worker
     * Set the ID of this worker to a given ID string.
     *
     * @param string $workerId ID for the worker.
+     *
+     * @return void
     */
-    public function setId($workerId)
+    public function setId($workerId): void
    {
        $this->id = $workerId;
    }
@ -146,9 +159,12 @@ class Resque_Worker
     *
     * @param int $interval How often to check for new jobs across the queues.
     * @param bool $blocking
+     *
+     * @return void
+     *
     * @throws Resque_RedisException
     */
-    public function work($interval = Resque::DEFAULT_INTERVAL, $blocking = false)
+    public function work($interval = Resque::DEFAULT_INTERVAL, $blocking = false): void
    {
        $this->updateProcLine('Starting');
        $this->startup();
@ -162,8 +178,14 @@ class Resque_Worker
            $job = false;
            if (!$this->paused) {
                if ($blocking === true) {
-                    $this->logger->log(Psr\Log\LogLevel::INFO, 'Starting blocking with timeout of {interval}', ['interval' => $interval]);
-                    $this->updateProcLine('Waiting for ' . implode(',', $this->queues) . ' with blocking timeout ' . $interval);
+                    $this->logger->log(
+                        \Psr\Log\LogLevel::INFO,
+                        'Starting blocking with timeout of {interval}',
+                        ['interval' => $interval],
+                    );
+                    $this->updateProcLine(
+                        'Waiting for ' . implode(',', $this->queues) . ' with blocking timeout ' . $interval
+                    );
                } else {
                    $this->updateProcLine('Waiting for ' . implode(',', $this->queues) . ' with interval ' . $interval);
                }
@ -179,7 +201,12 @@ class Resque_Worker

                if ($blocking === false) {
                    // If no job was found, we sleep for $interval before continuing and checking again
-                    $this->logger->log(Psr\Log\LogLevel::INFO, 'Sleeping for {interval}', ['interval' => $interval]);
+                    $this->logger->log(
+                        \Psr\Log\LogLevel::INFO,
+                        'Sleeping for {interval}',
+                        ['interval' => $interval],
+                    );
+
                    if ($this->paused) {
                        $this->updateProcLine('Paused');
                    } else {
@ -192,17 +219,19 @@ class Resque_Worker
                continue;
            }

-            $this->logger->log(Psr\Log\LogLevel::NOTICE, 'Starting work on {job}', ['job' => $job]);
-            Resque_Event::trigger('beforeFork', $job);
+            $this->logger->log(\Psr\Log\LogLevel::NOTICE, 'Starting work on {job}', ['job' => $job]);
+            Event::trigger('beforeFork', $job);
            $this->workingOn($job);

            $this->child = Resque::fork();

            // Forked and we're the child. Run the job.
            if ($this->child === 0 || $this->child === false) {
-                $status = 'Processing ' . $job->queue . ' since ' . strftime('%F %T');
+                $status = 'Processing ' . $job->queue
+                    . ' (' . ($job->payload['class'] ?? '') . ') since '
+                    . date('Y-m-d H:i:s');
                $this->updateProcLine($status);
-                $this->logger->log(Psr\Log\LogLevel::INFO, $status);
+                $this->logger->log(\Psr\Log\LogLevel::INFO, $status);
                /** @noinspection PhpParamsInspection */
                $this->perform($job);
                if ($this->child === 0) {
@ -212,15 +241,15 @@ class Resque_Worker

            if ($this->child > 0) {
                // Parent process, sit and wait
-                $status = 'Forked ' . $this->child . ' at ' . strftime('%F %T');
+                $status = 'Forked ' . $this->child . ' at ' . date('Y-m-d H:i:s');
                $this->updateProcLine($status);
-                $this->logger->log(Psr\Log\LogLevel::INFO, $status);
+                $this->logger->log(\Psr\Log\LogLevel::INFO, $status);

                // Wait until the child process finishes before continuing
                pcntl_wait($status);
                $exitStatus = pcntl_wexitstatus($status);
                if ($exitStatus !== 0) {
-                    $job->fail(new Resque_Job_DirtyExitException(
+                    $job->fail(new \Resque\Job\DirtyExitException(
                        'Job exited with exit code ' . $exitStatus
                    ));
                }
@ -234,29 +263,32 @@ class Resque_Worker
    }

    /**
-     * Process a single job.
+     * Process a single job
     *
-     * @param Resque_Job $job The job to be processed.
+     * @param \Resque\Job\Job $job The job to be processed
+     *
+     * @return void
     */
-    public function perform(Resque_Job $job)
+    public function perform(\Resque\Job\Job $job): void
    {
        try {
-            Resque_Event::trigger('afterFork', $job);
+            Event::trigger('afterFork', $job);
            $job->perform();
-        } catch (Exception $e) {
-            $this->logger->log(Psr\Log\LogLevel::CRITICAL, '{job} has failed {stack}', ['job' => $job, 'stack' => $e]);
+        } catch (\Exception $e) {
+            $this->logger->log(\Psr\Log\LogLevel::CRITICAL, '{job} has failed {stack}', ['job' => $job, 'stack' => $e]);
            $job->fail($e);
            return;
        }

-        $job->updateStatus(Resque_Job_Status::STATUS_COMPLETE);
-        $this->logger->log(Psr\Log\LogLevel::NOTICE, '{job} has finished', ['job' => $job]);
+        $job->updateStatus(\Resque\Job\Status::STATUS_COMPLETE);
+        $this->logger->log(\Psr\Log\LogLevel::NOTICE, '{job} has finished', ['job' => $job]);
    }

    /**
-     * @param  bool $blocking
-     * @param  int $timeout
-     * @return object|boolean               Instance of Resque_Job if a job is found, false if not.
+     * @param bool $blocking
+     * @param int $timeout
+     *
+     * @return object|boolean - Instance of \Resque\Job\Job if a job is found, false if not
     */
    public function reserve($blocking = false, $timeout = null)
    {
@ -266,17 +298,17 @@ class Resque_Worker
        }

        if ($blocking === true) {
-            $job = Resque_Job::reserveBlocking($queues, $timeout);
-            if ($job) {
-                $this->logger->log(Psr\Log\LogLevel::INFO, 'Found job on {queue}', ['queue' => $job->queue]);
+            $job = \Resque\Job\Job::reserveBlocking($queues, $timeout);
+            if (!is_null($job)) {
+                $this->logger->log(\Psr\Log\LogLevel::INFO, 'Found job on {queue}', ['queue' => $job->queue]);
                return $job;
            }
        } else {
            foreach ($queues as $queue) {
-                $this->logger->log(Psr\Log\LogLevel::INFO, 'Checking {queue} for jobs', ['queue' => $queue]);
-                $job = Resque_Job::reserve($queue);
-                if ($job) {
-                    $this->logger->log(Psr\Log\LogLevel::INFO, 'Found job on {queue}', ['queue' => $job->queue]);
+                $this->logger->log(\Psr\Log\LogLevel::INFO, 'Checking {queue} for jobs', ['queue' => $queue]);
+                $job = \Resque\Job\Job::reserve($queue);
+                if (!is_null($job)) {
+                    $this->logger->log(\Psr\Log\LogLevel::INFO, 'Found job on {queue}', ['queue' => $job->queue]);
                    return $job;
                }
            }
@ -287,16 +319,17 @@ class Resque_Worker

    /**
     * Return an array containing all of the queues that this worker should use
-     * when searching for jobs.
+     * when searching for jobs
     *
     * If * is found in the list of queues, every queue will be searched in
-     * alphabetic order. (@see $fetch)
+     * alphabetic order. (@param boolean $fetch If true, and the queue is set to *, will fetch
+     * all queue names from redis
     *
-     * @param boolean $fetch If true, and the queue is set to *, will fetch
-     * all queue names from redis.
-     * @return array Array of associated queues.
+     * @param boolean $fetch
+     *
+     * @return array Array of associated queues
     */
-    public function queues($fetch = true)
+    public function queues(bool $fetch = true): array
    {
        if (!in_array('*', $this->queues) || $fetch == false) {
            return $this->queues;
@ -304,17 +337,20 @@ class Resque_Worker

        $queues = Resque::queues();
        sort($queues);
+
        return $queues;
    }

    /**
-     * Perform necessary actions to start a worker.
+     * Perform necessary actions to start a worker
+     *
+     * @return void
     */
-    private function startup()
+    private function startup(): void
    {
        $this->registerSigHandlers();
        $this->pruneDeadWorkers();
-        Resque_Event::trigger('beforeFirstFork', $this);
+        Event::trigger('beforeFirstFork', $this);
        $this->registerWorker();
    }

@ -323,14 +359,16 @@ class Resque_Worker
     * the name of the currently running process to indicate the current state
     * of a worker.
     *
-     * @param string $status The updated process title.
+     * @param string $status The updated process title
+     *
+     * @return void
     */
-    private function updateProcLine($status)
+    private function updateProcLine($status): void
    {
        $processTitle = 'resque-' . Resque::VERSION . ': ' . $status;
        if (function_exists('cli_set_process_title') && PHP_OS !== 'Darwin') {
            cli_set_process_title($processTitle);
-        } else if (function_exists('setproctitle')) {
+        } elseif (function_exists('setproctitle')) {
            setproctitle($processTitle);
        }
    }
@ -342,8 +380,10 @@ class Resque_Worker
     * INT: Shutdown immediately and stop processing jobs.
     * QUIT: Shutdown after the current job finishes processing.
     * USR1: Kill the forked child immediately and continue processing jobs.
+     *
+     * @return void
     */
-    private function registerSigHandlers()
+    private function registerSigHandlers(): void
    {
        if (!function_exists('pcntl_signal')) {
            return;
@ -355,43 +395,51 @@ class Resque_Worker
        pcntl_signal(SIGUSR1, [$this, 'killChild']);
        pcntl_signal(SIGUSR2, [$this, 'pauseProcessing']);
        pcntl_signal(SIGCONT, [$this, 'unPauseProcessing']);
-        $this->logger->log(Psr\Log\LogLevel::DEBUG, 'Registered signals');
+        $this->logger->log(\Psr\Log\LogLevel::DEBUG, 'Registered signals');
    }

    /**
-     * Signal handler callback for USR2, pauses processing of new jobs.
+     * Signal handler callback for USR2, pauses processing of new jobs
+     *
+     * @return void
     */
-    public function pauseProcessing()
+    public function pauseProcessing(): void
    {
-        $this->logger->log(Psr\Log\LogLevel::NOTICE, 'USR2 received; pausing job processing');
+        $this->logger->log(\Psr\Log\LogLevel::NOTICE, 'USR2 received; pausing job processing');
        $this->paused = true;
    }

    /**
     * Signal handler callback for CONT, resumes worker allowing it to pick
     * up new jobs.
+     *
+     * @return void
     */
-    public function unPauseProcessing()
+    public function unPauseProcessing(): void
    {
-        $this->logger->log(Psr\Log\LogLevel::NOTICE, 'CONT received; resuming job processing');
+        $this->logger->log(\Psr\Log\LogLevel::NOTICE, 'CONT received; resuming job processing');
        $this->paused = false;
    }

    /**
     * Schedule a worker for shutdown. Will finish processing the current job
     * and when the timeout interval is reached, the worker will shut down.
+     *
+     * @return void
     */
-    public function shutdown()
+    public function shutdown(): void
    {
        $this->shutdown = true;
-        $this->logger->log(Psr\Log\LogLevel::NOTICE, 'Shutting down');
+        $this->logger->log(\Psr\Log\LogLevel::NOTICE, 'Shutting down');
    }

    /**
     * Force an immediate shutdown of the worker, killing any child jobs
     * currently running.
+     *
+     * @return void
     */
-    public function shutdownNow()
+    public function shutdownNow(): void
    {
        $this->shutdown();
        $this->killChild();
@ -400,21 +448,27 @@ class Resque_Worker
    /**
     * Kill a forked child job immediately. The job it is processing will not
     * be completed.
+     *
+     * @return void
     */
-    public function killChild()
+    public function killChild(): void
    {
        if (!$this->child) {
-            $this->logger->log(Psr\Log\LogLevel::DEBUG, 'No child to kill.');
+            $this->logger->log(\Psr\Log\LogLevel::DEBUG, 'No child to kill.');
            return;
        }

-        $this->logger->log(Psr\Log\LogLevel::INFO, 'Killing child at {child}', ['child' => $this->child]);
+        $this->logger->log(\Psr\Log\LogLevel::INFO, 'Killing child at {child}', ['child' => $this->child]);
        if (exec('ps -o pid,state -p ' . $this->child, $output, $returnCode) && $returnCode != 1) {
-            $this->logger->log(Psr\Log\LogLevel::DEBUG, 'Child {child} found, killing.', ['child' => $this->child]);
+            $this->logger->log(\Psr\Log\LogLevel::DEBUG, 'Child {child} found, killing.', ['child' => $this->child]);
            posix_kill($this->child, SIGKILL);
            $this->child = null;
        } else {
-            $this->logger->log(Psr\Log\LogLevel::INFO, 'Child {child} not found, restarting.', ['child' => $this->child]);
+            $this->logger->log(
+                \Psr\Log\LogLevel::INFO,
+                'Child {child} not found, restarting.',
+                ['child' => $this->child],
+            );
            $this->shutdown();
        }
    }
@ -426,8 +480,10 @@ class Resque_Worker
     * This is a form of garbage collection to handle cases where the
     * server may have been killed and the Resque workers did not die gracefully
     * and therefore leave state information in Redis.
+     *
+     * @return void
     */
-    public function pruneDeadWorkers()
+    public function pruneDeadWorkers(): void
    {
        $workerPids = $this->workerPids();
        $workers = self::all();
@ -437,7 +493,11 @@ class Resque_Worker
                if ($host != $this->hostname || in_array($pid, $workerPids) || $pid == getmypid()) {
                    continue;
                }
-                $this->logger->log(Psr\Log\LogLevel::INFO, 'Pruning dead worker: {worker}', ['worker' => (string)$worker]);
+                $this->logger->log(
+                    \Psr\Log\LogLevel::INFO,
+                    'Pruning dead worker: {worker}',
+                    ['worker' => (string)$worker],
+                );
                $worker->unregisterWorker();
            }
        }
@ -449,7 +509,7 @@ class Resque_Worker
     *
     * @return array Array of Resque worker process IDs.
     */
-    public function workerPids()
+    public function workerPids(): array
    {
        $pids = [];
        exec('ps -A -o pid,command | grep [r]esque', $cmdOutput);
@ -461,100 +521,122 @@ class Resque_Worker

    /**
     * Register this worker in Redis.
-     * 48 hour TTL so we don't pollute the db on server termination.
+     * 48 hour TTL so we don't pollute the redis db on server termination.
+     *
+     * @return void
     */
-    public function registerWorker()
+    public function registerWorker(): void
    {
        Resque::redis()->sadd('workers', (string)$this);
-        Resque::redis()->setex('worker:' . (string)$this . ':started', 172800, strftime('%a %b %d %H:%M:%S %Z %Y'));
+        Resque::redis()->set(
+            'worker:' . (string)$this . ':started',
+            date('D M d H:i:s T Y'),
+            ['ex' => Redis::DEFAULT_REDIS_TTL],
+        );
    }

    /**
     * Unregister this worker in Redis. (shutdown etc)
+     *
+     * @return void
     */
-    public function unregisterWorker()
+    public function unregisterWorker(): void
    {
        if (is_object($this->currentJob)) {
-            $this->currentJob->fail(new Resque_Job_DirtyExitException);
+            $this->currentJob->fail(new \Resque\Job\DirtyExitException());
        }

        $id = (string)$this;
        Resque::redis()->srem('workers', $id);
        Resque::redis()->del('worker:' . $id);
        Resque::redis()->del('worker:' . $id . ':started');
-        Resque_Stat::clear('processed:' . $id);
-        Resque_Stat::clear('failed:' . $id);
+        Stat::clear('processed:' . $id);
+        Stat::clear('failed:' . $id);
    }

    /**
-     * Tell Redis which job we're currently working on.
+     * Tell Redis which job we're currently working on
+     *
+     * @param \Resque\Job\Job $job \Resque\Job\Job instance containing the job we're working on
+     *
+     * @return void
     *
-     * @param Resque_Job $job Resque_Job instance containing the job we're working on.
     * @throws Resque_RedisException
     */
-    public function workingOn(Resque_Job $job)
+    public function workingOn(\Resque\Job\Job $job): void
    {
        $job->worker = $this;
        $this->currentJob = $job;
-        $job->updateStatus(Resque_Job_Status::STATUS_RUNNING);
+        $job->updateStatus(\Resque\Job\Status::STATUS_RUNNING);
        $data = json_encode([
            'queue' => $job->queue,
-            'run_at' => strftime('%a %b %d %H:%M:%S %Z %Y'),
+            'run_at' => date('D M d H:i:s T Y'),
            'payload' => $job->payload
        ]);
-        Resque::redis()->set('worker:' . $job->worker, $data);
+
+        Resque::redis()->set(
+            'worker:' . $job->worker,
+            $data,
+            ['ex' => Redis::DEFAULT_REDIS_TTL],
+        );
    }

    /**
     * Notify Redis that we've finished working on a job, clearing the working
-     * state and incrementing the job stats.
+     * state and incrementing the job stats
+     *
+     * @return void
     */
-    public function doneWorking()
+    public function doneWorking(): void
    {
        $this->currentJob = null;
-        Resque_Stat::incr('processed');
-        Resque_Stat::incr('processed:' . (string)$this);
+        Stat::incr('processed');
+        Stat::incr('processed:' . (string)$this);
        Resque::redis()->del('worker:' . (string)$this);
    }

    /**
-     * Generate a string representation of this worker.
+     * Generate a string representation of this worker
     *
-     * @return string String identifier for this worker instance.
+     * @return string String identifier for this worker instance
     */
-    public function __toString()
+    public function __toString(): string
    {
-        return $this->id;
+        return (string) $this->id;
    }

    /**
-     * Return an object describing the job this worker is currently working on.
+     * Return an object describing the job this worker is currently working on
     *
-     * @return array Array with details of current job.
+     * @return array Array with details of current job
     */
    public function job(): array
    {
        $job = Resque::redis()->get('worker:' . $this);
+
        return $job ? json_decode($job, true) : [];
    }

    /**
-     * Get a statistic belonging to this worker.
+     * Get a statistic belonging to this worker
     *
     * @param string $stat Statistic to fetch.
+     *
     * @return int Statistic value.
     */
-    public function getStat($stat)
+    public function getStat(string $stat): int
    {
-        return Resque_Stat::get($stat . ':' . $this);
+        return \Resque\Stat::get($stat . ':' . $this);
    }

    /**
     * Inject the logging object into the worker
     *
-     * @param Psr\Log\LoggerInterface $logger
+     * @param \Psr\Log\LoggerInterface $logger
+     *
+     * @return void
     */
-    public function setLogger(Psr\Log\LoggerInterface $logger)
+    public function setLogger(\Psr\Log\LoggerInterface $logger): void
    {
        $this->logger = $logger;
    }
--- a/test/Resque/Tests/JobStatusTest.php
+++ b/test/Resque/Tests/JobStatusTest.php
@ -1,109 +0,0 @@
-<?php
-
-/**
- * Resque_Job_Status tests.
- *
- * @package        Resque/Tests
- * @author        Chris Boulton <chris@bigcommerce.com>
- * @license        http://www.opensource.org/licenses/mit-license.php
- */
-
-class Resque_Tests_JobStatusTest extends Resque_Tests_TestCase
-{
-    /**
-     * @var \Resque_Worker
-     */
-    protected $worker;
-
-    public function setUp()
-    {
-        parent::setUp();
-
-        // Register a worker to test with
-        $this->worker = new Resque_Worker('jobs');
-        $this->worker->setLogger(new Resque_Log());
-    }
-
-    public function testJobStatusCanBeTracked()
-    {
-        $token = Resque::enqueue('jobs', 'Test_Job', null, true);
-        $status = new Resque_Job_Status($token);
-        $this->assertTrue($status->isTracking());
-    }
-
-    public function testJobStatusIsReturnedViaJobInstance()
-    {
-        Resque::enqueue('jobs', 'Test_Job', null, true);
-        $job = Resque_Job::reserve('jobs');
-        $this->assertEquals(Resque_Job_Status::STATUS_WAITING, $job->getStatus());
-
-    }
-
-    public function testQueuedJobReturnsQueuedStatus()
-    {
-        $token = Resque::enqueue('jobs', 'Test_Job', null, true);
-        $status = new Resque_Job_Status($token);
-        $this->assertEquals(Resque_Job_Status::STATUS_WAITING, $status->get());
-    }
-
-    public function testRunningJobReturnsRunningStatus()
-    {
-        $token = Resque::enqueue('jobs', 'Failing_Job', null, true);
-        $job = $this->worker->reserve();
-        $this->worker->workingOn($job);
-        $status = new Resque_Job_Status($token);
-        $this->assertEquals(Resque_Job_Status::STATUS_RUNNING, $status->get());
-    }
-
-    public function testFailedJobReturnsFailedStatus()
-    {
-        $token = Resque::enqueue('jobs', 'Failing_Job', null, true);
-        $this->worker->work(0);
-        $status = new Resque_Job_Status($token);
-        $this->assertEquals(Resque_Job_Status::STATUS_FAILED, $status->get());
-    }
-
-    public function testCompletedJobReturnsCompletedStatus()
-    {
-        $token = Resque::enqueue('jobs', 'Test_Job', null, true);
-        $this->worker->work(0);
-        $status = new Resque_Job_Status($token);
-        $this->assertEquals(Resque_Job_Status::STATUS_COMPLETE, $status->get());
-    }
-
-    public function testStatusIsNotTrackedWhenToldNotTo()
-    {
-        $token = Resque::enqueue('jobs', 'Test_Job', null, false);
-        $status = new Resque_Job_Status($token);
-        $this->assertFalse($status->isTracking());
-    }
-
-    public function testStatusTrackingCanBeStopped()
-    {
-        Resque_Job_Status::create('test');
-        $status = new Resque_Job_Status('test');
-        $this->assertEquals(Resque_Job_Status::STATUS_WAITING, $status->get());
-        $status->stop();
-        $this->assertFalse($status->get());
-    }
-
-    public function testRecreatedJobWithTrackingStillTracksStatus()
-    {
-        $originalToken = Resque::enqueue('jobs', 'Test_Job', null, true);
-        $job = $this->worker->reserve();
-
-        // Mark this job as being worked on to ensure that the new status is still
-        // waiting.
-        $this->worker->workingOn($job);
-
-        // Now recreate it
-        $newToken = $job->recreate();
-
-        // Make sure we've got a new job returned
-        $this->assertNotEquals($originalToken, $newToken);
-
-        // Now check the status of the new job
-        $newJob = Resque_Job::reserve('jobs');
-        $this->assertEquals(Resque_Job_Status::STATUS_WAITING, $newJob->getStatus());
-    }
-}
--- a/test/Resque/Tests/JobTest.php
+++ b/test/Resque/Tests/JobTest.php
@ -1,417 +0,0 @@
-<?php
-
-/**
- * Resque_Job tests.
- *
- * @package        Resque/Tests
- * @author        Chris Boulton <chris@bigcommerce.com>
- * @license        http://www.opensource.org/licenses/mit-license.php
- */
-
-class Resque_Tests_JobTest extends Resque_Tests_TestCase
-{
-    protected $worker;
-
-    public function setUp()
-    {
-        parent::setUp();
-
-        // Register a worker to test with
-        $this->worker = new Resque_Worker('jobs');
-        $this->worker->setLogger(new Resque_Log());
-        $this->worker->registerWorker();
-    }
-
-    public function testJobCanBeQueued()
-    {
-        $this->assertTrue((bool)Resque::enqueue('jobs', 'Test_Job'));
-    }
-
-    public function testQeueuedJobCanBeReserved()
-    {
-        Resque::enqueue('jobs', 'Test_Job');
-
-        $job = Resque_Job::reserve('jobs');
-        if ($job == false) {
-            $this->fail('Job could not be reserved.');
-        }
-        $this->assertEquals('jobs', $job->queue);
-        $this->assertEquals('Test_Job', $job->payload['class']);
-    }
-
-    /**
-     * @expectedException InvalidArgumentException
-     */
-    public function testObjectArgumentsCannotBePassedToJob()
-    {
-        $args = new stdClass;
-        $args->test = 'somevalue';
-        Resque::enqueue('jobs', 'Test_Job', $args);
-    }
-
-    public function testQueuedJobReturnsExactSamePassedInArguments()
-    {
-        $args = [
-            'int' => 123,
-            'numArray' => [
-                1,
-                2,
-            ],
-            'assocArray' => [
-                'key1' => 'value1',
-                'key2' => 'value2'
-            ],
-        ];
-        Resque::enqueue('jobs', 'Test_Job', $args);
-        $job = Resque_Job::reserve('jobs');
-
-        $this->assertEquals($args, $job->getArguments());
-    }
-
-    public function testAfterJobIsReservedItIsRemoved()
-    {
-        Resque::enqueue('jobs', 'Test_Job');
-        Resque_Job::reserve('jobs');
-        $this->assertFalse(Resque_Job::reserve('jobs'));
-    }
-
-    public function testRecreatedJobMatchesExistingJob()
-    {
-        $args = [
-            'int' => 123,
-            'numArray' => [
-                1,
-                2,
-            ],
-            'assocArray' => [
-                'key1' => 'value1',
-                'key2' => 'value2'
-            ],
-        ];
-
-        Resque::enqueue('jobs', 'Test_Job', $args);
-        $job = Resque_Job::reserve('jobs');
-
-        // Now recreate it
-        $job->recreate();
-
-        $newJob = Resque_Job::reserve('jobs');
-        $this->assertEquals($job->payload['class'], $newJob->payload['class']);
-        $this->assertEquals($job->getArguments(), $newJob->getArguments());
-    }
-
-
-    public function testFailedJobExceptionsAreCaught()
-    {
-        $payload = [
-            'class' => 'Failing_Job',
-            'args' => null
-        ];
-        $job = new Resque_Job('jobs', $payload);
-        $job->worker = $this->worker;
-
-        $this->worker->perform($job);
-
-        $this->assertEquals(1, Resque_Stat::get('failed'));
-        $this->assertEquals(1, Resque_Stat::get('failed:' . $this->worker));
-    }
-
-    /**
-     * @expectedException Resque_Exception
-     */
-    public function testJobWithoutPerformMethodThrowsException()
-    {
-        Resque::enqueue('jobs', 'Test_Job_Without_Perform_Method');
-        $job = $this->worker->reserve();
-        $job->worker = $this->worker;
-        $job->perform();
-    }
-
-    /**
-     * @expectedException Resque_Exception
-     */
-    public function testInvalidJobThrowsException()
-    {
-        Resque::enqueue('jobs', 'Invalid_Job');
-        $job = $this->worker->reserve();
-        $job->worker = $this->worker;
-        $job->perform();
-    }
-
-    public function testJobWithSetUpCallbackFiresSetUp()
-    {
-        $payload = [
-            'class' => 'Test_Job_With_SetUp',
-            'args' => [
-                'somevar',
-                'somevar2',
-            ],
-        ];
-        $job = new Resque_Job('jobs', $payload);
-        $job->perform();
-
-        $this->assertTrue(Test_Job_With_SetUp::$called);
-    }
-
-    public function testJobWithTearDownCallbackFiresTearDown()
-    {
-        $payload = [
-            'class' => 'Test_Job_With_TearDown',
-            'args' => [
-                'somevar',
-                'somevar2',
-            ],
-        ];
-        $job = new Resque_Job('jobs', $payload);
-        $job->perform();
-
-        $this->assertTrue(Test_Job_With_TearDown::$called);
-    }
-
-    public function testNamespaceNaming()
-    {
-        $fixture = [
-            ['test' => 'more:than:one:with:', 'assertValue' => 'more:than:one:with:'],
-            ['test' => 'more:than:one:without', 'assertValue' => 'more:than:one:without:'],
-            ['test' => 'resque', 'assertValue' => 'resque:'],
-            ['test' => 'resque:', 'assertValue' => 'resque:'],
-        ];
-
-        foreach ($fixture as $item) {
-            Resque_Redis::prefix($item['test']);
-            $this->assertEquals(Resque_Redis::getPrefix(), $item['assertValue']);
-        }
-    }
-
-    public function testJobWithNamespace()
-    {
-        Resque_Redis::prefix('php');
-        $queue = 'jobs';
-        $payload = ['another_value'];
-        Resque::enqueue($queue, 'Test_Job_With_TearDown', $payload);
-
-        $this->assertEquals(Resque::queues(), ['jobs']);
-        $this->assertEquals(Resque::size($queue), 1);
-
-        Resque_Redis::prefix('resque');
-        $this->assertEquals(Resque::size($queue), 0);
-    }
-
-    public function testDequeueAll()
-    {
-        $queue = 'jobs';
-        Resque::enqueue($queue, 'Test_Job_Dequeue');
-        Resque::enqueue($queue, 'Test_Job_Dequeue');
-        $this->assertEquals(Resque::size($queue), 2);
-        $this->assertEquals(Resque::dequeue($queue), 2);
-        $this->assertEquals(Resque::size($queue), 0);
-    }
-
-    public function testDequeueMakeSureNotDeleteOthers()
-    {
-        $queue = 'jobs';
-        Resque::enqueue($queue, 'Test_Job_Dequeue');
-        Resque::enqueue($queue, 'Test_Job_Dequeue');
-        $other_queue = 'other_jobs';
-        Resque::enqueue($other_queue, 'Test_Job_Dequeue');
-        Resque::enqueue($other_queue, 'Test_Job_Dequeue');
-        $this->assertEquals(Resque::size($queue), 2);
-        $this->assertEquals(Resque::size($other_queue), 2);
-        $this->assertEquals(Resque::dequeue($queue), 2);
-        $this->assertEquals(Resque::size($queue), 0);
-        $this->assertEquals(Resque::size($other_queue), 2);
-    }
-
-    public function testDequeueSpecificItem()
-    {
-        $queue = 'jobs';
-        Resque::enqueue($queue, 'Test_Job_Dequeue1');
-        Resque::enqueue($queue, 'Test_Job_Dequeue2');
-        $this->assertEquals(Resque::size($queue), 2);
-        $test = ['Test_Job_Dequeue2'];
-        $this->assertEquals(Resque::dequeue($queue, $test), 1);
-        $this->assertEquals(Resque::size($queue), 1);
-    }
-
-    public function testDequeueSpecificMultipleItems()
-    {
-        $queue = 'jobs';
-        Resque::enqueue($queue, 'Test_Job_Dequeue1');
-        Resque::enqueue($queue, 'Test_Job_Dequeue2');
-        Resque::enqueue($queue, 'Test_Job_Dequeue3');
-        $this->assertEquals(Resque::size($queue), 3);
-        $test = ['Test_Job_Dequeue2', 'Test_Job_Dequeue3'];
-        $this->assertEquals(Resque::dequeue($queue, $test), 2);
-        $this->assertEquals(Resque::size($queue), 1);
-    }
-
-    public function testDequeueNonExistingItem()
-    {
-        $queue = 'jobs';
-        Resque::enqueue($queue, 'Test_Job_Dequeue1');
-        Resque::enqueue($queue, 'Test_Job_Dequeue2');
-        Resque::enqueue($queue, 'Test_Job_Dequeue3');
-        $this->assertEquals(Resque::size($queue), 3);
-        $test = ['Test_Job_Dequeue4'];
-        $this->assertEquals(Resque::dequeue($queue, $test), 0);
-        $this->assertEquals(Resque::size($queue), 3);
-    }
-
-    public function testDequeueNonExistingItem2()
-    {
-        $queue = 'jobs';
-        Resque::enqueue($queue, 'Test_Job_Dequeue1');
-        Resque::enqueue($queue, 'Test_Job_Dequeue2');
-        Resque::enqueue($queue, 'Test_Job_Dequeue3');
-        $this->assertEquals(Resque::size($queue), 3);
-        $test = ['Test_Job_Dequeue4', 'Test_Job_Dequeue1'];
-        $this->assertEquals(Resque::dequeue($queue, $test), 1);
-        $this->assertEquals(Resque::size($queue), 2);
-    }
-
-    public function testDequeueItemID()
-    {
-        $queue = 'jobs';
-        Resque::enqueue($queue, 'Test_Job_Dequeue');
-        $qid = Resque::enqueue($queue, 'Test_Job_Dequeue');
-        $this->assertEquals(Resque::size($queue), 2);
-        $test = ['Test_Job_Dequeue' => $qid];
-        $this->assertEquals(Resque::dequeue($queue, $test), 1);
-        $this->assertEquals(Resque::size($queue), 1);
-    }
-
-    public function testDequeueWrongItemID()
-    {
-        $queue = 'jobs';
-        Resque::enqueue($queue, 'Test_Job_Dequeue');
-        $qid = Resque::enqueue($queue, 'Test_Job_Dequeue');
-        $this->assertEquals(Resque::size($queue), 2);
-        #qid right but class name is wrong
-        $test = ['Test_Job_Dequeue1' => $qid];
-        $this->assertEquals(Resque::dequeue($queue, $test), 0);
-        $this->assertEquals(Resque::size($queue), 2);
-    }
-
-    public function testDequeueWrongItemID2()
-    {
-        $queue = 'jobs';
-        Resque::enqueue($queue, 'Test_Job_Dequeue');
-        Resque::enqueue($queue, 'Test_Job_Dequeue');
-        $this->assertEquals(Resque::size($queue), 2);
-        $test = ['Test_Job_Dequeue' => 'r4nD0mH4sh3dId'];
-        $this->assertEquals(Resque::dequeue($queue, $test), 0);
-        $this->assertEquals(Resque::size($queue), 2);
-    }
-
-    public function testDequeueItemWithArg()
-    {
-        $queue = 'jobs';
-        $arg = ['foo' => 1, 'bar' => 2];
-        Resque::enqueue($queue, 'Test_Job_Dequeue9');
-        Resque::enqueue($queue, 'Test_Job_Dequeue9', $arg);
-        $this->assertEquals(Resque::size($queue), 2);
-        $test = ['Test_Job_Dequeue9' => $arg];
-        $this->assertEquals(Resque::dequeue($queue, $test), 1);
-        #$this->assertEquals(Resque::size($queue), 1);
-    }
-
-    public function testDequeueSeveralItemsWithArgs()
-    {
-        // GIVEN
-        $queue = 'jobs';
-        $args = ['foo' => 1, 'bar' => 10];
-        $removeArgs = ['foo' => 1, 'bar' => 2];
-        Resque::enqueue($queue, 'Test_Job_Dequeue9', $args);
-        Resque::enqueue($queue, 'Test_Job_Dequeue9', $removeArgs);
-        Resque::enqueue($queue, 'Test_Job_Dequeue9', $removeArgs);
-        $this->assertEquals(Resque::size($queue), 3, "Failed to add 3 items.");
-
-        // WHEN
-        $test = ['Test_Job_Dequeue9' => $removeArgs];
-        $removedItems = Resque::dequeue($queue, $test);
-
-        // THEN
-        $this->assertEquals($removedItems, 2);
-        $this->assertEquals(Resque::size($queue), 1);
-        $item = Resque::pop($queue);
-        $this->assertInternalType('array', $item['args']);
-        $this->assertEquals(10, $item['args'][0]['bar'], 'Wrong items were dequeued from queue!');
-    }
-
-    public function testDequeueItemWithUnorderedArg()
-    {
-        $queue = 'jobs';
-        $arg = ['foo' => 1, 'bar' => 2];
-        $arg2 = ['bar' => 2, 'foo' => 1];
-        Resque::enqueue($queue, 'Test_Job_Dequeue');
-        Resque::enqueue($queue, 'Test_Job_Dequeue', $arg);
-        $this->assertEquals(Resque::size($queue), 2);
-        $test = ['Test_Job_Dequeue' => $arg2];
-        $this->assertEquals(Resque::dequeue($queue, $test), 1);
-        $this->assertEquals(Resque::size($queue), 1);
-    }
-
-    public function testDequeueItemWithiWrongArg()
-    {
-        $queue = 'jobs';
-        $arg = ['foo' => 1, 'bar' => 2];
-        $arg2 = ['foo' => 2, 'bar' => 3];
-        Resque::enqueue($queue, 'Test_Job_Dequeue');
-        Resque::enqueue($queue, 'Test_Job_Dequeue', $arg);
-        $this->assertEquals(Resque::size($queue), 2);
-        $test = ['Test_Job_Dequeue' => $arg2];
-        $this->assertEquals(Resque::dequeue($queue, $test), 0);
-        $this->assertEquals(Resque::size($queue), 2);
-    }
-
-    public function testUseDefaultFactoryToGetJobInstance()
-    {
-        $payload = [
-            'class' => 'Some_Job_Class',
-            'args' => null
-        ];
-        $job = new Resque_Job('jobs', $payload);
-        $instance = $job->getInstance();
-        $this->assertInstanceOf('Some_Job_Class', $instance);
-    }
-
-    public function testUseFactoryToGetJobInstance()
-    {
-        $payload = [
-            'class' => 'Some_Job_Class',
-            'args' => [[]]
-        ];
-        $job = new Resque_Job('jobs', $payload);
-        $factory = new Some_Stub_Factory();
-        $job->setJobFactory($factory);
-        $instance = $job->getInstance();
-        $this->assertInstanceOf('Resque_JobInterface', $instance);
-    }
-}
-
-class Some_Job_Class implements Resque_JobInterface
-{
-
-    /**
-     * @return bool
-     */
-    public function perform()
-    {
-        return true;
-    }
-}
-
-class Some_Stub_Factory implements Resque_Job_FactoryInterface
-{
-
-    /**
-     * @param $className
-     * @param array $args
-     * @param $queue
-     * @return Resque_JobInterface
-     */
-    public function create($className, $args, $queue)
-    {
-        return new Some_Job_Class();
-    }
-}
--- a/test/bootstrap.php
+++ b/test/bootstrap.php
@ -1,150 +0,0 @@
-<?php
-/**
- * Resque test bootstrap file - sets up a test environment.
- *
- * @package        Resque/Tests
- * @author        Chris Boulton <chris@bigcommerce.com>
- * @license        http://www.opensource.org/licenses/mit-license.php
- */
-
-$loader = require __DIR__ . '/../vendor/autoload.php';
-$loader->add('Resque_Tests', __DIR__);
-
-define('TEST_MISC', realpath(__DIR__ . '/misc/'));
-define('REDIS_CONF', TEST_MISC . '/redis.conf');
-
-// Attempt to start our own redis instance for tesitng.
-exec('which redis-server', $output, $returnVar);
-if ($returnVar != 0) {
-    echo "Cannot find redis-server in path. Please make sure redis is installed.\n";
-    exit(1);
-}
-
-exec('cd ' . TEST_MISC . '; redis-server ' . REDIS_CONF, $output, $returnVar);
-usleep(500000);
-if ($returnVar != 0) {
-    echo "Cannot start redis-server.\n";
-    exit(1);
-
-}
-
-// Get redis port from conf
-$config = file_get_contents(REDIS_CONF);
-if (!preg_match('#^\s*port\s+([0-9]+)#m', $config, $matches)) {
-    echo "Could not determine redis port from redis.conf";
-    exit(1);
-}
-
-Resque::setBackend('localhost:' . $matches[1]);
-
-// Shutdown
-function killRedis($pid)
-{
-    if (getmypid() !== $pid) {
-        return; // don't kill from a forked worker
-    }
-    $config = file_get_contents(REDIS_CONF);
-    if (!preg_match('#^\s*pidfile\s+([^\s]+)#m', $config, $matches)) {
-        return;
-    }
-
-    $pidFile = TEST_MISC . '/' . $matches[1];
-    if (file_exists($pidFile)) {
-        $pid = trim(file_get_contents($pidFile));
-        posix_kill((int)$pid, 9);
-
-        if (is_file($pidFile)) {
-            unlink($pidFile);
-        }
-    }
-
-    // Remove the redis database
-    if (!preg_match('#^\s*dir\s+([^\s]+)#m', $config, $matches)) {
-        return;
-    }
-    $dir = $matches[1];
-
-    if (!preg_match('#^\s*dbfilename\s+([^\s]+)#m', $config, $matches)) {
-        return;
-    }
-
-    $filename = TEST_MISC . '/' . $dir . '/' . $matches[1];
-    if (is_file($filename)) {
-        unlink($filename);
-    }
-}
-
-register_shutdown_function('killRedis', getmypid());
-
-if (function_exists('pcntl_signal')) {
-    // Override INT and TERM signals, so they do a clean shutdown and also
-    // clean up redis-server as well.
-    function sigint()
-    {
-        exit;
-    }
-
-    pcntl_signal(SIGINT, 'sigint');
-    pcntl_signal(SIGTERM, 'sigint');
-}
-
-class Test_Job
-{
-    public static $called = false;
-
-    public function perform()
-    {
-        self::$called = true;
-    }
-}
-
-class Failing_Job_Exception extends Exception
-{
-
-}
-
-class Failing_Job
-{
-    public function perform()
-    {
-        throw new Failing_Job_Exception('Message!');
-    }
-}
-
-class Test_Job_Without_Perform_Method
-{
-
-}
-
-class Test_Job_With_SetUp
-{
-    public static $called = false;
-    public $args = false;
-
-    public function setUp()
-    {
-        self::$called = true;
-    }
-
-    public function perform()
-    {
-
-    }
-}
-
-
-class Test_Job_With_TearDown
-{
-    public static $called = false;
-    public $args = false;
-
-    public function perform()
-    {
-
-    }
-
-    public function tearDown()
-    {
-        self::$called = true;
-    }
-}
--- a/test/misc/redis.conf
+++ b/test/misc/redis.conf
@ -1,8 +0,0 @@
-daemonize yes
-pidfile ./redis.pid
-port 6379
-bind 127.0.0.1
-timeout 300
-dbfilename dump.rdb
-dir ./
-loglevel debug
--- a/tests/Resque/Tests/EventTest.php
+++ b/tests/Resque/Tests/EventTest.php
@ -1,43 +1,45 @@
 <?php

+namespace Resque\Test;
+
 /**
- * Resque_Event tests.
+ * \Resque\Event tests.
 *
 * @package        Resque/Tests
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */

-class Resque_Tests_EventTest extends Resque_Tests_TestCase
+class EventTest extends TestCase
 {
    private $callbacksHit = [];
    private $worker;

-    public function setUp()
+    public function setUp(): void
    {
-        Test_Job::$called = false;
+        TestJob::$called = false;

        // Register a worker to test with
-        $this->worker = new Resque_Worker('jobs');
-        $this->worker->setLogger(new Resque_Log());
+        $this->worker = new \Resque\Worker('jobs');
+        $this->worker->setLogger(new \Resque\Log());
        $this->worker->registerWorker();
    }

-    public function tearDown()
+    public function tearDown(): void
    {
-        Resque_Event::clearListeners();
+        \Resque\Event::clearListeners();
        $this->callbacksHit = [];
    }

    public function getEventTestJob()
    {
        $payload = [
-            'class' => 'Test_Job',
+            'class' => '\Resque\Test\TestJob',
            'args' => [
                ['somevar'],
            ],
        ];
-        $job = new Resque_Job('jobs', $payload);
+        $job = new \Resque\Job\Job('jobs', $payload);
        $job->worker = $this->worker;
        return $job;
    }
@ -58,7 +60,7 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
     */
    public function testEventCallbacksFire($event, $callback)
    {
-        Resque_Event::listen($event, [$this, $callback]);
+        \Resque\Event::listen($event, [$this, $callback]);

        $job = $this->getEventTestJob();
        $this->worker->perform($job);
@ -72,8 +74,8 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
        $event = 'beforeFork';
        $callback = 'beforeForkEventCallback';

-        Resque_Event::listen($event, [$this, $callback]);
-        Resque::enqueue('jobs', 'Test_Job', [
+        \Resque\Event::listen($event, [$this, $callback]);
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob', [
            'somevar'
        ]);
        $this->getEventTestJob();
@ -86,8 +88,8 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
        $event = 'beforeEnqueue';
        $callback = 'beforeEnqueueEventCallback';

-        Resque_Event::listen($event, [$this, $callback]);
-        Resque::enqueue('jobs', 'Test_Job', [
+        \Resque\Event::listen($event, [$this, $callback]);
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob', [
            'somevar'
        ]);
        $this->assertContains($callback, $this->callbacksHit, $event . ' callback (' . $callback . ') was not called');
@ -96,22 +98,22 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
    public function testBeforePerformEventCanStopWork()
    {
        $callback = 'beforePerformEventDontPerformCallback';
-        Resque_Event::listen('beforePerform', [$this, $callback]);
+        \Resque\Event::listen('beforePerform', [$this, $callback]);

        $job = $this->getEventTestJob();

        $this->assertFalse($job->perform());
        $this->assertContains($callback, $this->callbacksHit, $callback . ' callback was not called');
-        $this->assertFalse(Test_Job::$called, 'Job was still performed though Resque_Job_DontPerform was thrown');
+        $this->assertFalse(TestJob::$called, 'Job was still performed though Resque_Job_DontPerform was thrown');
    }

    public function testBeforeEnqueueEventStopsJobCreation()
    {
        $callback = 'beforeEnqueueEventDontCreateCallback';
-        Resque_Event::listen('beforeEnqueue', [$this, $callback]);
-        Resque_Event::listen('afterEnqueue', [$this, 'afterEnqueueEventCallback']);
+        \Resque\Event::listen('beforeEnqueue', [$this, $callback]);
+        \Resque\Event::listen('afterEnqueue', [$this, 'afterEnqueueEventCallback']);

-        $result = Resque::enqueue('test_job', 'TestClass');
+        $result = \Resque\Resque::enqueue('jobs', '\Resque\Test\TestClass');
        $this->assertContains($callback, $this->callbacksHit, $callback . ' callback was not called');
        $this->assertNotContains('afterEnqueueEventCallback', $this->callbacksHit, 'afterEnqueue was still called, even though it should not have been');
        $this->assertFalse($result);
@ -122,8 +124,8 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
        $callback = 'afterEnqueueEventCallback';
        $event = 'afterEnqueue';

-        Resque_Event::listen($event, [$this, $callback]);
-        Resque::enqueue('jobs', 'Test_Job', [
+        \Resque\Event::listen($event, [$this, $callback]);
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob', [
            'somevar'
        ]);
        $this->assertContains($callback, $this->callbacksHit, $event . ' callback (' . $callback . ') was not called');
@ -134,8 +136,8 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
        $callback = 'beforePerformEventCallback';
        $event = 'beforePerform';

-        Resque_Event::listen($event, [$this, $callback]);
-        Resque_Event::stopListening($event, [$this, $callback]);
+        \Resque\Event::listen($event, [$this, $callback]);
+        \Resque\Event::stopListening($event, [$this, $callback]);

        $job = $this->getEventTestJob();
        $this->worker->perform($job);
@ -149,20 +151,20 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
    public function beforePerformEventDontPerformCallback()
    {
        $this->callbacksHit[] = __FUNCTION__;
-        throw new Resque_Job_DontPerform();
+        throw new \Resque\Job\DontPerform();
    }

    public function beforeEnqueueEventDontCreateCallback()
    {
        $this->callbacksHit[] = __FUNCTION__;
-        throw new Resque_Job_DontCreate();
+        throw new \Resque\Job\DontCreate();
    }

    public function assertValidEventCallback($function, $job)
    {
        $this->callbacksHit[] = $function;
-        if (!$job instanceof Resque_Job) {
-            $this->fail('Callback job argument is not an instance of Resque_Job');
+        if (!$job instanceof \Resque\Job\Job) {
+            $this->fail('Callback job argument is not an instance of \Resque\Job\Job');
        }
        $args = $job->getArguments();
        $this->assertEquals($args[0], 'somevar');
@ -171,7 +173,7 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
    public function afterEnqueueEventCallback($class, $args)
    {
        $this->callbacksHit[] = __FUNCTION__;
-        $this->assertEquals('Test_Job', $class);
+        $this->assertEquals('\Resque\Test\TestJob', $class);
        $this->assertEquals([
            'somevar',
        ], $args);
--- a/tests/Resque/Tests/JobStatusTest.php
+++ b/tests/Resque/Tests/JobStatusTest.php
@ -0,0 +1,110 @@
+<?php
+
+namespace Resque\Test;
+
+/**
+ * \Resque\Job\Status tests.
+ *
+ * @package        Resque/Tests
+ * @author         Daniel Mason <daniel@m2.nz>
+ * @license        http://www.opensource.org/licenses/mit-license.php
+ */
+
+class JobStatusTest extends TestCase
+{
+    /**
+     * @var \Resque\Worker
+     */
+    protected $worker;
+
+    public function setUp(): void
+    {
+        parent::setUp();
+
+        // Register a worker to test with
+        $this->worker = new \Resque\Worker('jobs');
+        $this->worker->setLogger(new \Resque\Log());
+    }
+
+    public function testJobStatusCanBeTracked()
+    {
+        $token = \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob', null, true);
+        $status = new \Resque\Job\Status($token);
+        $this->assertTrue($status->isTracking());
+    }
+
+    public function testJobStatusIsReturnedViaJobInstance()
+    {
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob', null, true);
+        $job = \Resque\Job\Job::reserve('jobs');
+        $this->assertEquals(\Resque\Job\Status::STATUS_WAITING, $job->getStatus());
+    }
+
+    public function testQueuedJobReturnsQueuedStatus()
+    {
+        $token = \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob', null, true);
+        $status = new \Resque\Job\Status($token);
+        $this->assertEquals(\Resque\Job\Status::STATUS_WAITING, $status->get());
+    }
+
+    public function testRunningJobReturnsRunningStatus()
+    {
+        $token = \Resque\Resque::enqueue('jobs', '\Resque\Test\FailingJob', null, true);
+        $job = $this->worker->reserve();
+        $this->worker->workingOn($job);
+        $status = new \Resque\Job\Status($token);
+        $this->assertEquals(\Resque\Job\Status::STATUS_RUNNING, $status->get());
+    }
+
+    public function testFailedJobReturnsFailedStatus()
+    {
+        $token = \Resque\Resque::enqueue('jobs', '\Resque\Test\FailingJob', null, true);
+        $this->worker->work(0);
+        $status = new \Resque\Job\Status($token);
+        $this->assertEquals(\Resque\Job\Status::STATUS_FAILED, $status->get());
+    }
+
+    public function testCompletedJobReturnsCompletedStatus()
+    {
+        $token = \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob', null, true);
+        $this->worker->work(0);
+        $status = new \Resque\Job\Status($token);
+        $this->assertEquals(\Resque\Job\Status::STATUS_COMPLETE, $status->get());
+    }
+
+    public function testStatusIsNotTrackedWhenToldNotTo()
+    {
+        $token = \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob', null, false);
+        $status = new \Resque\Job\Status($token);
+        $this->assertFalse($status->isTracking());
+    }
+
+    public function testStatusTrackingCanBeStopped()
+    {
+        \Resque\Job\Status::create('test');
+        $status = new \Resque\Job\Status('test');
+        $this->assertEquals(\Resque\Job\Status::STATUS_WAITING, $status->get());
+        $status->stop();
+        $this->assertFalse($status->get());
+    }
+
+    public function testRecreatedJobWithTrackingStillTracksStatus()
+    {
+        $originalToken = \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob', null, true);
+        $job = $this->worker->reserve();
+
+        // Mark this job as being worked on to ensure that the new status is still
+        // waiting.
+        $this->worker->workingOn($job);
+
+        // Now recreate it
+        $newToken = $job->recreate();
+
+        // Make sure we've got a new job returned
+        $this->assertNotEquals($originalToken, $newToken);
+
+        // Now check the status of the new job
+        $newJob = \Resque\Job\Job::reserve('jobs');
+        $this->assertEquals(\Resque\Job\Status::STATUS_WAITING, $newJob->getStatus());
+    }
+}
--- a/tests/Resque/Tests/JobTest.php
+++ b/tests/Resque/Tests/JobTest.php
@ -0,0 +1,431 @@
+<?php
+
+namespace Resque\Test;
+
+/**
+ * ResqueJob tests.
+ *
+ * @package        Resque/Tests
+ * @author         Daniel Mason <daniel@m2.nz>
+ * @license        http://www.opensource.org/licenses/mit-license.php
+ */
+
+class JobTest extends TestCase
+{
+    protected $worker;
+
+    public function setUp(): void
+    {
+        parent::setUp();
+
+        // Register a worker to test with
+        $this->worker = new \Resque\Worker('jobs');
+        $this->worker->setLogger(new \Resque\Log());
+        $this->worker->registerWorker();
+    }
+
+    public function testJobCanBeQueued()
+    {
+        $this->assertTrue((bool)\Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob'));
+    }
+
+    public function testQeueuedJobCanBeReserved()
+    {
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob');
+
+        $job = \Resque\Job\Job::reserve('jobs');
+        if (is_null($job)) {
+            $this->fail('Job could not be reserved.');
+        }
+        $this->assertEquals('jobs', $job->queue);
+        $this->assertEquals('\Resque\Test\TestJob', $job->payload['class']);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testObjectArgumentsCannotBePassedToJob()
+    {
+        $this->expectException(\InvalidArgumentException::class);
+
+        $args = new \stdClass();
+        $args->test = 'somevalue';
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob', $args);
+    }
+
+    public function testQueuedJobReturnsExactSamePassedInArguments()
+    {
+        $args = [
+            'int' => 123,
+            'numArray' => [
+                1,
+                2,
+            ],
+            'assocArray' => [
+                'key1' => 'value1',
+                'key2' => 'value2'
+            ],
+        ];
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob', $args);
+        $job = \Resque\Job\Job::reserve('jobs');
+
+        $this->assertEquals($args, $job->getArguments());
+    }
+
+    public function testAfterJobIsReservedItIsRemoved()
+    {
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob');
+        \Resque\Job\Job::reserve('jobs');
+        $this->assertNull(\Resque\Job\Job::reserve('jobs'));
+    }
+
+    public function testRecreatedJobMatchesExistingJob()
+    {
+        $args = [
+            'int' => 123,
+            'numArray' => [
+                1,
+                2,
+            ],
+            'assocArray' => [
+                'key1' => 'value1',
+                'key2' => 'value2'
+            ],
+        ];
+
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob', $args);
+        $job = \Resque\Job\Job::reserve('jobs');
+
+        // Now recreate it
+        $job->recreate();
+
+        $newJob = \Resque\Job\Job::reserve('jobs');
+        $this->assertEquals($job->payload['class'], $newJob->payload['class']);
+        $this->assertEquals($job->getArguments(), $newJob->getArguments());
+    }
+
+
+    public function testFailedJobExceptionsAreCaught()
+    {
+        $payload = [
+            'class' => '\Resque\Test\FailingJob',
+            'args' => null
+        ];
+        $job = new \Resque\Job\Job('jobs', $payload);
+        $job->worker = $this->worker;
+
+        $this->worker->perform($job);
+
+        $this->assertEquals(1, \Resque\Stat::get('failed'));
+        $this->assertEquals(1, \Resque\Stat::get('failed:' . $this->worker));
+    }
+
+    /**
+     * @expectedException \Resque\Exception
+     */
+    public function testJobWithoutPerformMethodThrowsException()
+    {
+        $this->expectException(\Resque\Exception::class);
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob_Without_Perform_Method');
+        $job = $this->worker->reserve();
+        $job->worker = $this->worker;
+        $job->perform();
+    }
+
+    /**
+     * @expectedException \Resque\Exception
+     */
+    public function testInvalidJobThrowsException()
+    {
+        $this->expectException(\Resque\Exception::class);
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\InvalidJob');
+        $job = $this->worker->reserve();
+        $job->worker = $this->worker;
+        $job->perform();
+    }
+
+    public function testJobWithSetUpCallbackFiresSetUp()
+    {
+        $payload = [
+            'class' => '\Resque\Test\TestJobWithSetUp',
+            'args' => [
+                'somevar',
+                'somevar2',
+            ],
+        ];
+        $job = new \Resque\Job\Job('jobs', $payload);
+        $job->perform();
+
+        $this->assertTrue(TestJobWithSetUp::$called);
+    }
+
+    public function testJobWithTearDownCallbackFiresTearDown()
+    {
+        $payload = [
+            'class' => '\Resque\Test\TestJobWithTearDown',
+            'args' => [
+                'somevar',
+                'somevar2',
+            ],
+        ];
+        $job = new \Resque\Job\Job('jobs', $payload);
+        $job->perform();
+
+        $this->assertTrue(TestJobWithTearDown::$called);
+    }
+
+    public function testNamespaceNaming()
+    {
+        $fixture = [
+            ['test' => 'more:than:one:with:', 'assertValue' => 'more:than:one:with:'],
+            ['test' => 'more:than:one:without', 'assertValue' => 'more:than:one:without:'],
+            ['test' => 'resque', 'assertValue' => 'resque:'],
+            ['test' => 'resque:', 'assertValue' => 'resque:'],
+        ];
+
+        foreach ($fixture as $item) {
+            \Resque\Redis::prefix($item['test']);
+            $this->assertEquals(\Resque\Redis::getPrefix(), $item['assertValue']);
+        }
+    }
+
+    public function testJobWithNamespace()
+    {
+        \Resque\Redis::prefix('php');
+        $queue = 'jobs';
+        $payload = ['another_value'];
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobWithTearDown', $payload);
+
+        $this->assertEquals(\Resque\Resque::queues(), ['jobs']);
+        $this->assertEquals(\Resque\Resque::size($queue), 1);
+
+        \Resque\Redis::prefix('resque');
+        $this->assertEquals(\Resque\Resque::size($queue), 0);
+    }
+
+    public function testDequeueAll()
+    {
+        $queue = 'jobs';
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobDequeue');
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobDequeue');
+        $this->assertEquals(\Resque\Resque::size($queue), 2);
+        $this->assertEquals(\Resque\Resque::dequeue($queue), 2);
+        $this->assertEquals(\Resque\Resque::size($queue), 0);
+    }
+
+    public function testDequeueMakeSureNotDeleteOthers()
+    {
+        $queue = 'jobs';
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobDequeue');
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobDequeue');
+        $other_queue = 'other_jobs';
+        \Resque\Resque::enqueue($other_queue, '\Resque\Test\TestJobDequeue');
+        \Resque\Resque::enqueue($other_queue, '\Resque\Test\TestJobDequeue');
+        $this->assertEquals(\Resque\Resque::size($queue), 2);
+        $this->assertEquals(\Resque\Resque::size($other_queue), 2);
+        $this->assertEquals(\Resque\Resque::dequeue($queue), 2);
+        $this->assertEquals(\Resque\Resque::size($queue), 0);
+        $this->assertEquals(\Resque\Resque::size($other_queue), 2);
+    }
+
+    public function testDequeueSpecificItem()
+    {
+        $queue = 'jobs';
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobDequeue1');
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobDequeue2');
+        $this->assertEquals(\Resque\Resque::size($queue), 2);
+        $test = ['\Resque\Test\TestJobDequeue2'];
+        $this->assertEquals(\Resque\Resque::dequeue($queue, $test), 1);
+        $this->assertEquals(\Resque\Resque::size($queue), 1);
+    }
+
+    public function testDequeueSpecificMultipleItems()
+    {
+        $queue = 'jobs';
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJob_Dequeue1');
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJob_Dequeue2');
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJob_Dequeue3');
+        $this->assertEquals(\Resque\Resque::size($queue), 3);
+        $test = ['\Resque\Test\TestJob_Dequeue2', '\Resque\Test\TestJob_Dequeue3'];
+        $this->assertEquals(\Resque\Resque::dequeue($queue, $test), 2);
+        $this->assertEquals(\Resque\Resque::size($queue), 1);
+    }
+
+    public function testDequeueNonExistingItem()
+    {
+        $queue = 'jobs';
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJob_Dequeue1');
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJob_Dequeue2');
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJob_Dequeue3');
+        $this->assertEquals(\Resque\Resque::size($queue), 3);
+        $test = ['\Resque\Test\TestJob_Dequeue4'];
+        $this->assertEquals(\Resque\Resque::dequeue($queue, $test), 0);
+        $this->assertEquals(\Resque\Resque::size($queue), 3);
+    }
+
+    public function testDequeueNonExistingItem2()
+    {
+        $queue = 'jobs';
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJob_Dequeue1');
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJob_Dequeue2');
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJob_Dequeue3');
+        $this->assertEquals(\Resque\Resque::size($queue), 3);
+        $test = ['\Resque\Test\TestJob_Dequeue4', '\Resque\Test\TestJob_Dequeue1'];
+        $this->assertEquals(\Resque\Resque::dequeue($queue, $test), 1);
+        $this->assertEquals(\Resque\Resque::size($queue), 2);
+    }
+
+    public function testDequeueItemID()
+    {
+        $queue = 'jobs';
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJob_Dequeue');
+        $qid = \Resque\Resque::enqueue($queue, '\Resque\Test\TestJob_Dequeue');
+        $this->assertEquals(\Resque\Resque::size($queue), 2);
+        $test = ['\Resque\Test\TestJob_Dequeue' => $qid];
+        $this->assertEquals(\Resque\Resque::dequeue($queue, $test), 1);
+        $this->assertEquals(\Resque\Resque::size($queue), 1);
+    }
+
+    public function testDequeueWrongItemID()
+    {
+        $queue = 'jobs';
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJob_Dequeue');
+        $qid = \Resque\Resque::enqueue($queue, '\Resque\Test\TestJob_Dequeue');
+        $this->assertEquals(\Resque\Resque::size($queue), 2);
+        #qid right but class name is wrong
+        $test = ['\Resque\Test\TestJob_Dequeue1' => $qid];
+        $this->assertEquals(\Resque\Resque::dequeue($queue, $test), 0);
+        $this->assertEquals(\Resque\Resque::size($queue), 2);
+    }
+
+    public function testDequeueWrongItemID2()
+    {
+        $queue = 'jobs';
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJob_Dequeue');
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJob_Dequeue');
+        $this->assertEquals(\Resque\Resque::size($queue), 2);
+        $test = ['\Resque\Test\TestJob_Dequeue' => 'r4nD0mH4sh3dId'];
+        $this->assertEquals(\Resque\Resque::dequeue($queue, $test), 0);
+        $this->assertEquals(\Resque\Resque::size($queue), 2);
+    }
+
+    public function testDequeueItemWithArg()
+    {
+        $queue = 'jobs';
+        $arg = ['foo' => 1, 'bar' => 2];
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobDequeue9');
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobDequeue9', $arg);
+        $this->assertEquals(\Resque\Resque::size($queue), 2);
+        $test = ['\Resque\Test\TestJobDequeue9' => $arg];
+        $this->assertEquals(\Resque\Resque::dequeue($queue, $test), 1);
+        #$this->assertEquals(\Resque\Resque::size($queue), 1);
+    }
+
+    public function testDequeueSeveralItemsWithArgs()
+    {
+        // GIVEN
+        $queue = 'jobs';
+        $args = ['foo' => 1, 'bar' => 10];
+        $removeArgs = ['foo' => 1, 'bar' => 2];
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobDequeue9', $args);
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobDequeue9', $removeArgs);
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobDequeue9', $removeArgs);
+        $this->assertEquals(\Resque\Resque::size($queue), 3, "Failed to add 3 items.");
+
+        // WHEN
+        $test = ['\Resque\Test\TestJobDequeue9' => $removeArgs];
+        $removedItems = \Resque\Resque::dequeue($queue, $test);
+
+        // THEN
+        $this->assertEquals($removedItems, 2);
+        $this->assertEquals(\Resque\Resque::size($queue), 1);
+        $item = \Resque\Resque::pop($queue);
+        $this->assertIsArray($item['args']);
+        $this->assertEquals(10, $item['args'][0]['bar'], 'Wrong items were dequeued from queue!');
+    }
+
+    public function testDequeueItemWithUnorderedArg()
+    {
+        $queue = 'jobs';
+        $arg = ['foo' => 1, 'bar' => 2];
+        $arg2 = ['bar' => 2, 'foo' => 1];
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobDequeue');
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobDequeue', $arg);
+        $this->assertEquals(\Resque\Resque::size($queue), 2);
+        $test = ['\Resque\Test\TestJobDequeue' => $arg2];
+        $this->assertEquals(\Resque\Resque::dequeue($queue, $test), 1);
+        $this->assertEquals(\Resque\Resque::size($queue), 1);
+    }
+
+    public function testDequeueItemWithiWrongArg()
+    {
+        $queue = 'jobs';
+        $arg = ['foo' => 1, 'bar' => 2];
+        $arg2 = ['foo' => 2, 'bar' => 3];
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobDequeue');
+        \Resque\Resque::enqueue($queue, '\Resque\Test\TestJobDequeue', $arg);
+        $this->assertEquals(\Resque\Resque::size($queue), 2);
+        $test = ['\Resque\Test\TestJobDequeue' => $arg2];
+        $this->assertEquals(\Resque\Resque::dequeue($queue, $test), 0);
+        $this->assertEquals(\Resque\Resque::size($queue), 2);
+    }
+
+    public function testUseDefaultFactoryToGetJobInstance()
+    {
+        $payload = [
+            'class' => '\Resque\Test\SomeJobClass',
+            'args' => null
+        ];
+        $job = new \Resque\Job\Job('jobs', $payload);
+        $instance = $job->getInstance();
+        $this->assertInstanceOf('\Resque\Test\SomeJobClass', $instance);
+    }
+
+    public function testUseFactoryToGetJobInstance()
+    {
+        $payload = [
+            'class' => 'SomeJobClass',
+            'args' => [[]]
+        ];
+        $job = new \Resque\Job\Job('jobs', $payload);
+        $factory = new Some_Stub_Factory();
+        $job->setJobFactory($factory);
+        $instance = $job->getInstance();
+        $this->assertInstanceOf('\Resque\Job\JobInterface', $instance);
+    }
+}
+
+class SomeJobClass implements \Resque\Job\JobInterface
+{
+    public static $called = false;
+    public $args = false;
+    public $queue;
+    public $job;
+
+    /**
+     * @return bool
+     */
+    public function perform()
+    {
+        return true;
+    }
+}
+
+class Some_Stub_Factory implements \Resque\Job\FactoryInterface
+{
+    public static $called = false;
+    public $args = false;
+    public $queue;
+    public $job;
+
+    /**
+     * @param $className
+     * @param array $args
+     * @param $queue
+     * @return \Resque\Job\JobInterface
+     */
+    public function create($className, $args, $queue)
+    {
+        return new SomeJobClass();
+    }
+}
--- a/tests/Resque/Tests/LogTest.php
+++ b/tests/Resque/Tests/LogTest.php
@ -1,18 +1,20 @@
 <?php

+namespace Resque\Test;
+
 /**
- * Resque_Log tests.
+ * \Resque\Log tests.
 *
 * @package        Resque/Tests
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */

-class Resque_Tests_LogTest extends Resque_Tests_TestCase
+class LogTest extends TestCase
 {
    public function testLogInterpolate()
    {
-        $logger = new Resque_Log();
+        $logger = new \Resque\Log();
        $actual = $logger->interpolate('string {replace}', ['replace' => 'value']);
        $expected = 'string value';

@ -21,7 +23,7 @@ class Resque_Tests_LogTest extends Resque_Tests_TestCase

    public function testLogInterpolateMutiple()
    {
-        $logger = new Resque_Log();
+        $logger = new \Resque\Log();
        $actual = $logger->interpolate(
            'string {replace1} {replace2}',
            ['replace1' => 'value1', 'replace2' => 'value2']
--- a/tests/Resque/Tests/RedisTest.php
+++ b/tests/Resque/Tests/RedisTest.php
@ -1,18 +1,25 @@
 <?php

+namespace Resque\Test;
+
 /**
 * Resque_Event tests.
 *
 * @package        Resque/Tests
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */

-class Resque_Tests_RedisTest extends Resque_Tests_TestCase
+class RedisTest extends TestCase
 {
    public function testRedisGetSet()
    {
-        $this->redis->set("testKey", 24);
+        $this->redis->set(
+            'testKey',
+            24,
+            ['ex' => \Resque\Redis::DEFAULT_REDIS_TTL],
+        );
+
        $val = $this->redis->get("testKey");
        $this->assertEquals(24, $val);
    }
@ -28,14 +35,14 @@ class Resque_Tests_RedisTest extends Resque_Tests_TestCase
            // Input , Expected output
            ['', [
                'localhost',
-                Resque_Redis::DEFAULT_PORT,
+                \Resque\Redis::DEFAULT_PORT,
                false,
                false, false,
                [],
            ]],
            ['localhost', [
                'localhost',
-                Resque_Redis::DEFAULT_PORT,
+                \Resque\Redis::DEFAULT_PORT,
                false,
                false, false,
                [],
@ -56,14 +63,14 @@ class Resque_Tests_RedisTest extends Resque_Tests_TestCase
            ]],
            ['redis://foobar', [
                'foobar',
-                Resque_Redis::DEFAULT_PORT,
+                \Resque\Redis::DEFAULT_PORT,
                false,
                false, false,
                [],
            ]],
            ['redis://foobar/', [
                'foobar',
-                Resque_Redis::DEFAULT_PORT,
+                \Resque\Redis::DEFAULT_PORT,
                false,
                false, false,
                [],
@ -175,18 +182,20 @@ class Resque_Tests_RedisTest extends Resque_Tests_TestCase
     */
    public function testParsingValidDsnString($dsn, $expected)
    {
-        $result = Resque_Redis::parseDsn($dsn);
+        $result = \Resque\Redis::parseDsn($dsn);
        $this->assertEquals($expected, $result);
    }

    /**
     * @dataProvider bogusDsnStringProvider
-     * @expectedException InvalidArgumentException
+     *
+     * @expectedException \InvalidArgumentException
+     *
     * @param $dsn
     */
    public function testParsingBogusDsnStringThrowsException($dsn)
    {
-        // The next line should throw an InvalidArgumentException
-        Resque_Redis::parseDsn($dsn);
+        $this->expectException(\InvalidArgumentException::class);
+        \Resque\Redis::parseDsn($dsn);
    }
 }
--- a/tests/Resque/Tests/StatTest.php
+++ b/tests/Resque/Tests/StatTest.php
@ -1,51 +1,53 @@
 <?php

+namespace Resque\Test;
+
 /**
- * Resque_Stat tests.
+ * Resque\Stat tests.
 *
 * @package        Resque/Tests
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */

-class Resque_Tests_StatTest extends Resque_Tests_TestCase
+class StatTest extends TestCase
 {
    public function testStatCanBeIncremented()
    {
-        Resque_Stat::incr('test_incr');
-        Resque_Stat::incr('test_incr');
+        \Resque\Stat::incr('test_incr');
+        \Resque\Stat::incr('test_incr');
        $this->assertEquals(2, $this->redis->get('resque:stat:test_incr'));
    }

    public function testStatCanBeIncrementedByX()
    {
-        Resque_Stat::incr('test_incrX', 10);
-        Resque_Stat::incr('test_incrX', 11);
+        \Resque\Stat::incr('test_incrX', 10);
+        \Resque\Stat::incr('test_incrX', 11);
        $this->assertEquals(21, $this->redis->get('resque:stat:test_incrX'));
    }

    public function testStatCanBeDecremented()
    {
-        Resque_Stat::incr('test_decr', 22);
-        Resque_Stat::decr('test_decr');
+        \Resque\Stat::incr('test_decr', 22);
+        \Resque\Stat::decr('test_decr');
        $this->assertEquals(21, $this->redis->get('resque:stat:test_decr'));
    }

    public function testStatCanBeDecrementedByX()
    {
-        Resque_Stat::incr('test_decrX', 22);
-        Resque_Stat::decr('test_decrX', 11);
+        \Resque\Stat::incr('test_decrX', 22);
+        \Resque\Stat::decr('test_decrX', 11);
        $this->assertEquals(11, $this->redis->get('resque:stat:test_decrX'));
    }

    public function testGetStatByName()
    {
-        Resque_Stat::incr('test_get', 100);
-        $this->assertEquals(100, Resque_Stat::get('test_get'));
+        \Resque\Stat::incr('test_get', 100);
+        $this->assertEquals(100, \Resque\Stat::get('test_get'));
    }

    public function testGetUnknownStatReturns0()
    {
-        $this->assertEquals(0, Resque_Stat::get('test_get_unknown'));
+        $this->assertEquals(0, \Resque\Stat::get('test_get_unknown'));
    }
 }
--- a/tests/Resque/Tests/TestCase.php
+++ b/tests/Resque/Tests/TestCase.php
@ -1,28 +1,31 @@
 <?php

+namespace Resque\Test;
+
 /**
 * Resque test case class. Contains setup and teardown methods.
 *
 * @package        Resque/Tests
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */
-
-class Resque_Tests_TestCase extends PHPUnit\Framework\TestCase
+class TestCase extends \PHPUnit\Framework\TestCase
 {
    protected $resque;
    protected $redis;

-    public static function setUpBeforeClass()
+    public static function setUpBeforeClass(): void
    {
        date_default_timezone_set('UTC');
    }

-    public function setUp()
+    public function setUp(): void
    {
        // Setup redis connection for testing.
-        $this->redis = new Credis_Client('localhost', '6379');
-        Resque::setBackend('localhost');
+        global $redisTestServer;
+
+        $this->redis = new \Credis_Client($redisTestServer, '6379');
+        \Resque\Resque::setBackend($redisTestServer);
        $this->redis->flushAll();
    }
 }
--- a/tests/Resque/Tests/WorkerTest.php
+++ b/tests/Resque/Tests/WorkerTest.php
@ -1,19 +1,21 @@
 <?php

+namespace Resque\Test;
+
 /**
- * Resque_Worker tests.
+ * \Resque\Worker tests.
 *
 * @package        Resque/Tests
- * @author        Chris Boulton <chris@bigcommerce.com>
+ * @author         Daniel Mason <daniel@m2.nz>
 * @license        http://www.opensource.org/licenses/mit-license.php
 */

-class Resque_Tests_WorkerTest extends Resque_Tests_TestCase
+class WorkerTest extends TestCase
 {
    public function testWorkerRegistersInList()
    {
-        $worker = new Resque_Worker('*');
-        $worker->setLogger(new Resque_Log());
+        $worker = new \Resque\Worker('*');
+        $worker->setLogger(new \Resque\Log());
        $worker->registerWorker();

        // Make sure the worker is in the list
@ -25,76 +27,76 @@ class Resque_Tests_WorkerTest extends Resque_Tests_TestCase
        $num = 3;
        // Register a few workers
        for ($i = 0; $i < $num; ++$i) {
-            $worker = new Resque_Worker('queue_' . $i);
-            $worker->setLogger(new Resque_Log());
+            $worker = new \Resque\Worker('queue_' . $i);
+            $worker->setLogger(new \Resque\Log());
            $worker->registerWorker();
        }

        // Now try to get them
-        $this->assertEquals($num, count(Resque_Worker::all()));
+        $this->assertEquals($num, count(\Resque\Worker::all()));
    }

    public function testGetWorkerById()
    {
-        $worker = new Resque_Worker('*');
-        $worker->setLogger(new Resque_Log());
+        $worker = new \Resque\Worker('*');
+        $worker->setLogger(new \Resque\Log());
        $worker->registerWorker();

-        $newWorker = Resque_Worker::find((string)$worker);
+        $newWorker = \Resque\Worker::find((string)$worker);
        $this->assertEquals((string)$worker, (string)$newWorker);
    }

    public function testInvalidWorkerDoesNotExist()
    {
-        $this->assertFalse(Resque_Worker::exists('blah'));
+        $this->assertFalse(\Resque\Worker::exists('blah'));
    }

    public function testWorkerCanUnregister()
    {
-        $worker = new Resque_Worker('*');
-        $worker->setLogger(new Resque_Log());
+        $worker = new \Resque\Worker('*');
+        $worker->setLogger(new \Resque\Log());
        $worker->registerWorker();
        $worker->unregisterWorker();

-        $this->assertFalse(Resque_Worker::exists((string)$worker));
-        $this->assertEquals([], Resque_Worker::all());
+        $this->assertFalse(\Resque\Worker::exists((string)$worker));
+        $this->assertEquals([], \Resque\Worker::all());
        $this->assertEquals([], $this->redis->smembers('resque:workers'));
    }

    public function testPausedWorkerDoesNotPickUpJobs()
    {
-        $worker = new Resque_Worker('*');
-        $worker->setLogger(new Resque_Log());
+        $worker = new \Resque\Worker('*');
+        $worker->setLogger(new \Resque\Log());
        $worker->pauseProcessing();
-        Resque::enqueue('jobs', 'Test_Job');
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob');
        $worker->work(0);
        $worker->work(0);
-        $this->assertEquals(0, Resque_Stat::get('processed'));
+        $this->assertEquals(0, \Resque\Stat::get('processed'));
    }

    public function testResumedWorkerPicksUpJobs()
    {
-        $worker = new Resque_Worker('*');
-        $worker->setLogger(new Resque_Log());
+        $worker = new \Resque\Worker('*');
+        $worker->setLogger(new \Resque\Log());
        $worker->pauseProcessing();
-        Resque::enqueue('jobs', 'Test_Job');
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob');
        $worker->work(0);
-        $this->assertEquals(0, Resque_Stat::get('processed'));
+        $this->assertEquals(0, \Resque\Stat::get('processed'));
        $worker->unPauseProcessing();
        $worker->work(0);
-        $this->assertEquals(1, Resque_Stat::get('processed'));
+        $this->assertEquals(1, \Resque\Stat::get('processed'));
    }

    public function testWorkerCanWorkOverMultipleQueues()
    {
-        $worker = new Resque_Worker([
+        $worker = new \Resque\Worker([
            'queue1',
            'queue2'
        ]);
-        $worker->setLogger(new Resque_Log());
+        $worker->setLogger(new \Resque\Log());
        $worker->registerWorker();
-        Resque::enqueue('queue1', 'Test_Job_1');
-        Resque::enqueue('queue2', 'Test_Job_2');
+        \Resque\Resque::enqueue('queue1', '\Resque\Test\TestJob_1');
+        \Resque\Resque::enqueue('queue2', '\Resque\Test\TestJob_2');

        $job = $worker->reserve();
        $this->assertEquals('queue1', $job->queue);
@ -105,18 +107,18 @@ class Resque_Tests_WorkerTest extends Resque_Tests_TestCase

    public function testWorkerWorksQueuesInSpecifiedOrder()
    {
-        $worker = new Resque_Worker([
+        $worker = new \Resque\Worker([
            'high',
            'medium',
            'low'
        ]);
-        $worker->setLogger(new Resque_Log());
+        $worker->setLogger(new \Resque\Log());
        $worker->registerWorker();

        // Queue the jobs in a different order
-        Resque::enqueue('low', 'Test_Job_1');
-        Resque::enqueue('high', 'Test_Job_2');
-        Resque::enqueue('medium', 'Test_Job_3');
+        \Resque\Resque::enqueue('low', '\Resque\Test\TestJob_1');
+        \Resque\Resque::enqueue('high', '\Resque\Test\TestJob_2');
+        \Resque\Resque::enqueue('medium', '\Resque\Test\TestJob_3');

        // Now check we get the jobs back in the right order
        $job = $worker->reserve();
@ -131,12 +133,12 @@ class Resque_Tests_WorkerTest extends Resque_Tests_TestCase

    public function testWildcardQueueWorkerWorksAllQueues()
    {
-        $worker = new Resque_Worker('*');
-        $worker->setLogger(new Resque_Log());
+        $worker = new \Resque\Worker('*');
+        $worker->setLogger(new \Resque\Log());
        $worker->registerWorker();

-        Resque::enqueue('queue1', 'Test_Job_1');
-        Resque::enqueue('queue2', 'Test_Job_2');
+        \Resque\Resque::enqueue('queue1', '\Resque\Test\TestJob_1');
+        \Resque\Resque::enqueue('queue2', '\Resque\Test\TestJob_2');

        $job = $worker->reserve();
        $this->assertEquals('queue1', $job->queue);
@ -147,19 +149,19 @@ class Resque_Tests_WorkerTest extends Resque_Tests_TestCase

    public function testWorkerDoesNotWorkOnUnknownQueues()
    {
-        $worker = new Resque_Worker('queue1');
-        $worker->setLogger(new Resque_Log());
+        $worker = new \Resque\Worker('queue1');
+        $worker->setLogger(new \Resque\Log());
        $worker->registerWorker();
-        Resque::enqueue('queue2', 'Test_Job');
+        \Resque\Resque::enqueue('queue2', '\Resque\Test\TestJob');

        $this->assertFalse($worker->reserve());
    }

    public function testWorkerClearsItsStatusWhenNotWorking()
    {
-        Resque::enqueue('jobs', 'Test_Job');
-        $worker = new Resque_Worker('jobs');
-        $worker->setLogger(new Resque_Log());
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob');
+        $worker = new \Resque\Worker('jobs');
+        $worker->setLogger(new \Resque\Log());
        $job = $worker->reserve();
        $worker->workingOn($job);
        $worker->doneWorking();
@ -168,14 +170,14 @@ class Resque_Tests_WorkerTest extends Resque_Tests_TestCase

    public function testWorkerRecordsWhatItIsWorkingOn()
    {
-        $worker = new Resque_Worker('jobs');
-        $worker->setLogger(new Resque_Log());
+        $worker = new \Resque\Worker('jobs');
+        $worker->setLogger(new \Resque\Log());
        $worker->registerWorker();

        $payload = [
-            'class' => 'Test_Job'
+            'class' => '\Resque\Test\TestJob'
        ];
-        $job = new Resque_Job('jobs', $payload);
+        $job = new \Resque\Job\Job('jobs', $payload);
        $worker->workingOn($job);

        $job = $worker->job();
@ -188,14 +190,17 @@ class Resque_Tests_WorkerTest extends Resque_Tests_TestCase

    public function testWorkerErasesItsStatsWhenShutdown()
    {
-        Resque::enqueue('jobs', 'Test_Job');
-        Resque::enqueue('jobs', 'Invalid_Job');
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob');
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\InvalidJob');

-        $worker = new Resque_Worker('jobs');
-        $worker->setLogger(new Resque_Log());
+        $worker = new \Resque\Worker('jobs');
+        $worker->setLogger(new \Resque\Log());
        $worker->work(0);
        $worker->work(0);

+        // Allow time for async unlink to work
+        sleep(2);
+
        $this->assertEquals(0, $worker->getStat('processed'));
        $this->assertEquals(0, $worker->getStat('failed'));
    }
@ -203,87 +208,84 @@ class Resque_Tests_WorkerTest extends Resque_Tests_TestCase
    public function testWorkerCleansUpDeadWorkersOnStartup()
    {
        // Register a good worker
-        $goodWorker = new Resque_Worker('jobs');
-        $goodWorker->setLogger(new Resque_Log());
+        $goodWorker = new \Resque\Worker('jobs');
+        $goodWorker->setLogger(new \Resque\Log());
        $goodWorker->registerWorker();
        $workerId = explode(':', $goodWorker);

        // Register some bad workers
-        $worker = new Resque_Worker('jobs');
-        $worker->setLogger(new Resque_Log());
+        $worker = new \Resque\Worker('jobs');
+        $worker->setLogger(new \Resque\Log());
        $worker->setId($workerId[0] . ':1:jobs');
        $worker->registerWorker();

-        $worker = new Resque_Worker(['high', 'low']);
-        $worker->setLogger(new Resque_Log());
+        $worker = new \Resque\Worker(['high', 'low']);
+        $worker->setLogger(new \Resque\Log());
        $worker->setId($workerId[0] . ':2:high,low');
        $worker->registerWorker();

-        $this->assertEquals(3, count(Resque_Worker::all()));
+        $this->assertEquals(3, count(\Resque\Worker::all()));

        $goodWorker->pruneDeadWorkers();

        // There should only be $goodWorker left now
-        $this->assertEquals(1, count(Resque_Worker::all()));
+        $this->assertEquals(1, count(\Resque\Worker::all()));
    }

    public function testDeadWorkerCleanUpDoesNotCleanUnknownWorkers()
    {
        // Register a bad worker on this machine
-        $worker = new Resque_Worker('jobs');
-        $worker->setLogger(new Resque_Log());
+        $worker = new \Resque\Worker('jobs');
+        $worker->setLogger(new \Resque\Log());
        $workerId = explode(':', $worker);
        $worker->setId($workerId[0] . ':1:jobs');
        $worker->registerWorker();

        // Register some other false workers
-        $worker = new Resque_Worker('jobs');
-        $worker->setLogger(new Resque_Log());
+        $worker = new \Resque\Worker('jobs');
+        $worker->setLogger(new \Resque\Log());
        $worker->setId('my.other.host:1:jobs');
        $worker->registerWorker();

-        $this->assertEquals(2, count(Resque_Worker::all()));
+        $this->assertEquals(2, count(\Resque\Worker::all()));

        $worker->pruneDeadWorkers();

        // my.other.host should be left
-        $workers = Resque_Worker::all();
+        $workers = \Resque\Worker::all();
        $this->assertEquals(1, count($workers));
        $this->assertEquals((string)$worker, (string)$workers[0]);
    }

    public function testWorkerFailsUncompletedJobsOnExit()
    {
-        $worker = new Resque_Worker('jobs');
-        $worker->setLogger(new Resque_Log());
+        $worker = new \Resque\Worker('jobs');
+        $worker->setLogger(new \Resque\Log());
        $worker->registerWorker();

        $payload = [
-            'class' => 'Test_Job'
+            'class' => '\Resque\Test\TestJob'
        ];
-        $job = new Resque_Job('jobs', $payload);
+        $job = new \Resque\Job\Job('jobs', $payload);

        $worker->workingOn($job);
        $worker->unregisterWorker();

-        $this->assertEquals(1, Resque_Stat::get('failed'));
+        $this->assertEquals(1, \Resque\Stat::get('failed'));
    }

    public function testBlockingListPop()
    {
-        $this->markTestSkipped("Skip temporarily");
-        return;
-
-        $worker = new Resque_Worker('jobs');
-        $worker->setLogger(new Resque_Log());
+        $worker = new \Resque\Worker('jobs');
+        $worker->setLogger(new \Resque\Log());
        $worker->registerWorker();

-        Resque::enqueue('jobs', 'Test_Job_1');
-        Resque::enqueue('jobs', 'Test_Job_2');
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob_1');
+        \Resque\Resque::enqueue('jobs', '\Resque\Test\TestJob_2');

        $i = 1;
        while ($job = $worker->reserve(true, 2)) {
-            $this->assertEquals('Test_Job_' . $i, $job->payload['class']);
+            $this->assertEquals('\Resque\Test\TestJob_' . $i, $job->payload['class']);

            if ($i == 2) {
                break;
--- a/tests/bootstrap.php
+++ b/tests/bootstrap.php
@ -0,0 +1,102 @@
+<?php
+
+namespace Resque\Test;
+
+/**
+ * Resque test bootstrap file - sets up a test environment.
+ *
+ * @package        Resque/Tests
+ * @author         Daniel Mason <daniel@m2.nz>
+ * @license        http://www.opensource.org/licenses/mit-license.php
+ */
+
+$loader = require __DIR__ . '/../vendor/autoload.php';
+
+# Redis configuration
+global $redisTestServer;
+$redisTestServer = getenv("REDIS_SERVER") ?: "redis";
+\Resque\Resque::setBackend($redisTestServer);
+
+# Check Redis is accessable locally
+try {
+    $redisTest = new \Resque\Redis($redisTestServer);
+} catch (\Exception $e) {
+    throw new \Exception("Unable to connect to redis. Please check there is a redis-server running.");
+}
+$redisTest = null;
+
+# Cleanup forked workers cleanly
+if (function_exists('pcntl_signal')) {
+    pcntl_signal(SIGINT, function() { exit; });
+    pcntl_signal(SIGTERM, function() { exit; });
+}
+
+# Bootstrap it
+class TestJob
+{
+    public static $called = false;
+    public $args = false;
+    public $queue;
+    public $job;
+
+    public function perform()
+    {
+        self::$called = true;
+    }
+}
+
+class FailingJobException extends \Exception
+{
+}
+
+class FailingJob
+{
+    public static $called = false;
+    public $args = false;
+    public $queue;
+    public $job;
+
+    public function perform()
+    {
+        throw new FailingJobException('Message!');
+    }
+}
+
+class TestJobWithoutPerformMethod
+{
+}
+
+class TestJobWithSetUp
+{
+    public static $called = false;
+    public $args = false;
+    public $queue;
+    public $job;
+
+    public function setUp()
+    {
+        self::$called = true;
+    }
+
+    public function perform()
+    {
+    }
+}
+
+
+class TestJobWithTearDown
+{
+    public static $called = false;
+    public $args = false;
+    public $queue;
+    public $job;
+
+    public function perform()
+    {
+    }
+
+    public function tearDown()
+    {
+        self::$called = true;
+    }
+}
Author	SHA1	Message	Date
Daniel Mason	aad9334fba	2.5.3 - Update LOG() Some checks failed CI / Linter (push) Has been cancelled Details CI / PHPTest (8.1) (push) Has been cancelled Details CI / PHPTest (8.2) (push) Has been cancelled Details CI / PHPTest (8.3) (push) Has been cancelled Details CI / PHPTest (8.4) (push) Has been cancelled Details	2025-06-08 15:20:22 +12:00
Daniel Mason	b9042358e1	v2.5.2 add support for psr/log ^1	2025-06-08 14:21:33 +12:00
Daniel Mason	eb3395645f	v2.5.1 - Update psr/log reqs Some checks are pending CI / Linter (push) Waiting to run Details CI / PHPTest (8.1) (push) Waiting to run Details CI / PHPTest (8.2) (push) Waiting to run Details CI / PHPTest (8.3) (push) Waiting to run Details CI / PHPTest (8.4) (push) Waiting to run Details	2025-06-08 13:59:27 +12:00
Daniel Mason	e3ac97920c	v2.5.0 - Update packages/docs	2025-06-08 13:49:16 +12:00
idanoo	81fe761577	v3.4.0 - Update packages	2024-12-11 14:31:58 +13:00
Daniel Mason	2c995bd613	v2.3.0 - Update packages	2024-09-04 18:50:32 +12:00
Daniel Mason	5ef4a63a6e	2.2.0 (2023-03-20) - Update pacakges - Bump requirements to PHP >= 8.1	2024-03-20 19:03:55 +13:00
Daniel Mason	948b758a57	2.1.3 (2023-11-15) - Resolved issue with SET EX TTL's using unix-timestamps	2023-11-15 09:52:10 +13:00
Daniel Mason	0b925b68bd	Merge pull request #1 from idanoo/action_test 2.1.2 (2023-03-22) - Composer update / Update git information (GitHub)	2023-03-22 12:13:26 +13:00
Daniel Mason	575509ff53	2.1.2 (2023-03-22) - Update composer packages - Update git information (GitHub)	2023-03-22 12:10:33 +13:00
Daniel Mason	c696723fd0	Fix linter	2023-03-20 10:46:18 +13:00
Daniel Mason	6737df5925	Add sleep for tests	2023-03-20 10:44:47 +13:00
Daniel Mason	94cae8d271	2.1.1 (2023-03-20) - Update setex to set, add TTL to stats	2023-03-20 09:26:45 +13:00
Daniel Mason	679394eb5f	- Add PHP 8.1 / 8.2 unit tests - Updated code to be PHP 8.2 compliant	2023-02-07 15:20:03 +13:00
Daniel Mason	3c7e20e364	2.1.0 (2023-02-07) - PHP 8.2 compatibility	2023-02-07 02:19:09 +00:00
idanoo	ef82313d4e	Update	2023-02-07 14:34:41 +13:00
idanoo	ba52eb34c7	Update gitlab CI	2023-02-07 14:26:15 +13:00
idanoo	6458563051	Unit test PHP8.2	2023-02-07 14:18:40 +13:00
idanoo	05cae402b5	2.0.3 (2022-09-12) - Update composer packages - Added WoodpeckerCI tests - Updated links in composer package - Stricter typing	2022-09-12 19:50:02 +12:00
Daniel Mason	f9a22e7b8a	Bump resque version constant	2022-02-15 10:53:18 +13:00
Daniel Mason	655273ce78	Merge branch 'dev-2.0.2' into 'master' 2.0.2 (2022-02-15) See merge request idanoo/php-resque!2	2022-02-14 21:36:34 +00:00
Daniel Mason	ac044747aa	2.0.2 (2022-02-15) - Replace strftime with strtotime for PHP8.1 support - Added processing class into proc line for easier debugging	2022-02-15 10:12:16 +13:00
Daniel Mason	3d869bf653	Merge branch 'dev-2.0.1' into 'master' 2.0.1 See merge request idanoo/php-resque!1	2022-02-08 06:33:49 +00:00
Daniel Mason	dd0bb8947f	Update composer	2022-02-08 19:30:15 +13:00
idanoo	80d64e79ff	2.0.0 Add namespacing + PHP8.0 support (#1 ) 2.0.0 (2021-02-19) Moved to PSR-4 Namespaced codebase Added more comments throughout Co-Authored-By: idanoo <daniel@m2.nz> Co-Committed-By: idanoo <daniel@m2.nz>	2021-02-19 12:23:32 +13:00
Daniel Mason	ebec2f7bf7	Merge branch 'dev' into 'master' Update for PHP7.4 compatibility + PHPUnit 9 See merge request idanoo/php-resque!2	2020-04-10 21:59:55 +00:00
Daniel Mason	b99217f2c0	Update for PHP7.4 compatibility + UnitTests	2020-04-11 09:48:04 +12:00
Daniel Mason	493c12846a	Switched IF Statement order to prevent excess calls to redis.	2020-01-10 11:35:56 +13:00
Daniel Mason	19f21219f8	1.4.5 patch - formatting + composer replace	2019-08-28 10:06:52 +12:00
Daniel Mason	5a94c021da	Fix paths	2019-06-02 23:21:25 +12:00
Daniel Mason	3b4d2e4c1f	Fix bootstrap.php for tests	2019-06-02 22:54:15 +12:00
Daniel Mason	d702f498bf	Remove phpredis	2019-05-31 11:52:23 +12:00
Daniel Mason	70090b4d66	.gitlab-ci.yml ordering	2019-05-31 11:51:06 +12:00
Daniel Mason	6bedeaab5f	php-redis != phpredis	2019-05-31 11:50:32 +12:00
Daniel Mason	d76fd1a7e0	Tag != Tags	2019-05-31 11:49:08 +12:00
Daniel Mason	4a396bdb78	Tidying up GitLab CI file	2019-05-31 11:47:42 +12:00
Daniel Mason	939f4e58a6	Add redis to docker_install.sh	2018-10-13 12:55:06 +13:00
Daniel Mason	6232aff129	Add gitlab CI file	2018-10-13 12:53:14 +13:00
Daniel Mason	9a97a29aa3	Re-added disabled test	2018-10-13 12:45:53 +13:00