Archived
1
0
This repository has been archived on 2024-09-09. You can view files and clone it, but cannot push or open issues or pull requests.
code-server/test/unit/node/update.test.ts

174 lines
5.2 KiB
TypeScript
Raw Normal View History

import * as http from "http"
import * as path from "path"
import { SettingsProvider, UpdateSettings } from "../../../src/node/settings"
import { LatestResponse, UpdateProvider } from "../../../src/node/update"
import { clean, mockLogger, tmpdir } from "../../utils/helpers"
2021-05-04 00:39:59 +02:00
describe("update", () => {
let version = "1.0.0"
let spy: string[] = []
const server = http.createServer((request: http.IncomingMessage, response: http.ServerResponse) => {
if (!request.url) {
throw new Error("no url")
}
spy.push(request.url)
// Return the latest version.
if (request.url === "/latest") {
const latest: LatestResponse = {
name: version,
}
response.writeHead(200)
return response.end(JSON.stringify(latest))
}
// Anything else is a 404.
response.writeHead(404)
response.end("not found")
})
let _settings: SettingsProvider<UpdateSettings> | undefined
const settings = (): SettingsProvider<UpdateSettings> => {
if (!_settings) {
throw new Error("Settings provider has not been created")
}
return _settings
}
2020-10-21 01:05:58 +02:00
let _provider: UpdateProvider | undefined
const provider = (): UpdateProvider => {
if (!_provider) {
throw new Error("Update provider has not been created")
}
return _provider
}
2021-01-08 21:55:47 +01:00
beforeAll(async () => {
mockLogger()
const testName = "update"
await clean(testName)
const testDir = await tmpdir(testName)
const jsonPath = path.join(testDir, "update.json")
_settings = new SettingsProvider<UpdateSettings>(jsonPath)
2020-03-04 17:31:59 +01:00
await new Promise((resolve, reject) => {
server.on("error", reject)
server.on("listening", resolve)
server.listen({
port: 0,
host: "localhost",
})
})
const address = server.address()
if (!address || typeof address === "string" || !address.port) {
throw new Error("unexpected address")
}
_provider = new UpdateProvider(`http://${address.address}:${address.port}/latest`, _settings)
})
2021-01-08 21:55:47 +01:00
afterAll(() => {
server.close()
})
beforeEach(() => {
spy = []
})
it("should get the latest", async () => {
version = "2.1.0"
const p = provider()
const now = Date.now()
const update = await p.getUpdate()
await expect(settings().read()).resolves.toEqual({ update })
2021-01-08 21:55:47 +01:00
expect(isNaN(update.checked)).toEqual(false)
expect(update.checked < Date.now() && update.checked >= now).toEqual(true)
2021-05-04 00:39:59 +02:00
expect(update.version).toStrictEqual("2.1.0")
2021-01-08 21:55:47 +01:00
expect(spy).toEqual(["/latest"])
})
it("should keep existing information", async () => {
version = "3.0.1"
const p = provider()
const now = Date.now()
const update = await p.getUpdate()
await expect(settings().read()).resolves.toEqual({ update })
2021-05-04 00:39:59 +02:00
expect(isNaN(update.checked)).toStrictEqual(false)
2021-01-08 21:55:47 +01:00
expect(update.checked < now).toBe(true)
2021-05-04 00:39:59 +02:00
expect(update.version).toStrictEqual("2.1.0")
2021-01-08 21:55:47 +01:00
expect(spy).toEqual([])
})
it("should force getting the latest", async () => {
version = "4.1.1"
const p = provider()
const now = Date.now()
const update = await p.getUpdate(true)
await expect(settings().read()).resolves.toEqual({ update })
2021-05-04 00:39:59 +02:00
expect(isNaN(update.checked)).toStrictEqual(false)
expect(update.checked < Date.now() && update.checked >= now).toStrictEqual(true)
expect(update.version).toStrictEqual("4.1.1")
expect(spy).toStrictEqual(["/latest"])
})
it("should get latest after interval passes", async () => {
const p = provider()
await p.getUpdate()
2021-01-08 21:55:47 +01:00
expect(spy).toEqual([])
let checked = Date.now() - 1000 * 60 * 60 * 23
await settings().write({ update: { checked, version } })
await p.getUpdate()
2021-01-08 21:55:47 +01:00
expect(spy).toEqual([])
checked = Date.now() - 1000 * 60 * 60 * 25
await settings().write({ update: { checked, version } })
const update = await p.getUpdate()
2021-05-04 00:39:59 +02:00
expect(update.checked).not.toStrictEqual(checked)
expect(spy).toStrictEqual(["/latest"])
})
it("should check if it's the current version", async () => {
version = "9999999.99999.9999"
const p = provider()
let update = await p.getUpdate(true)
2021-05-04 00:39:59 +02:00
expect(p.isLatestVersion(update)).toStrictEqual(false)
version = "0.0.0"
update = await p.getUpdate(true)
2021-05-04 00:39:59 +02:00
expect(p.isLatestVersion(update)).toStrictEqual(true)
// Old version format; make sure it doesn't report as being later.
version = "999999.9999-invalid999.99.9"
update = await p.getUpdate(true)
2021-05-04 00:39:59 +02:00
expect(p.isLatestVersion(update)).toStrictEqual(true)
})
it("should not reject if unable to fetch", async () => {
let provider = new UpdateProvider("invalid", settings())
2021-05-04 00:39:59 +02:00
let now = Date.now()
let update = await provider.getUpdate(true)
expect(isNaN(update.checked)).toStrictEqual(false)
expect(update.checked < Date.now() && update.checked >= now).toEqual(true)
expect(update.version).toStrictEqual("unknown")
provider = new UpdateProvider("http://probably.invalid.dev.localhost/latest", settings())
2021-05-04 00:39:59 +02:00
now = Date.now()
update = await provider.getUpdate(true)
expect(isNaN(update.checked)).toStrictEqual(false)
expect(update.checked < Date.now() && update.checked >= now).toEqual(true)
expect(update.version).toStrictEqual("unknown")
})
})