proxy-rotator-js 1.0.0

package/README.md

@@ -0,0 +1,146 @@
+Proxy Rotator
+=======
+#### 
+
+
+## Introduction
+
+ProxyRotator is a JavaScript class that provides a mechanism for managing a pool of proxies and rotating them based on their availability and status.
+
+## Installation
+```
+npm install proxy-rotator
+```
+
+## Properties
+
+    pool: Represents the pool of proxies as a queue.
+
+    graveyard: Stores proxies that are currently dead or inactive.
+
+## Usage
+
+```javascript
+
+import ProxyRoulette from 'proxy-rotator'
+
+let proxies = ['proxy1', 'proxy2', 'proxy3']
+
+let rotator = ProxyRotator(proxies, options={})
+
+console.log( rotator.next() ) // 'proxy1'
+console.log( rotator.next() ) // 'proxy2'
+```
+
+Initializes a new instance of ProxyRotator with the given proxies and options. The proxies parameter can be a file path or an array of proxies. The options parameter allows customization of various settings such as revive timer, shuffling, protocol assumption, and more.
+Methods
+
+## Methods 
+
+```javascript
+next() // Rotates the proxy by moving the front proxy to the end of the pool and returns it.
+
+add(proxies) // Adds one or more proxies to the pool.
+
+getAlive() //  Retrieves a random alive proxy from the pool.
+
+setAlive(proxy) // Sets a specific proxy to an alive state.
+
+setDead(proxy) // Sets a specific proxy to a dead state and moves it to the graveyard.
+
+resurrect(proxy) // Moves a proxy from the graveyard back to the pool.
+
+getPool() // Returns an array of proxies in the pool.
+
+getPoolSize() // Returns the number of proxies in the pool.
+
+getGraveyard() // Returns an array of proxies in the graveyard (dead proxies).
+
+getGraveyardSize() // Returns the number of proxies in the graveyard.
+
+remove(proxy) // Removes one or more proxies from the pool.
+```
+
+## Getting Started
+
+To use the ProxyRotator class in your JavaScript project, follow these steps:
+
+    Make sure you have Node.js  and npm installed on your system. 
+
+```javascript
+npm install proxy-rotator
+```
+
+Import the ProxyRotator class into your JavaScript file using the following line of code:
+
+```javascript
+
+import ProxyRotator from './ProxyRotator.js';
+```
+
+    Create an instance of ProxyRotator by calling the constructor and providing the required parameters. For example:
+
+```javascript
+
+const proxies = ['proxy1:8000', 'proxy2:322', 'proxy3:543'];
+const rotator = new ProxyRotator(proxies);
+
+```
+
+    Access the properties and methods of the ProxyRotator object using dot notation. For example:
+
+```javascript
+
+rotator.next();
+// 'proxy1:500'
+const poolSize = proxyRotator.getPoolSize();
+// 3
+const aliveProxy = proxyRotator.getAlive();
+// 'proxy2:500'
+proxyRotator.setAlive( 'proxy2:500' );
+// null 
+```
+
+### Examples
+
+
+```javascript
+
+import ProxyRotator from './ProxyRotator.js';
+
+// Create an instance of ProxyRotator
+const proxies = ['proxy1', 'proxy2', 'proxy3'];
+const options = { revive_timer: 1800000, shuffle: true };
+const proxyRotator = new ProxyRotator(proxies, options);
+
+// Access the properties
+console.log(proxyRotator.getGraveyard());  // Output: []
+console.log(proxyRotator.getGraveyardSize());  // Output: 0
+console.log(proxyRotator.getPool());  // Output: ['proxy1', 'proxy2', 'proxy3']
+console.log(proxyRotator.getPoolSize());  // Output: 3
+
+// Call the methods
+proxyRotator.add('proxy4');
+console.log(proxyRotator.getPool());  // Output: ['proxy1', 'proxy2', 'proxy3', 'proxy4']
+proxyRotator.remove('proxy2');
+console.log(proxyRotator.getPool());  // Output: ['proxy1', 'proxy3', 'proxy4']
+const aliveProxy = proxyRotator.getAlive();
+console.log(aliveProxy);  // Output: 'proxy1'
+proxyRotator.setAlive('proxy3');
+proxyRotator.next(); // prox1
+proxyRotator.next(); // prox3
+proxyRotator.next(); // prox4
+console.log(proxyRotator.getPool());  // Output: ['proxy1', 'proxy4', 'proxy3']
+```
+
+### Contributing
+
+If you would like to contribute to the ProxyRotator project, you can fork the repository and make your desired changes. Feel free to submit a pull request with your improvements or bug fixes. We appreciate your contributions!
+License
+
+The ProxyRotator class is released under the MIT License. You can freely use and modify it in your projects. Please refer to the license file for more information.
+Contact
+
+If you have any questions, suggestions, or feedback regarding the ProxyRotator class, please me =) Goran Topic @  telegonicaxx@live.com. We appreciate your input and are happy to assist you.
+
+Thank you for using the ProxyRotator class. We hope it helps simplify your proxy management and rotation tasks.

package/assets/http_proxies_with_commas.txt

@@ -0,0 +1 @@
+139.59.1.14:8080, 94.45.74.60:8080, 161.35.70.249:3128, 217.182.170.224:80, 222.138.76.6:9002, 218.252.206.89:80, 18.214.66.210:80, 120.234.203.171:9002

package/assets/http_proxies_with_newlines.txt

@@ -0,0 +1,8 @@
+139.59.1.14:8080
+94.45.74.60:8080
+161.35.70.249:3128
+217.182.170.224:80
+222.138.76.6:9002
+218.252.206.89:80
+18.214.66.210:80
+120.234.203.171:9002

package/assets/http_proxies_with_spaces.txt

@@ -0,0 +1 @@
+139.59.1.14:8080 94.45.74.60:8080 161.35.70.249:3128 217.182.170.224:80 222.138.76.6:9002 218.252.206.89:80 18.214.66.210:80 120.234.203.171:9002

package/index.js

@@ -0,0 +1,2 @@
+import ProxyRotator from './src/ProxyRotator.js'
+export default ProxyRotator

package/package.json

@@ -0,0 +1,104 @@
+{
+  "name": "proxy-rotator-js",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Proxy Rotator",
+  "main": "index.js",
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "ansi-colors": "^4.1.1",
+    "ansi-regex": "^5.0.1",
+    "ansi-styles": "^4.3.0",
+    "anymatch": "^3.1.3",
+    "argparse": "^2.0.1",
+    "assertion-error": "^1.1.0",
+    "balanced-match": "^1.0.2",
+    "binary-extensions": "^2.2.0",
+    "brace-expansion": "^2.0.1",
+    "braces": "^3.0.2",
+    "browser-stdout": "^1.3.1",
+    "camelcase": "^6.3.0",
+    "chai": "^4.3.7",
+    "chalk": "^4.1.2",
+    "check-error": "^1.0.2",
+    "chokidar": "^3.5.3",
+    "cliui": "^7.0.4",
+    "color-convert": "^2.0.1",
+    "color-name": "^1.1.4",
+    "concat-map": "^0.0.1",
+    "debug": "^4.3.4",
+    "decamelize": "^4.0.0",
+    "deep-eql": "^4.1.3",
+    "diff": "^5.0.0",
+    "emoji-regex": "^8.0.0",
+    "escalade": "^3.1.1",
+    "escape-string-regexp": "^4.0.0",
+    "files-js": "^1.0.1",
+    "fill-range": "^7.0.1",
+    "find-up": "^5.0.0",
+    "flat": "^5.0.2",
+    "fs.realpath": "^1.0.0",
+    "get-caller-file": "^2.0.5",
+    "get-func-name": "^2.0.0",
+    "glob": "^7.2.0",
+    "glob-parent": "^5.1.2",
+    "has-flag": "^4.0.0",
+    "he": "^1.2.0",
+    "inflight": "^1.0.6",
+    "inherits": "^2.0.4",
+    "is-binary-path": "^2.1.0",
+    "is-extglob": "^2.1.1",
+    "is-fullwidth-code-point": "^3.0.0",
+    "is-glob": "^4.0.3",
+    "is-number": "^7.0.0",
+    "is-plain-obj": "^2.1.0",
+    "is-unicode-supported": "^0.1.0",
+    "js-yaml": "^4.1.0",
+    "locate-path": "^6.0.0",
+    "log-symbols": "^4.1.0",
+    "loupe": "^2.3.6",
+    "minimatch": "^5.0.1",
+    "ms": "^2.1.3",
+    "nanoid": "^3.3.3",
+    "normalize-path": "^3.0.0",
+    "object-hash": "^3.0.0",
+    "once": "^1.4.0",
+    "p-limit": "^3.1.0",
+    "p-locate": "^5.0.0",
+    "path-exists": "^4.0.0",
+    "path-is-absolute": "^1.0.1",
+    "pathval": "^1.1.1",
+    "picomatch": "^2.3.1",
+    "randombytes": "^2.1.0",
+    "readdirp": "^3.6.0",
+    "require-directory": "^2.1.1",
+    "rimraf": "^3.0.2",
+    "safe-buffer": "^5.2.1",
+    "serialize-javascript": "^6.0.0",
+    "string-width": "^4.2.3",
+    "strip-ansi": "^6.0.1",
+    "strip-json-comments": "^3.1.1",
+    "supports-color": "^8.1.1",
+    "tmp": "^0.2.1",
+    "to-regex-range": "^5.0.1",
+    "type-detect": "^4.0.8",
+    "workerpool": "^6.2.1",
+    "wrap-ansi": "^7.0.0",
+    "wrappy": "^1.0.2",
+    "y18n": "^5.0.8",
+    "yargs": "^16.2.0",
+    "yargs-parser": "^20.2.4",
+    "yargs-unparser": "^2.0.0",
+    "yocto-queue": "^0.1.0"
+  },
+  "devDependencies": {
+    "mocha": "^10.2.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "author": "Goran Topic",
+  "license": "ISC"
+}

package/src/Proxy.js

@@ -0,0 +1,103 @@
+class Proxy {
+    constructor(proxy, protocol = null) {
+        // if proxy string starts with protocol
+        if( proxy.includes('://') ){
+            this.protocol = proxy.split('://')[0];
+            this.ip = proxy.split('://')[1].split(':')[0];
+            this.port = proxy.split('://')[1].split(':')[1];
+        } else { // if proxy string does not start with protocol
+            this.protocol = protocol;
+            this.ip = proxy.split(':')[0];
+            this.port = proxy.split(':')[1];
+        }
+        // the proxy 
+        this.proxy = `${(this.protocol)? this.protocol+'://' : ''}${this.ip}:${this.port}`;
+        // status can be 'new', 'alive', 'dead'
+        this.status = 'new';
+        this.changeTimeStamp = Date.now();
+    }
+    // method to return as string
+    proxy() {
+        return `${(this.protocol)? this.protocol+'://' : ''}${this.ip}:${this.port}`;
+    }
+    toString() {
+        return `${(this.protocol)? this.protocol+'://' : ''}${this.ip}:${this.port}`;
+    }
+    // method to return as obj
+    get() {
+        return {
+            protocol: this.protocol,
+            ip: this.ip,
+            port: this.port,
+        };
+    }
+    // method to return as obj
+    obj() {
+        return {
+            protocol: this.protocol,
+            ip: this.ip,
+            port: this.port,
+            status: this.status,
+            changeTimeStamp: this.changeTimeStamp
+        }
+    }
+    // mark proxy as dead
+    kill() {
+        this.status = 'dead';
+        this.changeTimeStamp = Date.now();
+    }
+    setDead() {
+        this.status = 'dead'
+        this.changeTimeStamp = Date.now();
+    }
+    setAlive(){
+        this.status = 'alive'
+        this.changeTimeStamp = Date.now();
+    }
+    setNew() { 
+        this.status = 'new'
+        this.changeTimeStamp = Date.now();
+    }
+    isDead() { 
+        return this.status === 'dead';
+    }
+    isAlive() {
+        return this.status === 'alive';
+    }
+    isNew() {
+        return this.status === 'new';
+    }
+    revive() {
+        this.status = 'alive';
+        this.changeTimeStamp = Date.now();
+    }
+    reset() {
+        this.status = 'new';
+        this.changeTimeStamp = Date.now();
+    }
+    status() {
+        return this.status;
+    }
+    equals(proxy) {
+        if (typeof proxy === 'string')
+            proxy = new Proxy(proxy);
+        return (this.ip === proxy.ip && this.port === proxy.port);      
+    }
+    timeSinceStatusChange() {
+        return Date.now() - this.changeTimeStamp;
+    }
+    print() {
+        console.log(this.get());
+    }
+    getIp() {
+        return this.ip;
+    }
+    getPort() {
+        return this.port;
+    }
+    getProtocol() {
+        return this.protocol;
+    }
+}
+
+export default Proxy;

package/src/ProxyRotator.js

@@ -0,0 +1,175 @@
+import fs from 'fs';
+import Queue from './Queue.js';
+import Proxy from './Proxy.js';
+
+class ProxyRotator {
+    constructor(proxies, options={} ){
+        this.pool = new Queue();
+        this.graveyard = [];
+        // examine proxies passed
+        // check if it is a file path
+        if( typeof proxies === 'string' ){
+            // parse file
+            proxies = this._parseFile(proxies);
+            // add proxies to queue
+            proxies.forEach( p => this._add(p) );
+        }else if( this._isArray(proxies) ){
+            // add proxies to queue
+            proxies.forEach( p => this._add(p) );
+        }
+        // handle options
+        let { revive_timer, shuffle, protocol, assume_aliveness, check_on_next } = options;
+        // how long to wait before reviving a dead proxy
+        // default: 30 minutes
+        this.revive_timer = revive_timer ?? 1000 * 60 * 30;
+        // assume a a protocol for all proxies
+        this.protocol = protocol ?? null;
+        // shuffle the proxies before adding them to the queue
+        this.shuffle = shuffle ?? true;
+        // assume all proxies are alive when first added instead of 'new'
+        this.assume_aliveness = assume_aliveness ?? false;
+        // check if proxies are alive when they are added to the queue
+        this.check_on_next = check_on_next ?? false;
+    }
+
+    getGraveyard(){ return this.graveyard.map(p => p.proxy) }
+
+    getGraveyardSize(){ return this.graveyard.length }
+
+    getPool(){ return this.pool.toArray().map(p => p.proxy) }
+
+    getPoolSize(){ return this.pool.size }
+
+    add(proxies){ // add proxy to queue
+        if(this._isArray(proxies)) // if passed an array
+            for(let proxy of proxies) this._add(proxy);
+        else // single file
+            this._add(proxies);
+    }
+
+    _add(proxy){ // add proxy to queue
+        let p = new Proxy(proxy);
+        this.pool.enqueue(p);
+    }
+
+    remove(proxy){ // remove proxy from queue
+        if(this._isArray(proxy)) // if passed an array
+            for(let p of proxy) this._remove(p);
+        else // single file
+            this._remove(proxy);
+    }
+
+    _remove(proxy){ // remove proxy from queue
+        this.pool.toArray().forEach( (p,i) => {
+            if(p.equals(proxy)) this.pool.remove(i);
+        });
+    }
+
+    getAlive(){ // get a random alive proxy
+        let proxies = this.pool.toArray();
+        for( let proxy of proxies )
+            if(proxy.isAlive()) return proxy.proxy;
+    }
+
+    setAlive(proxy){ // set a proxy to alive
+        let proxies = this.pool.toArray()
+        for( let p of proxies ) // if proxy is in queue
+            if(p.equals(proxy)) return p.setAlive();
+        // if proxy is in graveyard
+        for( let p of this.graveyard )
+            if(p.equals(proxy)) return this.resurect(p);
+    }
+
+    resurect( proxy ){
+        // get proxy from graveyard
+        let p = this.graveyard.find( p => p.equals(proxy) );
+        // if proxy is not in graveyard
+        if(!p) return;
+        // remove from graveyard
+        this.graveyard = this.graveyard.filter( p => !p.equals(proxy) );
+        // set as new
+        p.setNew();
+        // add to queue
+        this.pool.enqueue(p);
+    }
+
+    setDead(proxy){ // set a proxy to dead
+        this.pool.toArray().forEach( (p,i) => {
+            if(p.equals(proxy)){
+                p.setDead(); // set to dead
+                // remove from queue
+                this.pool.remove(i);
+                // add to graveyard
+                this.graveyard.push(p);
+            }
+        })
+        //  revive proxy after revive_timer
+        setTimeout( () => this.resurect(proxy), this.revive_timer );
+    }
+
+    next(){
+        // resurect a proxy from the graveyard
+        if(this.check_on_next) _resurection();
+        // if there are no proxies in the pool
+        if(this.pool.size === 0) return null ;
+        // remove from front 
+        let proxy = this.pool.dequeue();
+        // add to back
+        this.pool.enqueue(proxy);
+        // return 
+        return proxy
+    }
+
+    /* Randomize array in-place using Durstenfeld shuffle algorithm */
+    _shuffleArray(array) {
+        for (var i = array.length - 1; i > 0; i--) {
+            var j = Math.floor(Math.random() * (i + 1));
+            var temp = array[i];
+            array[i] = array[j];
+            array[j] = temp;
+        }
+        return array;
+    }
+
+    _parseFile(filename) {
+        // read file
+        let str = fs.readFileSync(filename, 'utf8');
+        // this function is able to handle multiples types of files
+        let strList = str.split('\n')
+        // remove lines that are empty
+        strList = strList.filter(s=>s.length>0);
+        // if strList is has only one element
+        if(strList.length === 1)
+            strList = str.split(' ')
+        // if strList is has only one check to separate by comma
+        if(strList.length === 1)
+            strList = str.split(',')
+        // remove all the commas from the strings
+        strList = strList.map(s=>s.replace(',',''))
+        // parse list of strings into 
+        strList = strList
+            .map(s=>s.trim())
+            .filter(s=>s.length>0);
+        // return proxies
+        return strList;
+    }
+
+
+    _isArray(arrayValue){
+        return ( arrayValue && 
+            (typeof arrayValue === 'object') && 
+            (arrayValue.constructor === Array) );
+    }
+
+    _resurection(){
+        // look for proxies that have been 
+        // dead for a long than the resurection time
+        // and revive them
+        for( let proxy of this.graveyard )
+            if( proxy.isDead() && proxy.timeSinceStatusChange >= this.revive_timer )
+                this.resurect(proxy);
+    }
+
+}
+
+export default ProxyRotator 

package/src/Queue.js

@@ -0,0 +1,61 @@
+class Queue {
+    constructor() {
+        this.items = {}
+        this.frontIndex = 0
+        this.backIndex = 0
+    }
+    
+    enqueue(item) {
+        this.items[this.backIndex] = item
+        this.backIndex++
+        return item + ' inserted'
+    }
+
+    dequeue() {
+        const item = this.items[this.frontIndex]
+        delete this.items[this.frontIndex]
+        this.frontIndex++
+        return item
+    }
+    
+    // remove value while maintaining order
+    remove( index ) {
+        if (index < 0 || index >= this.backIndex) {
+            return 'Invalid index'
+        }
+        const item = this.items[index]
+        for (let i = index; i < this.backIndex; i++) {
+            this.items[i] = this.items[i + 1]
+        }
+        delete this.items[this.backIndex - 1]
+        this.backIndex--
+        return item
+    }
+
+    peek() {
+        return this.items[this.frontIndex]
+    }
+
+    printQueue() {
+        return this.items;
+    }
+
+    // return array of items in the order they were added
+    toArray() {
+        let arr = [];
+        for(let i = this.frontIndex; i < this.backIndex; i++)
+            arr.push(this.items[i]);
+        return arr;
+    }
+
+    // return object of items in the order they were added
+    toObject() {
+        let obj = {};
+        for(let i = this.frontIndex; i < this.backIndex; i++)
+            obj[i] = this.items[i];
+        return obj;
+    }
+    
+}
+
+export default Queue;

package/test/test.js

@@ -0,0 +1,169 @@
+import ProxyRotator from '../index.js'
+import assert from 'assert';
+import chai from 'chai';
+const expect = chai.expect
+
+// slogan: when you like a little risk with you proxies
+// proxies to test with 
+let test_proxies = [ '139.59.1.14:8080', '94.45.74.60:8080', 
+    '161.35.70.249:3128', '217.182.170.224:80', '222.138.76.6:9002',
+    '218.252.206.89:80',  '18.214.66.210:80', '120.234.203.171:9002' ]
+
+// check if it is able to read from difrent files
+describe('read form proxy files', () => {
+    // test if it can process a string point to a file
+    it('reading file with newlines', () => {
+        // make rotator with file with newlines
+        let proxies_file = './assets/http_proxies_with_newlines.txt';
+        // make rotator with file with newlines
+        let rotator_with_newlines = new ProxyRotator(proxies_file); 
+        // get pool
+        let pool = rotator_with_newlines.getPool();
+        assert.deepEqual(test_proxies, pool)
+    })
+    // test if it can process a file with spaces
+    it('reading file with spaces', () => {
+        // make rotator with file with spaces
+        let proxies_file = './assets/http_proxies_with_spaces.txt';
+        // make rotator with file with spaces
+        let rotator_with_spaces = new ProxyRotator(proxies_file);
+        // get pool
+        let pool = rotator_with_spaces.getPool();
+        assert.deepEqual(test_proxies, pool)
+    })
+    // test if it can process a file with commas
+    it('reading file with commas', () => {
+        // make rotator with file with commas
+        let proxies_file = './assets/http_proxies_with_commas.txt';
+        // make rotator with file with spaces
+        let rotator_with_commas = new ProxyRotator(proxies_file);
+        // get pool
+        let pool = rotator_with_commas.getPool();
+        assert.deepEqual(test_proxies, pool)
+    })
+});
+
+// check the functionality of the rotator
+describe('basic functionality', () => {
+    // test if it can process a string point to a file
+    it('add proxies array', () => {
+        // make rotator with file with newlines
+        let rotator = new ProxyRotator(test_proxies);
+        // get pool
+        assert.deepEqual(test_proxies,rotator.getPool())
+    })
+    // adding one by one
+    it('add proxy one by one ', () => {
+        // make rotator with file with newlines
+        let rotator = new ProxyRotator();
+        // add proxies one by one
+        for(let proxy of test_proxies) rotator.add(proxy)
+        // test
+        assert.deepEqual(test_proxies,rotator.getPool())
+    })
+    // remove one by one
+    it('remove one', () => {
+        // make rotator
+        let rotator = new ProxyRotator(test_proxies);
+        // remove proxies one by one
+        let removed = test_proxies.filter(e => e !== test_proxies[3])
+        rotator.remove(test_proxies[3])
+        // test
+        assert.deepEqual(removed, rotator.getPool())
+    })
+    // remove one by one
+    it('remove proxy one by one ', () => {
+        // make rotator
+        let rotator = new ProxyRotator(test_proxies);
+        // remove proxies one by one
+        for(let proxy of test_proxies) rotator.remove(proxy)
+        // test
+        assert.deepEqual([], rotator.getPool())
+    })
+    // test if set dead works
+    it('set dead to graveyard', () => {
+        // make rotator
+        let rotator = new ProxyRotator(test_proxies);
+        //  set dead
+        rotator.setDead(test_proxies[3])
+        // test
+        assert.deepEqual(
+            rotator.getGraveyard().includes(test_proxies[3]),
+            true
+        )
+    })
+    it('set dead remove from pool', () => {
+        // make rotator
+        let rotator = new ProxyRotator(test_proxies);
+        //  set dead
+        rotator.setDead(test_proxies[3])
+        // test
+        assert.equal(
+            rotator.getPool().includes(test_proxies[3]),
+            false
+        )
+    })
+    it('resurect proxy from graveyard', () => {
+        // make rotator
+        let rotator = new ProxyRotator(test_proxies);
+        //  set dead
+        rotator.setDead(test_proxies[3])
+        // set alive
+        rotator.resurect(test_proxies[3])
+        // test
+        assert.equal(rotator.getPool().includes(test_proxies[3]), true)
+    })
+    // test if set dead works
+    it('set dead proxy alive', () => {
+        // make rotator
+        let rotator = new ProxyRotator(test_proxies);
+        //  set dead
+        rotator.setDead(test_proxies[3])
+        // set alive
+        rotator.setAlive(test_proxies[3])
+        // test
+        assert.equal(rotator.getPool().includes(test_proxies[3]), true)
+    })
+    // test if set dead works
+    it('get alive', () => {
+        // make rotator
+        let rotator = new ProxyRotator(test_proxies);
+        // set alive
+        rotator.setAlive(test_proxies[3])
+        // get alive
+        let proxy = rotator.getAlive()
+        // test
+        assert.equal(proxy, test_proxies[3])
+    })
+    // test rotation
+    it('test rotation', () => {
+        // make rotator
+        let rotator = new ProxyRotator(test_proxies);
+        let removed = test_proxies.filter(e => e !== test_proxies[3])
+        // set dead
+        rotator.setDead(test_proxies[3])
+        // test if every proxy returned with next matches removed 
+        for(let i = 0; i < removed.length; i++){
+            let proxy = rotator.next()
+            assert.equal(proxy, removed[i])
+        }
+    })
+    // test resurrect timer
+    it('resurect timer', function(done){
+        // set timeout
+        this.timeout(1100);
+        // make rotator
+        let rotator = new ProxyRotator(test_proxies, { revive_timer: 1000 } );
+        let removed = test_proxies.filter(e => e !== test_proxies[3])
+        // set dead
+        rotator.setDead(test_proxies[3])
+        // wait for resurect timer
+        setTimeout(() => { 
+            assert.equal(
+                rotator.getPool().includes(test_proxies[3]),
+                true
+            );
+            done();
+        }, 1000);
+    })
+});