@streamr/geoip-location 100.2.4

package/test/unit/GeoIpLocator-no-network-at-monthly.test.ts

@@ -0,0 +1,55 @@
+import { GeoIpLocator } from '../../src/GeoIpLocator'
+import fs from 'fs'
+import { wait } from '@streamr/utils'
+import { TestServer } from '../helpers/TestServer'
+
+describe('GeoIpLocatorNoNetworkAtMonthly', () => {
+    let dirCounter = 0
+    const dbPath = '/tmp'
+    const serverPort = 31990
+    const serverUrl = 'http://localhost:' + serverPort + '/'
+
+    let testServer: TestServer
+    let dbDir: string
+    let locator: GeoIpLocator
+
+    const getDbDir = () => {
+        dirCounter++
+        return dbPath + '/geolite2-no-nw-monthly' + dirCounter
+    }
+
+    beforeAll(async () => {
+        testServer = new TestServer()
+        await testServer.start(serverPort)
+        dbDir = getDbDir()
+        locator = new GeoIpLocator(dbDir, 5000, 10000, serverUrl)
+        await locator.start()
+    }, 120000)
+
+    afterAll(async () => {
+        locator!.stop()
+        testServer!.stop()
+        fs.unlinkSync(dbDir + '/GeoLite2-City.mmdb')
+        fs.rmSync(dbDir!, { recursive: true })
+    })
+
+    it('does not crash if monthly database check fails because of fetch returning garbage', async () => {
+        const oldFetch = globalThis.fetch
+        const fetchMock = jest
+            .spyOn(globalThis, 'fetch')
+            .mockImplementation(() => oldFetch('https://streamr.network'))
+
+        await wait(10000)
+
+        fetchMock.mockRestore()
+
+        // suomi.fi
+        const location = locator!.lookup('62.241.198.245')
+        expect(location).toBeDefined()
+
+        // Helsinki, Finland
+        expect(location!.latitude).toBe(60.1797)
+        expect(location!.longitude).toBe(24.9344)
+
+    }, 60000)
+})

package/test/unit/GeoIpLocator-no-network-at-start.test.ts

@@ -0,0 +1,29 @@
+import { GeoIpLocator } from '../../src/GeoIpLocator'
+
+describe('GeoIpLocator', () => {
+    let dirCounter = 0
+    const dbPath = '/tmp'
+
+    const getDbDir = () => {
+        dirCounter++
+        return dbPath + '/geolite2-no-nw-start' + dirCounter
+    }
+
+    it('start throws if no network connectivity', async () => {
+        const dbDir = getDbDir()
+        
+        const fetchMock = jest
+            .spyOn(globalThis, 'fetch')
+            .mockImplementation(async () => {
+                throw new Error('API is down') 
+            })
+
+        const locator = new GeoIpLocator(dbDir)
+        
+        await expect(locator.start()).rejects.toThrow()
+        
+        fetchMock.mockRestore()
+
+        locator.stop()
+    })
+})

package/test/unit/GeoIpLocator.test.ts

@@ -0,0 +1,127 @@
+import { GeoIpLocator } from '../../src/GeoIpLocator'
+import fs from 'fs'
+import { wait } from '@streamr/utils'
+import { TestServer } from '../helpers/TestServer'
+
+describe('GeoIpLocator', () => {
+    let testServer: TestServer
+    let dirCounter = 0
+    const dbPath = '/tmp'
+    const serverPort = 31992
+    const serverUrl = 'http://127.0.0.1:' + serverPort + '/'
+
+    const getDbDir = () => {
+        dirCounter++
+        return dbPath + '/geolite2-' + dirCounter
+    }
+
+    beforeAll(async () => {
+        testServer = new TestServer()
+        await testServer.start(serverPort)
+    }, 120000)
+
+    afterAll(async () => {
+        testServer!.stop()
+    })
+
+    describe('tests with normal startup and shutdown', () => {
+        let dbDir: string
+        let locator: GeoIpLocator
+
+        it('can locate an IP address', async () => {
+            dbDir = getDbDir()
+            locator = new GeoIpLocator(dbDir, 5000, 5000, serverUrl)
+            await locator.start()
+
+            // suomi.fi
+            const location = locator.lookup('62.241.198.245')
+    
+            expect(location).toBeDefined()
+    
+            // Helsinki, Finland
+            expect(location!.latitude).toBe(60.1797)
+            expect(location!.longitude).toBe(24.9344)
+        
+            locator.stop()
+            fs.unlinkSync(dbDir + '/GeoLite2-City.mmdb')
+            fs.rmSync(dbDir, { recursive: true })
+        })
+    
+        it('returns undefined with invalid IP address', async () => {
+            dbDir = getDbDir()
+            locator = new GeoIpLocator(dbDir, 5000, 5000, serverUrl)
+            await locator.start()
+
+            expect(locator.lookup('invalid')).toBeUndefined()
+            expect(locator.lookup('')).toBeUndefined()
+            expect(locator.lookup(undefined as unknown as string)).toBeUndefined()
+            expect(locator.lookup(null as unknown as string)).toBeUndefined()
+            expect(locator.lookup('127.0.0.1')).toBeUndefined()
+        
+            locator.stop()
+            fs.unlinkSync(dbDir + '/GeoLite2-City.mmdb')
+            fs.rmSync(dbDir, { recursive: true })
+        })
+
+        it('works also after monthly check', async () => {
+            dbDir = getDbDir()
+            locator = new GeoIpLocator(dbDir, 5000, 5000, serverUrl)
+            await locator.start()
+
+            await wait(7000)
+    
+            // suomi.fi
+            const location = locator.lookup('62.241.198.245')
+            expect(location).toBeDefined()
+    
+            // Helsinki, Finland
+            expect(location!.latitude).toBe(60.1797)
+            expect(location!.longitude).toBe(24.9344)
+    
+            locator.stop()
+            fs.unlinkSync(dbDir + '/GeoLite2-City.mmdb')
+            fs.rmSync(dbDir, { recursive: true })
+        }, 60000)
+
+        it('works also after monthly check if db gets deleted before the check', async () => {
+            dbDir = getDbDir()
+            locator = new GeoIpLocator(dbDir, 5000, 5000, serverUrl)
+            await locator.start()
+
+            fs.unlinkSync(dbDir + '/GeoLite2-City.mmdb')
+    
+            await wait(10000)
+    
+            // suomi.fi
+            const location = locator.lookup('62.241.198.245')
+            expect(location).toBeDefined()
+    
+            // Helsinki, Finland
+            expect(location!.latitude).toBe(60.1797)
+            expect(location!.longitude).toBe(24.9344)
+    
+            locator.stop()
+            fs.unlinkSync(dbDir + '/GeoLite2-City.mmdb')
+            fs.rmSync(dbDir, { recursive: true })
+        }, 60000)
+    })
+
+    describe('tests with failing startup', () => {
+        it('returns undefined if not started', async () => {
+            const dbDir = getDbDir()
+            const locator = new GeoIpLocator(dbDir)
+            const location = locator.lookup('62.241.198.245')
+            expect(location).toBeUndefined()
+        })
+
+        it('start() throws if database path does not exist', async () => {
+            const locator = new GeoIpLocator('/nonexistent')
+            await expect(locator.start()).rejects.toThrow()
+        })
+    
+        it('start() throws if database path is not writable', async () => {
+            const locator = new GeoIpLocator('/etc')
+            await expect(locator.start()).rejects.toThrow()
+        })
+    })
+})

package/test/unit/downloadGeoIpDatabase.test.ts

@@ -0,0 +1,66 @@
+import { downloadGeoIpDatabase } from '../../src/downloadGeoIpDatabase'
+import fs from 'fs'
+import { TestServer } from '../helpers/TestServer'
+
+describe('downloadGeoIpDatabase', () => {
+    const serverPort = 31993
+    const mirrorUrl = 'http://127.0.0.1:' + serverPort + '/'
+
+    let testServer: TestServer
+    const abortController = new AbortController()
+    const path = '/tmp/downloadGeoIpDatabaseTest/'
+
+    beforeAll(async () => {
+        testServer = new TestServer()
+        await testServer.start(serverPort)
+    }, 120000)
+
+    afterAll(async () => {
+        testServer!.stop()
+    })
+
+    beforeEach(() => {
+        try {
+            fs.rmSync(path, { recursive: true })
+        } catch (e) {
+            // ignore error when removing the test data
+        }
+    })
+
+    it('downloads the database with correct file permissions', async () => {
+        const reader = await downloadGeoIpDatabase(path, false, abortController.signal, mirrorUrl)
+
+        expect(fs.existsSync(path)).toBe(true)
+        expect(fs.existsSync(path + '/GeoLite2-City.mmdb')).toBe(true)
+
+        // https://www.martin-brennan.com/nodejs-file-permissions-fstat/
+        const permissions = fs.statSync(path + '/GeoLite2-City.mmdb').mode & 0o777
+        
+        // on windows the permissions might be 0o666
+        expect(permissions === 0o600 || permissions === 0o666).toBe(true)
+        expect(reader).toBeDefined()
+    }, 60000)
+
+    it('throws if the path is not writable', async () => {
+        const path = '/etc/downloadGeoIpDatabaseTest/'
+        await expect(downloadGeoIpDatabase(path, false, abortController.signal, mirrorUrl)).rejects.toThrow()
+    }, 60000)
+
+    it('throws if the path does not exist', async () => {
+        const path = '/nonexistent/downloadGeoIpDatabaseTest/'
+        await expect(downloadGeoIpDatabase(path, false, abortController.signal, mirrorUrl)).rejects.toThrow()
+    }, 60000)
+
+    it('does not download the database if it is already up to date', async () => {
+        const path = '/tmp/downloadGeoIpDatabaseTest/'
+        
+        const newReader = await downloadGeoIpDatabase(path, false, abortController.signal, mirrorUrl)
+        expect(newReader).toBeDefined()
+
+        const newReader2 = await downloadGeoIpDatabase(path, false, abortController.signal, mirrorUrl)
+        expect(newReader2).toBeUndefined()
+        
+        const newReader3 = await downloadGeoIpDatabase(path, true, abortController.signal, mirrorUrl)
+        expect(newReader3).toBeDefined()
+    }, 60000)
+})

package/test/unit/tarHelper.test.ts

@@ -0,0 +1,92 @@
+import { waitForEvent3 } from '@streamr/utils'
+import { extractFileFromTarStream } from '../../src/tarHelper'
+import { TestServer, TestServerEvents } from '../helpers/TestServer'
+
+describe('tarHelper', () => {
+    const serverUrl = 'http://127.0.0.1:'
+    const dbFileName = 'GeoLite2-City.mmdb'
+    const tarFileName = 'GeoLite2-City.tar.gz'
+    const hashFileName = 'GeoLite2-City.mmdb.sha384'
+
+    let testServer: TestServer
+
+    afterEach(async () => {
+        await testServer!.stop()
+    })
+
+    describe('testsWithNormalServer', () => {
+        const serverPort = 3197
+        
+        beforeEach(async () => {
+            testServer = new TestServer()
+            await testServer.start(serverPort)
+        })
+
+        it('happy path', async () => {
+            const url = serverUrl + serverPort + '/' + tarFileName
+            const result = await fetch(url, { keepalive: false })
+        
+            await extractFileFromTarStream(dbFileName, result.body!, '/tmp')
+            
+        })
+
+        it('throws asynchonously if the stream contains garbage', async () => {
+            const url = serverUrl + serverPort + '/' + hashFileName
+            const result = await fetch(url)
+            
+            await expect(extractFileFromTarStream(dbFileName, result.body!, '/tmp'))
+                .rejects
+                .toThrow('TAR_BAD_ARCHIVE: Unrecognized archive format')
+
+        })
+
+        it('throws asynchonously if the stream does not contain the desired file', async () => {
+            const url = serverUrl + serverPort + '/' + tarFileName
+            const result = await fetch(url)
+
+            await expect(extractFileFromTarStream('nonexisting-filename', result.body!, '/tmp'))
+                .rejects
+                .toThrow('File not found in tarball: nonexisting-filename')
+
+        })
+    })
+
+    describe('testsWithThrottledServer', () => {
+        const serverPort = 3198
+       
+        beforeEach(async () => {
+            testServer = new TestServer()
+            await testServer.start(serverPort, 1)
+        })
+
+        it('throws asynchonously if the stream gets aborted', async () => {
+            const abortController = new AbortController()
+
+            setTimeout(() => {
+                abortController.abort()
+            }, 5000)
+
+            const url = serverUrl + serverPort + '/' + tarFileName
+            const result = await fetch(url, { signal: abortController.signal })
+
+            await expect(extractFileFromTarStream(dbFileName, result.body!, '/tmp'))
+                .rejects
+                .toThrow('AbortError: This operation was aborted')
+
+        }, 15 * 1000)
+
+        it('throws asynchonously if server gets shut down', async () => {
+            const closedPromise = waitForEvent3<TestServerEvents>(testServer!, 'closed', 10000)
+            setTimeout(async () => {
+                await testServer!.stop()
+            }, 5000)
+
+            const url = serverUrl + serverPort + '/' + tarFileName
+            const result = await fetch(url)
+            await expect(extractFileFromTarStream(dbFileName, result.body!, '/tmp'))
+                .rejects
+                .toThrow('Error extracting tarball')
+            await closedPromise
+        }, 15 * 1000)
+    })
+})

package/tsconfig.browser.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.browser.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDirs": ["src", "test"],
+    "noImplicitOverride": false
+  },
+  "include": [
+    "src/**/*",
+    "test/**/*"
+  ]
+}

package/tsconfig.jest.json

@@ -0,0 +1,14 @@
+{
+    "extends": "../../tsconfig.jest.json",
+    "compilerOptions": {
+        "outDir": "dist",
+        "noImplicitOverride": false
+    },
+    "include": [
+        "src/**/*",
+        "test/**/*"
+    ],
+    "references": [
+        { "path": "../utils/tsconfig.node.json" }
+    ]
+}

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./tsconfig.jest.json"
+}

package/tsconfig.node.json

@@ -0,0 +1,13 @@
+{
+    "extends": "../../tsconfig.node.json",
+    "compilerOptions": {
+        "outDir": "dist",
+        "noImplicitOverride": false
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "references": [
+        { "path": "../utils/tsconfig.node.json" },
+    ]
+}