@streamr/geoip-location 103.0.0-rc.0 → 103.0.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamr/geoip-location",
-  "version": "103.0.0-rc.0",
+  "version": "103.0.0-rc.1",
   "description": "Library for getting location information from IP addresses based on MaxMind GeoLite2 databases",
   "repository": {
     "type": "git",
@@ -14,6 +14,12 @@
     "dist/src/downloadGeoIpDatabase.js": false
   },
   "types": "dist/src/exports.d.ts",
+  "files": [
+    "dist",
+    "!*.tsbuildinfo",
+    "README.md",
+    "LICENSE"
+  ],
   "license": "Apache-2.0",
   "author": "Streamr Network AG <contact@streamr.network>",
   "scripts": {
@@ -25,7 +31,7 @@
     "test-unit": "jest test/unit"
   },
   "dependencies": {
-    "@streamr/utils": "103.0.0-rc.0",
+    "@streamr/utils": "103.0.0-rc.1",
     "eventemitter3": "^5.0.0",
     "long-timeout": "^0.1.1",
     "mmdb-lib": "^2.1.1",

package/jest.config.ts

@@ -1 +0,0 @@
-export { default } from '../../jest.config'

package/src/GeoIpLocator.ts

@@ -1,109 +0,0 @@
-import { Logger, filePathToNodeFormat } from '@streamr/utils'
-import { CityResponse, Reader } from 'mmdb-lib'
-import LongTimeout from 'long-timeout'
-import { downloadGeoIpDatabase } from './downloadGeoIpDatabase'
-
-const logger = new Logger(module)
-
-interface GeoIpLookupResult {
-    latitude: number
-    longitude: number
-}
-
-// 30 days in milliseconds
-const DEFAULT_DB_CHECK_INTERVAL = 30 * 24 * 60 * 60 * 1000
-// 24 hours in milliseconds
-const DEFAULT_DB_CHECK_ERROR_INTERVAL = 24 * 60 * 60 * 1000
-
-export class GeoIpLocator { 
-    private abortController: AbortController
-    private readonly geoIpDatabaseFolder: string
-    private readonly dbCheckInterval: number
-    private readonly dbCheckErrorInterval: number
-    private readonly mirrorUrl?: string
-    private reader?: Reader<CityResponse>
-    private dbCheckTimeout?: LongTimeout.Timeout
-
-    constructor(
-        geoIpDatabaseFolder: string,
-        dbCheckInterval = DEFAULT_DB_CHECK_INTERVAL,
-        dbCheckErrorInterval = DEFAULT_DB_CHECK_ERROR_INTERVAL,
-        mirrorUrl?: string
-    ) {
-        this.abortController = new AbortController()
-        this.dbCheckInterval = dbCheckInterval
-        this.dbCheckErrorInterval = dbCheckErrorInterval
-        if (!geoIpDatabaseFolder.endsWith('/')) {
-            geoIpDatabaseFolder += '/'
-        }
-        this.geoIpDatabaseFolder = filePathToNodeFormat(geoIpDatabaseFolder)
-        this.mirrorUrl = mirrorUrl
-    }
-
-    private checkDatabase: () => Promise<void> = async () => {
-        if (this.reader === undefined) {
-            // if we do not have a reader, create a new one in any case
-            this.reader = await downloadGeoIpDatabase(this.geoIpDatabaseFolder, true, this.abortController.signal, this.mirrorUrl)
-        } else {
-            // if we already have a reader, create a new one only if db has changed
-            const newReader = await downloadGeoIpDatabase(this.geoIpDatabaseFolder, false, this.abortController.signal, this.mirrorUrl)
-            if (newReader !== undefined) {
-                this.reader = newReader
-            }
-        }
-    }
-
-    private scheduleCheck: (timeout: number) => void = async (timeout: number) => {
-        if (this.abortController.signal.aborted) {
-            return
-        }
-        this.dbCheckTimeout = LongTimeout.setTimeout(async () => {
-            try {
-                await this.checkDatabase()
-                this.scheduleCheck(this.dbCheckInterval)
-            } catch (err) {
-                logger.warn('GeoIpLocator: GeoIP database check failed', { err })
-                this.scheduleCheck(this.dbCheckErrorInterval)
-            } 
-        }, timeout)
-    }
-
-    async start(): Promise<void> {
-        if (this.dbCheckTimeout !== undefined) {
-            return
-        }
-        await this.checkDatabase()
-        this.scheduleCheck(this.dbCheckInterval)
-    }
-
-    stop(): void {
-        if (this.dbCheckTimeout !== undefined) {
-            LongTimeout.clearTimeout(this.dbCheckTimeout)
-        }
-        this.abortController.abort()
-    }
-
-    lookup(ip: string): GeoIpLookupResult | undefined {
-        if (this.reader === undefined) {
-            logger.warn('GeoIpLocator: lookup called before database is ready (maybe start() was not called?')
-            return undefined
-        }
-
-        // If ip is falsy, the library will crash
-        // this might happen despite the ts typings because the ip address 
-        // comes from the ws server socket and is not under our control
-        if (!ip) {
-            return undefined
-        }
-
-        const result = this.reader.get(ip)
-        if (!result?.location?.latitude || !result.location.longitude) {
-            return undefined
-        } else {
-            return {
-                latitude: result.location.latitude,
-                longitude: result.location.longitude
-            }
-        }
-    }
-}

package/src/downloadGeoIpDatabase.ts

@@ -1,185 +0,0 @@
-import crypto from 'crypto'
-import fs from 'fs'
-import { CityResponse, Reader } from 'mmdb-lib'
-import { extractFileFromTarStream } from './tarHelper'
-import { v4 } from 'uuid'
-import { Logger } from '@streamr/utils'
-
-const GEOIP_MIRROR_URL = 'https://raw.githubusercontent.com/GitSquared/node-geolite2-redist/master/redist/'
-const DB_NAME = 'GeoLite2-City'
-const TAR_SUFFFIX = '.tar.gz'
-const DB_SUFFIX = '.mmdb'
-const HASH_SUFFIX = '.mmdb.sha384'
-
-const logger = new Logger(module)
-
-const downloadNewDb = async (
-    url: string,
-    dbFolder: string,
-    remoteHash: string,
-    abortSignal: AbortSignal
-): Promise<void> => {
-    // make a unique name for the temporary download folder
-    // in case there are multiple downloads happening at the same time
-
-    const uniqueName = v4()
-    const downloadFolder = dbFolder + '.download' + uniqueName
-    const dbFileName = DB_NAME + DB_SUFFIX
-    const dbFileInDownloadFolder = downloadFolder + '/' + dbFileName
-    const dbFileInDbFolder = dbFolder + dbFileName
-
-    let response: Response
-
-    try {
-        logger.debug('Downloading GeoIP database from: ' + url)
-        response = await fetch(url, { keepalive: false, signal: abortSignal })
-    } catch (e) {
-        // Catching and re-throwing as async exception 
-        // here is necessary, synch exceptions cannot be caught by the caller
-        throw new Error('Fetch error when downloading ' + url + ', error: ' + e)
-    }
-
-    if (!response.ok) {
-        throw new Error('HTTP error when downloading ' + url + ', status: ' + response.status)
-    }
-
-    // extract the tarball to a temporary folder
-
-    try {
-        fs.mkdirSync(downloadFolder, { recursive: true })
-    } catch (e) {
-        throw new Error('Error creating temporary folder ' + downloadFolder + ', error: ' + e)
-    }
-
-    try {
-        await extractFileFromTarStream(dbFileName, response.body!, downloadFolder)
-    } catch (e) {
-        try {
-            fs.rmSync(downloadFolder, { recursive: true })
-        } catch {
-            // ignore error when removing the temporary folder
-        }
-        throw e
-    }
-
-    // check the hash of the extracted file
-
-    if (!isDbFileValid(dbFileInDownloadFolder, remoteHash)) {
-        try {
-            fs.rmSync(downloadFolder, { recursive: true })
-        } catch {
-            // ignore error when removing the temporary folder
-        }
-        throw new Error('Downloaded database hash does not match the expected hash')
-    }
-
-    try {
-        // move the extracted file to the correct location
-        fs.renameSync(dbFileInDownloadFolder, dbFileInDbFolder)
-    } catch (e) {
-        throw new Error('Error moving ' + dbFileInDownloadFolder + ' to ' + dbFileInDbFolder + ', error: ' + e)
-    } finally {
-        try {
-            fs.rmSync(downloadFolder, { recursive: true })
-        } catch {
-            // ignore error when removing the temporary folder
-        }
-    }
-
-    // set the db file permissions to rw only for the owner
-
-    try {
-        fs.chmodSync(dbFileInDbFolder, 0o600)
-    } catch (err) {
-        throw new Error('Error setting permissions on ' + dbFileInDbFolder + ', error: ' + err)
-    }
-
-    logger.debug('Downloaded GeoIP database to: ' + dbFileInDbFolder)
-
-}
-
-const downloadRemoteHash = async (remoteHashUrl: string, abortSignal: AbortSignal): Promise<string> => {
-    // download the hash of the latest GeoIP database using fetch as text and trim it
-    let response: Response
-
-    try {
-        logger.debug('Downloading GeoIP database hash from: ' + remoteHashUrl)
-        response = await fetch(remoteHashUrl, { signal: abortSignal })
-    } catch (e) {
-        // Catching and re-throwing as async exception 
-        // here is necessary, synch exceptions cannot be caught by the caller
-        throw new Error('Fetch error when downloading ' + remoteHashUrl + ', error: ' + e)
-    }
-
-    if (!response.ok) {
-        throw new Error('HTTP error when downloading ' + remoteHashUrl + ', status: ' + response.status)
-    }
-
-    return (await response.text()).trim()
-}
-
-const isDbFileValid = (dbFile: string, remoteHash: string): boolean => {
-    // check if the local db exists and calculate its hash
-
-    try {
-        const db = fs.readFileSync(dbFile)
-        const localHash = crypto.createHash('sha384').update(db).digest('hex')
-
-        // if the hashes are different, download the latest database
-        if (localHash !== remoteHash) {
-            return false
-        } else {
-            return true
-        }
-    } catch {
-        // if the local db does not exist, or some other exception occurres db is not considered valid
-        return false
-    }
-}
-
-// returns a Reader if a new db was downloaded, or if the caller wants to force return a reader
-// also if there was no need to download a new db
-
-export const downloadGeoIpDatabase = async (
-    dbFolder: string,
-    forceReturnReader: boolean,
-    abortSignal: AbortSignal,
-    mirrorUrl?: string
-): Promise<Reader<CityResponse> | undefined> => {
-    // This will throw if the download folder is not readable
-    if (!fs.existsSync(dbFolder)) {
-        // This will throw if the download folder is not writable
-        fs.mkdirSync(dbFolder, { recursive: true })
-    }
-    if (!dbFolder.endsWith('/')) {
-        dbFolder += '/'
-    }
-    let geoIpMirrorUrl = GEOIP_MIRROR_URL
-    if (mirrorUrl !== undefined) {
-        if (!mirrorUrl.endsWith('/')) {
-            mirrorUrl += '/'
-        }
-        geoIpMirrorUrl = mirrorUrl
-    }
-    const remoteHashUrl = geoIpMirrorUrl + DB_NAME + HASH_SUFFIX
-    const dbDownloadUrl = geoIpMirrorUrl + DB_NAME + TAR_SUFFFIX
-    const dbFileInDbFolder = dbFolder + DB_NAME + DB_SUFFIX
-
-    const remoteHash = await downloadRemoteHash(remoteHashUrl, abortSignal)
-    const dbValid = isDbFileValid(dbFileInDbFolder, remoteHash)
-    if (dbValid === false) {
-        await downloadNewDb(dbDownloadUrl, dbFolder, remoteHash, abortSignal)
-        // return new reader if db was downloaded
-        return new Reader<CityResponse>(fs.readFileSync(dbFileInDbFolder))
-    } else {
-        logger.debug('The hash of the local GeoIP database matches the remote hash, no need to download a new database')
-    }
-    if (forceReturnReader) {
-        // return reader also for old db the caller wants it
-        return new Reader<CityResponse>(fs.readFileSync(dbFileInDbFolder))
-    } else {
-        // return undefined if the db is already up to date
-        return undefined
-    }
-}
-

package/src/exports.ts

@@ -1 +0,0 @@
-export { GeoIpLocator } from './GeoIpLocator'

package/src/tarHelper.ts

@@ -1,35 +0,0 @@
-import { Readable, pipeline } from 'stream'
-import { extract } from 'tar'
-import { ReadableStream } from 'stream/web'
-import NodePath from 'path'     // use NodePath to avoid conflict with other 'path' symbols
-import fs from 'fs'
-
-const doExtractFileFromTarStream = (fileName: string, stream: ReadableStream<any>, downloadFolder: string): Promise<void> => {
-    return new Promise((resolve, reject) => {
-        try {
-            const nodeStream = Readable.fromWeb(stream)
-            pipeline(nodeStream,
-                extract({
-                    cwd: downloadFolder,
-                    filter: (entryPath: string): boolean => NodePath.basename(entryPath) === fileName,
-                    strip: 1
-                }), (err) => {
-                    if (err) {
-                        reject(new Error('Error extracting tarball to ' + downloadFolder + ', error: ' + err))
-                    } else {
-                        resolve()
-                    }
-                })
-        } catch (e) {
-            reject(new Error('Failed to create nodejs Readable from web stream: ' + e))
-        }
-    })
-}
-
-export const extractFileFromTarStream = async (fileName: string, stream: ReadableStream<any>, downloadFolder: string): Promise<void> => {
-    await doExtractFileFromTarStream(fileName, stream, downloadFolder)
-    if (!fs.existsSync(NodePath.join(downloadFolder, fileName))) {
-        throw new Error('File not found in tarball: ' + fileName)
-    }
-}
-

package/test/helpers/TestServer.ts

@@ -1,176 +0,0 @@
-import express from 'express'
-import http from 'http'
-import { Logger, wait } from '@streamr/utils'
-import { fetchFileToMemory } from './fetchFileToMemory'
-import fs from 'fs'
-import { v4 } from 'uuid'
-import EventEmitter from 'eventemitter3'
-import { Duplex, pipeline } from 'stream'
-
-const logger = new Logger(module)
-
-type ExpressType = ReturnType<typeof express>
-type ServerType = ReturnType<ExpressType['listen']>
-
-const dbUrl = 'https://raw.githubusercontent.com/GitSquared/node-geolite2-redist/master/redist/GeoLite2-City.tar.gz'
-const hashUrl = 'https://raw.githubusercontent.com/GitSquared/node-geolite2-redist/master/redist/GeoLite2-City.mmdb.sha384'
-
-const dbFileName = '/GeoLite2-City.tar.gz'
-const hashFileName = '/GeoLite2-City.mmdb.sha384'
-
-const CACHE_PATH = '/tmp/geoip-location-test-cache'
-
-export interface TestServerEvents {
-    closed: () => void
-}
-
-function bufferToStream(buf: Buffer) {
-    const tmp = new Duplex()
-    tmp.push(buf)
-    tmp.push(null)
-    return tmp
-}
-
-export class TestServer extends EventEmitter<TestServerEvents> {
-    private server?: ServerType
-    private abortController?: AbortController
-
-    private static hashData?: Uint8Array
-    private static dbData?: Uint8Array
-
-    private static async prefetchData(): Promise<void> {
-
-        TestServer.hashData = await fetchFileToMemory(hashUrl)
-
-        // check if db data is already prefetched to CACHE_PATH
-
-        if (fs.existsSync(CACHE_PATH + hashFileName) && fs.existsSync(CACHE_PATH + dbFileName)) {
-            // read hash data from CACHE_PATH
-            const cachedHash = fs.readFileSync(CACHE_PATH + hashFileName)
-
-            if (cachedHash.equals(TestServer.hashData)) {
-                TestServer.dbData = fs.readFileSync(CACHE_PATH + dbFileName)
-                return
-            }
-        }
-
-        // eslint-disable-next-line require-atomic-updates
-        TestServer.dbData = await fetchFileToMemory(dbUrl)
-
-        // save db and hash data to CACHE_PATH
-        try {
-            fs.mkdirSync(CACHE_PATH, { recursive: true })
-        } catch {
-            // ignore error when creating the cache folder
-        }
-        // ensure there is never an incomplete file in the fs
-        const uniqueName = v4()
-
-        fs.writeFileSync(CACHE_PATH + hashFileName + uniqueName, TestServer.hashData)
-        fs.renameSync(CACHE_PATH + hashFileName + uniqueName, CACHE_PATH + hashFileName)
-
-        fs.writeFileSync(CACHE_PATH + dbFileName + uniqueName, TestServer.dbData)
-        fs.renameSync(CACHE_PATH + dbFileName + uniqueName, CACHE_PATH + dbFileName)
-    }
-
-    private async writeDataKilobytesPerSecond(res: http.ServerResponse, data: Uint8Array, kilobytesPerSecond?: number): Promise<void> {
-        let delayMilliseconds = 1
-
-        if (kilobytesPerSecond) {
-            delayMilliseconds = 1000 / kilobytesPerSecond
-        }
-        const chuckSize = 1024
-        for (let i = 0; i < data.length && !this.abortController?.signal.aborted; i += chuckSize) {
-            let end = i + chuckSize
-            if (end > data.length) {
-                end = data.length
-            }
-
-            res.write(data.slice(i, end))
-
-            if (delayMilliseconds !== undefined) {
-                await wait(delayMilliseconds, this.abortController?.signal)
-            } else {
-                await wait(0, this.abortController?.signal)
-            }
-        }
-    }
-
-    startServer(port: number, kiloBytesPerSecond?: number): Promise<void> {
-        return new Promise((resolve, _reject) => {
-            const app = express()
-
-            app.get(dbFileName, (_req, res) => {
-                if (kiloBytesPerSecond !== undefined) {
-                    res.setHeader('Content-Type', 'application/gzip')
-                    this.writeDataKilobytesPerSecond(res, TestServer.dbData!,
-                        kiloBytesPerSecond).then(() => {
-                        res.end()
-                    }).catch((_err) => {
-                        res.end()
-                    })
-                } else {
-                    // send data without throttling from file
-                    const readable = bufferToStream(Buffer.from(TestServer.dbData!))
-                    pipeline(readable, res, (err) => {
-                        if (err) {
-                            logger.error('Error sending db file: ', { err })
-                        }
-                    })
-                }
-            })
-
-            app.get(hashFileName, (_req, res) => {
-                // always send hash data without throttling
-                const readable = bufferToStream(Buffer.from(TestServer.hashData!))
-                pipeline(readable, res, (err) => {
-                    if (err) {
-                        logger.error('Error sending hash file: ', { err })
-                    }
-                })
-            })
-
-            this.server = app.listen(port, '127.0.0.1', () => {
-                logger.info('Test server is running on port ' + port)
-                
-                // The server is not really ready after listen callback, possible bug in express
-                setTimeout(() => {
-                    resolve()
-                }, 1000)
-            })
-        })
-    }
-
-    async start(port: number, kiloBytesPerSecond?: number): Promise<void> {
-        if (!TestServer.hashData || !TestServer.dbData) {
-            await TestServer.prefetchData()
-        }
-
-        if (this.server) {
-            throw new Error('Test server already running')
-        }
-
-        this.abortController = new AbortController()
-        await this.startServer(port, kiloBytesPerSecond)
-    }
-
-    stop(): Promise<void> {
-        return new Promise((resolve, _reject) => {
-            if (this.server) {
-                this.abortController!.abort()
-
-                this.server.close((err) => {
-                    if (err) {
-                        logger.warn('Error closing server: ', { err })
-                    }
-                    this.server = undefined
-                    this.emit('closed')
-                    resolve()
-                })
-                this.server.closeAllConnections()
-            } else {
-                resolve()
-            }
-        })
-    }
-}

package/test/helpers/fetchFileToMemory.ts

@@ -1,7 +0,0 @@
-export const fetchFileToMemory = async (url: string): Promise<Uint8Array> => {
-    const response = await fetch(url)
-    if (!response.ok) {
-        throw new Error('HTTP error when downloading ' + url + ', status: ' + response.status)
-    }
-    return new Uint8Array(await response.arrayBuffer())
-}

package/test/unit/GeoIpLocator-intervals.test.ts

@@ -1,107 +0,0 @@
-import { GeoIpLocator } from '../../src/GeoIpLocator'
-import { wait, until } from '@streamr/utils'
-import fs from 'fs'
-import { TestServer } from '../helpers/TestServer'
-
-describe('GeoIpLocator', () => {
-  
-    const serverPort = 31991
-    const mirrorUrl = 'http://127.0.0.1:' + serverPort + '/'
-
-    const DB_FILENAME = 'GeoLite2-City.mmdb'
-    let dirCounter = 0
-    const dbPath = '/tmp'
-    let dbDir: string
-    let locator: GeoIpLocator
-    let testServer: TestServer
-
-    const getDbDir = () => {
-        dirCounter++
-        return dbPath + '/geolitelocator2-intervals' + dirCounter
-    }
-
-    beforeAll(async () => {
-        testServer = new TestServer()
-        await testServer.start(serverPort)
-    }, 120000)
-    
-    afterEach(async () => {
-        locator!.stop()
-        testServer!.stop()
-        fs.rmSync(dbDir!, { recursive: true })
-    })
-
-    it('schedules a new check with a diffrent interval if monthly database check fails', async () => {
-        
-        dbDir = getDbDir()
-
-        try {
-            fs.unlinkSync(dbDir + '/' + DB_FILENAME)
-        } catch {
-            // ignore
-        }
-
-        locator = new GeoIpLocator(dbDir, 3000, 1000, mirrorUrl)
-       
-        // start locator normally
-        await locator.start()
-
-        // delete the db
-        try {
-            fs.unlinkSync(dbDir + '/' + DB_FILENAME)
-        } catch {
-            // ignore
-        }
-
-        // mock fetch to fail
-        const fetchMock = jest
-            .spyOn(globalThis, 'fetch')
-            .mockImplementation(async () => {
-                throw new Error('API is down')
-            })
-
-        // wait for the first check to happen
-        await wait(3500)
-
-        // normal check interval should have been run 
-        // after 3000ms, this should have tried
-        // downloading the hash, but failed
-
-        expect(fetchMock).toHaveBeenCalledTimes(1)
-
-        // wait for the failure interval to happen
-        await wait(1200)
-
-        // failure interval should have been run after 1500ms from the failure
-        // it should have tried downloading the hash again and
-        // failed
-
-        expect(fetchMock).toHaveBeenCalledTimes(2)
-
-        // restore fetch 
-        fetchMock.mockRestore()
-        
-        // mock fetch again to just count the calls
-        const fetchMock2 = jest
-            .spyOn(globalThis, 'fetch')
-            
-        // wait for failure interval to happen
-        await wait(1200)
-        
-        // failure interval should have downloaded
-        // both the hash and the db
-
-        expect(fetchMock2).toHaveBeenCalledTimes(2)
-        
-        // expect the db to be there
-        await until(() => fs.existsSync(dbDir + '/' + DB_FILENAME), 10000)
-
-        // helsinki.fi
-        const location = locator.lookup('128.214.222.50')
-        expect(location).toBeDefined()
-
-        // Helsinki, Finland
-        expect(location!.latitude).toBeCloseTo(60.1719, 1)
-        expect(location!.longitude).toBeCloseTo(24.9347, 1)
-    }, 60000)
-})

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

@@ -1,55 +0,0 @@
-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()
-
-        // helsinki.fi
-        const location = locator!.lookup('128.214.222.50')
-        expect(location).toBeDefined()
-
-        // Helsinki, Finland
-        expect(location!.latitude).toBeCloseTo(60.1719, 1)
-        expect(location!.longitude).toBeCloseTo(24.9347, 1)
-
-    }, 60000)
-})

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

@@ -1,29 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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()
-
-            // helsinki.fi
-            const location = locator.lookup('128.214.222.50')
-    
-            expect(location).toBeDefined()
-    
-            // Helsinki, Finland
-            expect(location!.latitude).toBeCloseTo(60.1719, 1)
-            expect(location!.longitude).toBeCloseTo(24.9347, 1)
-        
-            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)
-    
-            // helsinki.fi
-            const location = locator.lookup('128.214.222.50')
-            expect(location).toBeDefined()
-    
-            // Helsinki, Finland
-            expect(location!.latitude).toBeCloseTo(60.1719, 1)
-            expect(location!.longitude).toBeCloseTo(24.9347, 1)
-    
-            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)
-    
-            // helsinki.fi
-            const location = locator.lookup('128.214.222.50')
-            expect(location).toBeDefined()
-    
-            // Helsinki, Finland
-            expect(location!.latitude).toBeCloseTo(60.1719, 1)
-            expect(location!.longitude).toBeCloseTo(24.9347, 1)
-    
-            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('128.214.222.50')
-            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

@@ -1,66 +0,0 @@
-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 {
-            // 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

@@ -1,92 +0,0 @@
-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

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

package/tsconfig.jest.json

@@ -1,10 +0,0 @@
-{
-    "extends": "../../tsconfig.jest.json",
-    "include": [
-        "src/**/*",
-        "test/**/*"
-    ],
-    "references": [
-        { "path": "../utils/tsconfig.node.json" }
-    ]
-}

package/tsconfig.json

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

package/tsconfig.node.json

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