@k03mad/ip2geo 3.1.0 → 4.0.0

package/README.md

@@ -7,6 +7,7 @@
 
 ```bash
 npm i @k03mad/ip2geo -g
+ip2geo --help
 
 ip2geo 1.1.1.1
 # {
@@ -21,8 +22,8 @@ ip2geo 1.1.1.1
 #   ispDomain: 'cloudflare.com'
 # }
 
-ip2geo 1.1.1.1 --json
-# {"ip":"1.1.1.1","emoji":"🇺🇸","country":"United States","countryA2":"US","region":"District of Columbia","city":"Washington","org":"APNIC and Cloudflare DNS Resolver project","isp":"Cloudflare, Inc.","ispDomain":"cloudflare.com"}
+ip2geo 1.1.1.1 8.8.8.8 --json
+# [{"ip":"1.1.1.1","emoji":"🇺🇸","country":"United States","countryA2":"US","region":"District of Columbia","city":"Washington","org":"APNIC and Cloudflare DNS Resolver project","isp":"Cloudflare, Inc.","ispDomain":"cloudflare.com"},{"ip":"8.8.8.8","emoji":"🇺🇸","country":"United States","countryA2":"US","region":"California","city":"Mountain View","org":"Google LLC","isp":"Google LLC","ispDomain":"google.com"}]
 ```
 
 ## API
@@ -40,6 +41,8 @@ const info = await ip2geo('1.1.1.1', {
     cacheFileName: 'ips.log',
     cacheFileSeparator: ';;',
     cacheFileNewline: '\n',
+    cacheMap: new Map(),
+    rps: 5, // useful in Promise.all with big IPs array
 });
 
 // info {

package/app/cli.js

@@ -1,40 +1,39 @@
 #!/usr/bin/env node
 
-import {log, logErrorExit} from '@k03mad/simple-log';
+import {log} from '@k03mad/simple-log';
 
-import {codeText, errorText, nameText} from './helpers/colors.js';
+import {codeText, nameText} from './helpers/colors.js';
 
 import {ip2geo} from './index.js';
 
-const jsonParam = '--json';
+const args = process.argv.slice(2);
 
-let args = process.argv.slice(2);
-
-if (args.length === 0) {
+if (args.includes('-h') || args.includes('--help')) {
     const prefix = codeText('$');
     const name = nameText('ip2geo');
+    const json = codeText('// json output for parse');
+    const multi = codeText('// multi IPs');
 
-    logErrorExit([
-        errorText('IP(s) should be passed as args'),
+    log([
         '',
+        `${prefix} ${name}`,
         `${prefix} ${name} 1.1.1.1`,
-        `${prefix} ${name} 1.1.1.1 8.8.8.8`,
+        `${prefix} ${name} 1.1.1.1 -j       ${json}`,
+        `${prefix} ${name} 1.1.1.1 --json   ${json}`,
+        `${prefix} ${name} 1.1.1.1 8.8.8.8  ${multi}`,
+        `${prefix} ${name} 1.1.1.1,8.8.8.8  ${multi}`,
+        '',
     ]);
 }
 
-let json;
-
-if (args.includes(jsonParam)) {
-    json = true;
-    args = args.filter(elem => elem !== jsonParam);
-}
-
-await Promise.all(args.map(async arg => {
-    const output = await ip2geo(arg);
+const output = await Promise.all(args
+    .filter(arg => !arg.startsWith('-'))
+    .map(arg => Promise.all(arg.split(',').map(elem => ip2geo(elem)))));
 
-    if (json) {
-        return log(JSON.stringify(output));
-    }
+const flatten = output.flat();
 
-    log(output);
-}));
+if (args.includes('--json') || args.includes('-j')) {
+    log(JSON.stringify(flatten.length > 1 ? flatten : flatten[0]));
+} else {
+    log(flatten);
+}

package/app/helpers/colors.js

@@ -1,6 +1,5 @@
 import chalk from 'chalk';
 
-export const errorText = chalk.red.bold.bgGray;
 export const codeText = chalk.gray;
 export const numText = chalk.blue;
 export const nameText = chalk.magenta;

package/app/index.js

@@ -1 +1 @@
-export {default as ip2geo} from './lib/ip2geo.js';
+export * from './lib/ip2geo.js';

package/app/lib/ip2geo.js

@@ -26,8 +26,9 @@ const DEFAULT_CACHE_FILE_DIR = path.join(os.tmpdir(), '.ip2geo');
 const DEFAULT_CACHE_FILE_NAME = 'ips.log';
 const DEFAULT_CACHE_FILE_SEPARATOR = ';;';
 const DEFAULT_CACHE_FILE_NEWLINE = '\n';
+const DEFAULT_RPS = 5;
 
-const cacheMap = new Map();
+export const cacheStorage = new Map();
 
 const outputKeys = [
     'ip',
@@ -110,13 +111,17 @@ const writeToFsCache = async (ip, data, cacheDir, cacheFileName, cacheFileSepara
  * @param {string} [opts.cacheFileName]
  * @param {string} [opts.cacheFileSeparator]
  * @param {string} [opts.cacheFileNewline]
+ * @param {Map} [opts.cacheMap]
+ * @param {number} opts.rps
  * @returns {Promise<GeoIpOutput>}
  */
-export default async (ip = '', {
+export const ip2geo = async (ip = '', {
     cacheDir = DEFAULT_CACHE_FILE_DIR,
     cacheFileName = DEFAULT_CACHE_FILE_NAME,
     cacheFileSeparator = DEFAULT_CACHE_FILE_SEPARATOR,
     cacheFileNewline = DEFAULT_CACHE_FILE_NEWLINE,
+    cacheMap = cacheStorage,
+    rps = DEFAULT_RPS,
 } = {}) => {
     if (ip) {
         const ipData = cacheMap.get(ip);
@@ -145,7 +150,7 @@ export default async (ip = '', {
         }
     }
 
-    const {body} = await request(API + ip);
+    const {body} = await request(API + ip, {}, {rps});
 
     if (!body?.ip) {
         throw new Error(`API error:\n${body}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k03mad/ip2geo",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "description": "GeoIP library",
   "maintainers": [
     "Kirill Molchanov <k03.mad@gmail.com"
@@ -19,13 +19,13 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@k03mad/request": "5.4.1",
-    "@k03mad/simple-log": "2.0.0",
+    "@k03mad/request": "5.5.0",
+    "@k03mad/simple-log": "2.1.0",
     "chalk": "5.3.0",
     "debug": "4.3.4"
   },
   "devDependencies": {
-    "@k03mad/eslint-config": "19.3.0",
+    "@k03mad/eslint-config": "19.4.0",
     "eslint": "8.56.0",
     "husky": "8.0.3",
     "mocha": "10.2.0"

package/tests/helpers/consts.js

@@ -0,0 +1,33 @@
+import os from 'node:os';
+import path from 'node:path';
+
+export const DEFAULT_OPTS = {
+    cacheDir: path.join(os.tmpdir(), '.ip2geo'),
+    cacheFileName: 'ips.log',
+    cacheFileSeparator: ';;',
+    cacheFileNewline: '\n',
+};
+
+export const REQUEST_IPV4 = {
+    ip: '8.8.8.8',
+    emoji: '🇺🇸',
+    country: 'United States',
+    countryA2: 'US',
+    region: 'California',
+    city: 'Mountain View',
+    org: 'Google LLC',
+    isp: 'Google LLC',
+    ispDomain: 'google.com',
+};
+
+export const REQUEST_IPV6 = {
+    ip: '2a00:dd80:40:100::',
+    emoji: '🇳🇱',
+    country: 'Netherlands',
+    countryA2: 'NL',
+    region: 'North Holland',
+    city: 'Amsterdam',
+    org: '',
+    isp: 'NetActuate Inc',
+    ispDomain: '',
+};

package/tests/opts-assigned-all.js

@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict';
+
+import {describe, it} from 'mocha';
+
+import {ip2geo} from '../app/index.js';
+
+import {REQUEST_IPV4} from './helpers/consts.js';
+import {getCurrentFilename, getTestFolder} from './helpers/path.js';
+import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
+
+const testName = getCurrentFilename(import.meta.url);
+
+describe(testName, () => {
+    const opts = {
+        cacheDir: getTestFolder(testName),
+        cacheFileName: 'ips.md',
+        cacheFileSeparator: '-_-',
+        cacheFileNewline: '%%%',
+        cacheMap: new Map(),
+    };
+
+    it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
+
+    it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
+        const data = await ip2geo(REQUEST_IPV4.ip, opts);
+        assert.deepEqual(data, REQUEST_IPV4);
+    });
+
+    it('should have cache file', () => checkCacheFile({
+        ...opts,
+        response: REQUEST_IPV4,
+    }));
+});

package/tests/opts-assigned-cache-map.js

@@ -0,0 +1,43 @@
+import assert from 'node:assert/strict';
+
+import {describe, it} from 'mocha';
+
+import {ip2geo} from '../app/index.js';
+
+import {REQUEST_IPV4, REQUEST_IPV6} from './helpers/consts.js';
+import {getCurrentFilename, getTestFolder} from './helpers/path.js';
+import {removeCacheFolder} from './shared/fs.js';
+
+const testName = getCurrentFilename(import.meta.url);
+
+describe(testName, () => {
+    const cacheMap = new Map();
+
+    const opts = {
+        cacheDir: getTestFolder(testName),
+        cacheMap,
+    };
+
+    it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
+
+    it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
+        const data = await ip2geo(REQUEST_IPV4.ip, opts);
+        assert.deepEqual(data, REQUEST_IPV4);
+    });
+
+    it('should have 1 correct cache entry', () => {
+        assert.equal(cacheMap.size, 1);
+        assert.deepEqual(cacheMap.get(REQUEST_IPV4.ip), REQUEST_IPV4);
+    });
+
+    it(`should return correct response for IP: "${REQUEST_IPV6.ip}"`, async () => {
+        const data = await ip2geo(REQUEST_IPV6.ip, opts);
+        assert.deepEqual(data, REQUEST_IPV6);
+    });
+
+    it('should have 2 correct cache entries', () => {
+        assert.equal(cacheMap.size, 2);
+        assert.deepEqual(cacheMap.get(REQUEST_IPV4.ip), REQUEST_IPV4);
+        assert.deepEqual(cacheMap.get(REQUEST_IPV6.ip), REQUEST_IPV6);
+    });
+});

package/tests/opts-assigned-ipv6.js

@@ -4,48 +4,28 @@ import {describe, it} from 'mocha';
 
 import {ip2geo} from '../app/index.js';
 
+import {REQUEST_IPV6} from './helpers/consts.js';
 import {getCurrentFilename, getTestFolder} from './helpers/path.js';
 import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
 
 const testName = getCurrentFilename(import.meta.url);
 
 describe(testName, () => {
-    const CACHE_FILE_DIR = getTestFolder(testName);
-    const CACHE_FILE_NAME = 'ips.log';
-    const CACHE_FILE_SEPARATOR = ';;';
-    const CACHE_FILE_NEWLINE = '\n';
-
-    const REQUEST_IP = '2a00:dd80:40:100::';
-
-    const cacheFile = `${REQUEST_IP.split(/\.|:/)[0]}_${CACHE_FILE_NAME}`;
-
-    const response = {
-        ip: REQUEST_IP,
-        emoji: '🇳🇱',
-        country: 'Netherlands',
-        countryA2: 'NL',
-        region: 'North Holland',
-        city: 'Amsterdam',
-        org: '',
-        isp: 'NetActuate Inc',
-        ispDomain: '',
+    const opts = {
+        cacheDir: getTestFolder(testName),
+        cacheMap: new Map(),
     };
 
-    it('should remove fs cache dir if exist', () => removeCacheFolder(CACHE_FILE_DIR));
+    it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
 
-    it(`should return correct response for IP: "${REQUEST_IP}"`, async () => {
-        const data = await ip2geo(REQUEST_IP, {
-            cacheDir: CACHE_FILE_DIR,
-        });
+    it(`should return correct response for IP: "${REQUEST_IPV6.ip}"`, async () => {
+        const data = await ip2geo(REQUEST_IPV6.ip, opts);
 
-        assert.deepEqual(data, response);
+        assert.deepEqual(data, REQUEST_IPV6);
     });
 
-    it('should have cache file', () => checkCacheFile(
-        CACHE_FILE_DIR,
-        cacheFile,
-        CACHE_FILE_SEPARATOR,
-        CACHE_FILE_NEWLINE,
-        response,
-    ));
+    it('should have cache file', () => checkCacheFile({
+        ...opts,
+        response: REQUEST_IPV6,
+    }));
 });

package/tests/opts-assigned-multi-requests.js

@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict';
+
+import {describe, it} from 'mocha';
+
+import {ip2geo} from '../app/index.js';
+
+import {REQUEST_IPV4} from './helpers/consts.js';
+import {getCurrentFilename, getTestFolder} from './helpers/path.js';
+import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
+
+const testName = getCurrentFilename(import.meta.url);
+
+describe(testName, () => {
+    const opts = {
+        cacheDir: getTestFolder(testName),
+        cacheMap: new Map(),
+        requestsCount: 5,
+    };
+
+    it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
+
+    Array.from({length: opts.requestsCount}).forEach(() => {
+        it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
+            const data = await ip2geo(REQUEST_IPV4.ip, opts);
+            assert.deepEqual(data, REQUEST_IPV4);
+        });
+    });
+
+    it('should have cache file', () => checkCacheFile({
+        ...opts,
+        response: REQUEST_IPV4,
+    }));
+});

package/tests/opts-assigned-no-data.js

@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict';
+
+import {describe, it} from 'mocha';
+
+import {ip2geo} from '../app/index.js';
+
+import {REQUEST_IPV4} from './helpers/consts.js';
+import {getCurrentFilename, getTestFolder} from './helpers/path.js';
+import {removeCacheFolder} from './shared/fs.js';
+
+const testName = getCurrentFilename(import.meta.url);
+
+describe(testName, () => {
+    const response = {ip: '10.10.10.10'};
+
+    Object.keys(REQUEST_IPV4).forEach(elem => {
+        if (elem !== 'ip') {
+            response[elem] = undefined;
+        }
+    });
+
+    const opts = {
+        cacheDir: getTestFolder(testName),
+        cacheMap: new Map(),
+    };
+
+    it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
+
+    it(`should return empty response for IP: "${response.ip}"`, async () => {
+        const data = await ip2geo(response.ip, opts);
+        assert.deepEqual(data, response);
+    });
+});

package/tests/opts-assigned-subfolder.js

@@ -5,54 +5,33 @@ import {describe, it} from 'mocha';
 
 import {ip2geo} from '../app/index.js';
 
+import {REQUEST_IPV4} from './helpers/consts.js';
 import {getCurrentFilename, getTestFolder} from './helpers/path.js';
 import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
 
 const testName = getCurrentFilename(import.meta.url);
-const SUBFOLDERS = 5;
 
 describe(testName, () => {
-    const CACHE_FILE_DIR = getTestFolder(
-        path.join(
-            ...Array.from({length: SUBFOLDERS}, () => testName),
+    const SUBFOLDERS = 5;
+
+    const opts = {
+        cacheDir: getTestFolder(
+            path.join(
+                ...Array.from({length: SUBFOLDERS}, () => testName),
+            ),
         ),
-    );
-
-    const CACHE_FILE_NAME = 'ips.log';
-    const CACHE_FILE_SEPARATOR = ';;';
-    const CACHE_FILE_NEWLINE = '\n';
-
-    const REQUEST_IP = '9.9.9.9';
-
-    const cacheFile = `${REQUEST_IP.split(/\.|:/)[0]}_${CACHE_FILE_NAME}`;
-
-    const response = {
-        ip: REQUEST_IP,
-        emoji: '🇨🇭',
-        country: 'Switzerland',
-        countryA2: 'CH',
-        region: 'Zurich',
-        city: 'Zürich',
-        org: 'Quad9',
-        isp: 'Quad9',
-        ispDomain: 'quad9.net',
+        cacheMap: new Map(),
     };
 
-    it('should remove fs cache dir if exist', () => removeCacheFolder(CACHE_FILE_DIR));
-
-    it(`should return correct response for IP: "${REQUEST_IP}"`, async () => {
-        const data = await ip2geo(REQUEST_IP, {
-            cacheDir: CACHE_FILE_DIR,
-        });
+    it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
 
-        assert.deepEqual(data, response);
+    it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
+        const data = await ip2geo(REQUEST_IPV4.ip, opts);
+        assert.deepEqual(data, REQUEST_IPV4);
     });
 
-    it('should have cache file', () => checkCacheFile(
-        CACHE_FILE_DIR,
-        cacheFile,
-        CACHE_FILE_SEPARATOR,
-        CACHE_FILE_NEWLINE,
-        response,
-    ));
+    it('should have cache file', () => checkCacheFile({
+        ...opts,
+        response: REQUEST_IPV4,
+    }));
 });

package/tests/opts-default.js

@@ -1,63 +1,32 @@
 import assert from 'node:assert/strict';
-import os from 'node:os';
-import path from 'node:path';
 
 import {describe, it} from 'mocha';
 
-import {ip2geo} from '../app/index.js';
+import {cacheStorage, ip2geo} from '../app/index.js';
 
+import {REQUEST_IPV4} from './helpers/consts.js';
+import {getCurrentFilename} from './helpers/path.js';
 import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
 
-describe('opts-default', () => {
-    const CACHE_FILE_DIR = path.join(os.tmpdir(), '.ip2geo');
-    const CACHE_FILE_NAME = 'ips.log';
-    const CACHE_FILE_SEPARATOR = ';;';
-    const CACHE_FILE_NEWLINE = '\n';
+const testName = getCurrentFilename(import.meta.url);
 
-    const REQUEST_IP = '1.1.1.1';
-
-    const cacheFile = `${REQUEST_IP.split(/\.|:/)[0]}_${CACHE_FILE_NAME}`;
-
-    const response = {
-        ip: REQUEST_IP,
-        emoji: '🇺🇸',
-        country: 'United States',
-        countryA2: 'US',
-        region: 'District of Columbia',
-        city: 'Washington',
-        org: 'APNIC and Cloudflare DNS Resolver project',
-        isp: 'Cloudflare, Inc.',
-        ispDomain: 'cloudflare.com',
-    };
-
-    const outputKeys = [
-        'ip',
-        'emoji',
-        'country',
-        'countryA2',
-        'region',
-        'city',
-        'org',
-        'isp',
-        'ispDomain',
-    ];
-
-    removeCacheFolder(CACHE_FILE_DIR);
+describe(testName, () => {
+    it('should remove fs cache dir if exist', () => removeCacheFolder());
 
     describe('with ip arg', () => {
-        it(`should return correct response for IP: "${REQUEST_IP}"`, async () => {
-            const data = await ip2geo(REQUEST_IP);
-
-            assert.deepEqual(data, response);
+        it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
+            const data = await ip2geo(REQUEST_IPV4.ip);
+            assert.deepEqual(data, REQUEST_IPV4);
         });
 
-        it('should have cache file', () => checkCacheFile(
-            CACHE_FILE_DIR,
-            cacheFile,
-            CACHE_FILE_SEPARATOR,
-            CACHE_FILE_NEWLINE,
-            response,
-        ));
+        it('should have cache file', () => checkCacheFile({
+            response: REQUEST_IPV4,
+        }));
+
+        it('should have 1 correct cache entry', () => {
+            assert.equal(cacheStorage.size, 1);
+            assert.deepEqual(cacheStorage.get(REQUEST_IPV4.ip), REQUEST_IPV4);
+        });
     });
 
     describe('without ip arg', () => {
@@ -67,14 +36,19 @@ describe('opts-default', () => {
             data = await ip2geo();
         });
 
-        outputKeys.forEach(key => {
+        Object.keys(REQUEST_IPV4).forEach(key => {
             it(`should have "${key}" in request response`, () => {
                 assert.ok(data[key]);
             });
         });
 
         it('should not have extra keys in request response', () => {
-            assert.deepEqual(Object.keys(data), outputKeys);
+            assert.deepEqual(Object.keys(data), Object.keys(REQUEST_IPV4));
+        });
+
+        it('should have 2 cache entries', () => {
+            assert.equal(cacheStorage.size, 2);
+            assert.deepEqual(cacheStorage.get(REQUEST_IPV4.ip), REQUEST_IPV4);
         });
     });
 });

package/tests/shared/fs.js

@@ -2,10 +2,12 @@ import assert from 'node:assert/strict';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
+import {DEFAULT_OPTS} from '../helpers/consts.js';
+
 /**
  * @param {string} cacheDir
  */
-export const removeCacheFolder = async cacheDir => {
+export const removeCacheFolder = async (cacheDir = DEFAULT_OPTS.cacheDir) => {
     try {
         await fs.rm(cacheDir, {recursive: true, force: true});
     } catch (err) {
@@ -16,14 +18,22 @@ export const removeCacheFolder = async cacheDir => {
 };
 
 /**
- * @param {string} cacheDir
- * @param {string} cacheFileName
- * @param {string} cacheFileSeparator
- * @param {string} cacheFileNewline
- * @param {object} response
+ * @param {object} opts
+ * @param {string} opts.cacheDir
+ * @param {string} opts.cacheFileName
+ * @param {string} opts.cacheFileSeparator
+ * @param {string} opts.cacheFileNewline
+ * @param {object} opts.response
  */
-export const checkCacheFile = async (cacheDir, cacheFileName, cacheFileSeparator, cacheFileNewline, response) => {
-    const data = await fs.readFile(path.join(cacheDir, cacheFileName), {encoding: 'utf8'});
+export const checkCacheFile = async ({
+    cacheDir = DEFAULT_OPTS.cacheDir,
+    cacheFileName = DEFAULT_OPTS.cacheFileName,
+    cacheFileSeparator = DEFAULT_OPTS.cacheFileSeparator,
+    cacheFileNewline = DEFAULT_OPTS.cacheFileNewline,
+    response,
+}) => {
+    const cacheFile = `${response.ip.split(/\.|:/)[0]}_${cacheFileName}`;
+    const data = await fs.readFile(path.join(cacheDir, cacheFile), {encoding: 'utf8'});
 
     assert.equal(data, Object.values(response).join(cacheFileSeparator) + cacheFileNewline);
 };

package/tests/opts-assigned.js

@@ -1,54 +0,0 @@
-import assert from 'node:assert/strict';
-
-import {describe, it} from 'mocha';
-
-import {ip2geo} from '../app/index.js';
-
-import {getCurrentFilename, getTestFolder} from './helpers/path.js';
-import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
-
-const testName = getCurrentFilename(import.meta.url);
-
-describe(testName, () => {
-    const CACHE_FILE_DIR = getTestFolder(testName);
-    const CACHE_FILE_NAME = 'ips.md';
-    const CACHE_FILE_SEPARATOR = '-_-';
-    const CACHE_FILE_NEWLINE = '%%%';
-
-    const REQUEST_IP = '8.8.8.8';
-
-    const cacheFile = `${REQUEST_IP.split(/\.|:/)[0]}_${CACHE_FILE_NAME}`;
-
-    const response = {
-        ip: REQUEST_IP,
-        emoji: '🇺🇸',
-        country: 'United States',
-        countryA2: 'US',
-        region: 'California',
-        city: 'Mountain View',
-        org: 'Google LLC',
-        isp: 'Google LLC',
-        ispDomain: 'google.com',
-    };
-
-    it('should remove fs cache dir if exist', () => removeCacheFolder(CACHE_FILE_DIR));
-
-    it(`should return correct response for IP: "${REQUEST_IP}"`, async () => {
-        const data = await ip2geo(REQUEST_IP, {
-            cacheDir: CACHE_FILE_DIR,
-            cacheFileName: CACHE_FILE_NAME,
-            cacheFileSeparator: CACHE_FILE_SEPARATOR,
-            cacheFileNewline: CACHE_FILE_NEWLINE,
-        });
-
-        assert.deepEqual(data, response);
-    });
-
-    it('should have cache file', () => checkCacheFile(
-        CACHE_FILE_DIR,
-        cacheFile,
-        CACHE_FILE_SEPARATOR,
-        CACHE_FILE_NEWLINE,
-        response,
-    ));
-});