proxy-rotator-js 1.0.8 → 1.1.0

package/README.md

@@ -77,6 +77,29 @@ remove(proxy) // Removes one or more proxies from the pool.
 
     graveyard: Stores proxies that are currently dead or inactive.
 
+## Options
+```javascript
+const proxies = ['proxy1.example.com', 'proxy2.example.com'];
+const options = {
+    returnAs: 'object',
+    revive_timer: 1000 * 60 * 30,
+    shuffle: true,
+    protocol: 'http',
+    assume_aliveness: true,
+    check_on_next: true
+};
+
+const proxyRotator = new ProxyRotator(proxies, options);
+```
+    The following options can be passed to customize the behavior of the ProxyRotator:
+
+    - returnAs: Specifies the return type of proxies. Can be either 'string' or 'object'. Default: 'string'.
+    - revive_timer: Specifies the duration in milliseconds before a dead proxy is revived. Default: 1000 * 60 * 30 (30 minutes).
+    - protocol: Specifies a protocol for all proxies. Default: null.
+    - shuffle: Specifies whether to shuffle the proxies before adding them to the queue. Default: false.
+    - assume_aliveness: Specifies whether to assume all proxies are alive when first added instead of 'new'. Default: false.
+    - check_on_next: Specifies whether to check if proxies are alive when they are added to the queue. Default: false.
+
 ## Getting Started
 
 To use the ProxyRotator class in your JavaScript project, follow these steps:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "proxy-rotator-js",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "type": "module",
   "description": "Proxy Rotator",
   "main": "index.js",
@@ -14,6 +14,7 @@
     "anymatch": "^3.1.3",
     "argparse": "^2.0.1",
     "assertion-error": "^1.1.0",
+    "axios": "^1.6.8",
     "balanced-match": "^1.0.2",
     "binary-extensions": "^2.2.0",
     "brace-expansion": "^2.0.1",

package/src/ProxyRotator.js

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import Queue from './Queue.js';
 import Proxy from './Proxy.js';
+import makeRequestWithProxy from './utils/makeRequestWithProxy.js';
 
 class ProxyRotator {
     constructor(proxies, options={} ){
@@ -16,7 +17,7 @@ class ProxyRotator {
         // assume a a protocol for all proxies
         this.protocol = protocol ?? null;
         // shuffle the proxies before adding them to the queue
-        this.shuffle = shuffle ?? true;
+        this.shuffle = shuffle ?? false;
         // 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
@@ -32,6 +33,12 @@ class ProxyRotator {
             // add proxies to queue
             proxies.forEach( p => this._add(p) );
         }
+        // shuffle proxies
+        if(this.shuffle){
+            let shuffled = this._shuffleArray(this.pool.toArray());
+            this.pool = new Queue();
+            shuffled.forEach( p => this.pool.enqueue(p) );
+        }
     }
 
     getGraveyard(){ return this.graveyard.map(p => p.proxy) }
@@ -196,6 +203,37 @@ class ProxyRotator {
                 this.resurect(proxy);
     }
 
+    async test_proxies(){
+        // test if proxies are working
+        let proxies = this.pool.toArray()
+            .map(p=>p.proxy)
+            .map(p=> ({
+                host:p.split(':')[0],
+                port:p.split(':')[1]
+            }));
+        console.log('--- Testing Proxies ---');
+        let workingCount = 0;
+        let notWorkingCount = 0;
+        // make request with proxy
+        for (const proxy of proxies) {
+            console.log(`Testing proxy ${proxy.host}:${proxy.port}...`);    
+            const response = await makeRequestWithProxy(proxy);
+            if (response === proxy.host) {
+                console.log(`Proxy ${proxy.host}:${proxy.port} is working.`);
+                workingCount++;
+            } else {
+                console.log(`Proxy ${proxy.host}:${proxy.port} is not working.`);
+                notWorkingCount++;
+            }
+        }
+        console.log('--- Statistics ---');
+        console.log(`Total proxies: ${proxies.length}`);
+        console.log(`Working proxies: ${workingCount}`);
+        console.log(`Not working proxies: ${notWorkingCount}`);
+    }
+
+    test = this.test_proxies;
+
 }
 
 export default ProxyRotator 

package/src/utils/makeRequestWithProxy.js

@@ -0,0 +1,21 @@
+import axios from 'axios';
+// Description: Function to make an Axios request using a proxy
+
+// Function to make an Axios request using a proxy
+async function makeRequestWithProxy(proxy) {
+  try {
+    const response = await axios.get('https://api.ipify.org?format=json', {
+      proxy: {
+        host: proxy.host,
+        port: proxy.port,
+        protocol: 'http'
+      }
+    });
+    console.log(response.data);
+    return response.data;
+  } catch (error) {
+    return null;
+  }
+}
+
+export default makeRequestWithProxy;

package/test/options.js

@@ -0,0 +1,32 @@
+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 shuffle option
+describe('shuffle option', () => {
+    it('shuffle proxies when true', () => {
+        // make rotator with shuffle option set to true
+        let rotator = new ProxyRotator(test_proxies, { shuffle: true });
+        // get pool
+        let pool = rotator.getPool();
+        // check if the proxies are shuffled
+        assert.notDeepEqual(test_proxies, pool);
+    });
+
+    it('do not shuffle proxies when false', () => {
+        // make rotator with shuffle option set to false
+        let rotator = new ProxyRotator(test_proxies, { shuffle: false });
+        // get pool
+        let pool = rotator.getPool();
+        // check if the proxies are not shuffled
+        assert.deepEqual(test_proxies, pool);
+    });
+});
+

package/test/test_proxies.js

@@ -0,0 +1,22 @@
+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('testing testing proxies', () => {
+    // test if it can process a string point to a file
+    it('testing proxeis', () => {
+        // make rotator 
+        let rotator = new ProxyRotator(test_proxies);
+        rotator.test()
+        assert.deepEqual(test_proxies,rotator.getPool())
+    })
+})
+