@scaleway/sdk-client 2.2.1 → 2.2.2

package/dist/internal/interceptors/__tests__/composer.test.js

@@ -0,0 +1,48 @@
+import { composeRequestInterceptors, composeResponseErrorInterceptors } from "../composer.js";
+import { describe, expect, it } from "vitest";
+//#region src/internal/interceptors/__tests__/composer.test.ts
+describe("composeRequestInterceptors", () => {
+	it("modifies the request header", async () => {
+		return expect(composeRequestInterceptors([({ request }) => {
+			const clone = request.clone();
+			clone.headers.set("new-header", "42");
+			return clone;
+		}])(new Request("https://api.scaleway.com")).then((obj) => obj.headers.get("new-header"))).resolves.toBe("42");
+	});
+});
+describe("composeResponseErrorInterceptors", () => {
+	it("passes the error to all interceptors if they all throw", () => {
+		class NumberError extends Error {
+			counter;
+			constructor(obj) {
+				super();
+				this.counter = obj;
+				Object.setPrototypeOf(this, NumberError.prototype);
+			}
+		}
+		return expect(composeResponseErrorInterceptors([({ error }) => {
+			throw error instanceof NumberError ? new NumberError(error.counter + 1) : error;
+		}, ({ error }) => {
+			throw error instanceof NumberError ? new NumberError(error.counter + 2) : error;
+		}])(new Request("https://api.scaleway.com"), new NumberError(42))).rejects.toThrow(new NumberError(45));
+	});
+	it("stops at the second interceptor (amongst three) if it resolves", () => {
+		return expect(composeResponseErrorInterceptors([
+			({ error }) => {
+				throw error;
+			},
+			() => Promise.resolve(42),
+			({ error }) => {
+				throw error;
+			}
+		])(new Request("https://api.scaleway.com"), /* @__PURE__ */ new TypeError(""))).resolves.toBe(42);
+	});
+	it("throws the last processed error", () => {
+		return expect(composeResponseErrorInterceptors([({ error }) => {
+			throw error;
+		}, () => {
+			throw new TypeError("second error");
+		}])(new Request("https://api.scaleway.com"), /* @__PURE__ */ new TypeError("first error"))).rejects.toThrow(/* @__PURE__ */ new TypeError("second error"));
+	});
+});
+//#endregion

package/dist/internal/interceptors/__tests__/helpers.test.js

@@ -0,0 +1,27 @@
+import { addAsyncHeaderInterceptor, addHeaderInterceptor } from "../helpers.js";
+import { describe, expect, it } from "vitest";
+//#region src/internal/interceptors/__tests__/helpers.test.ts
+describe("addHeaderInterceptor", () => {
+	it("insertsnothing if value is undefined", async () => {
+		const request = new Request("https://api.scaleway.com/my/path");
+		expect((await addHeaderInterceptor("my-key", void 0)({ request })).headers.has("my-key")).toBe(false);
+	});
+	it("inserts 1 key/value in the request", async () => {
+		const request = new Request("https://api.scaleway.com/my/path");
+		expect((await addHeaderInterceptor("my-key", "my-value")({ request })).headers.get("my-key")).toBe("my-value");
+	});
+	it(`doesn't modify the input request`, async () => {
+		const request = new Request("https://api.scaleway.com/my/path");
+		const originalHeaders = request.headers;
+		const updatedReq = await addHeaderInterceptor("my-key", "my-value")({ request });
+		expect(request.headers).toBe(originalHeaders);
+		expect(updatedReq.headers.get("my-key")).toBe("my-value");
+	});
+});
+describe("addAsyncHeaderInterceptor", () => {
+	it("inserts 1 key/value in the request", async () => {
+		const request = new Request("https://api.scaleway.com/my/path");
+		expect((await addAsyncHeaderInterceptor("my-key", async () => Promise.resolve("my-value"))({ request })).headers.get("my-key")).toBe("my-value");
+	});
+});
+//#endregion

package/dist/internal/interceptors/composer.js

@@ -1,3 +1,4 @@
+//#region src/internal/interceptors/composer.ts
 /**
 * Composes request interceptors.
 *
@@ -6,7 +7,7 @@
 *
 * @internal
 */
-const composeRequestInterceptors = (interceptors) => async (request) => interceptors.reduce(async (asyncResult, interceptor) => interceptor({ request: await asyncResult }), Promise.resolve(request));
+var composeRequestInterceptors = (interceptors) => async (request) => interceptors.reduce(async (asyncResult, interceptor) => interceptor({ request: await asyncResult }), Promise.resolve(request));
 /**
 * Composes response interceptors.
 *
@@ -15,13 +16,13 @@ const composeRequestInterceptors = (interceptors) => async (request) => intercep
 *
 * @internal
 */
-const composeResponseInterceptors = (interceptors) => async (response) => interceptors.reduce(async (asyncResult, interceptor) => interceptor({ response: await asyncResult }), Promise.resolve(response));
+var composeResponseInterceptors = (interceptors) => async (response) => interceptors.reduce(async (asyncResult, interceptor) => interceptor({ response: await asyncResult }), Promise.resolve(response));
 /**
 * Compose response error interceptors.
 *
 * @internal
 */
-const composeResponseErrorInterceptors = (interceptors) => async (request, error) => {
+var composeResponseErrorInterceptors = (interceptors) => async (request, error) => {
 	let prevError = error;
 	for (const interceptor of interceptors) try {
 		return await interceptor({
@@ -33,4 +34,5 @@ const composeResponseErrorInterceptors = (interceptors) => async (request, error
 	}
 	throw prevError;
 };
+//#endregion
 export { composeRequestInterceptors, composeResponseErrorInterceptors, composeResponseInterceptors };

package/dist/internal/interceptors/helpers.js

@@ -1,3 +1,4 @@
+//#region src/internal/interceptors/helpers.ts
 /**
 * Adds an header to a request through an interceptor.
 *
@@ -7,7 +8,7 @@
 *
 * @internal
 */
-const addHeaderInterceptor = (key, value) => ({ request }) => {
+var addHeaderInterceptor = (key, value) => ({ request }) => {
 	const clone = request.clone();
 	if (value !== void 0) clone.headers.append(key, value);
 	return clone;
@@ -21,5 +22,6 @@ const addHeaderInterceptor = (key, value) => ({ request }) => {
 *
 * @internal
 */
-const addAsyncHeaderInterceptor = (key, getter) => async (request) => addHeaderInterceptor(key, await getter())(request);
+var addAsyncHeaderInterceptor = (key, getter) => async (request) => addHeaderInterceptor(key, await getter())(request);
+//#endregion
 export { addAsyncHeaderInterceptor, addHeaderInterceptor };

package/dist/internal/logger/__tests__/index.test.js

@@ -0,0 +1,209 @@
+import { ConsoleLogger } from "../console-logger.js";
+import { enableConsoleLogger, getLogger, setLogger } from "../index.js";
+import { describe, expect, it, vi } from "vitest";
+//#region src/internal/logger/__tests__/index.test.ts
+var makeCallbackConsole = (onMessage) => ({
+	...console,
+	debug: onMessage,
+	error: onMessage,
+	info: onMessage,
+	warn: onMessage
+});
+var allLogLevels = [
+	"debug",
+	"info",
+	"warn",
+	"error"
+];
+var IS_LEVEL_ENOUGH_CASES = [
+	{
+		base: "debug",
+		tests: [
+			{
+				expected: true,
+				target: "debug"
+			},
+			{
+				expected: true,
+				target: "info"
+			},
+			{
+				expected: true,
+				target: "warn"
+			},
+			{
+				expected: true,
+				target: "error"
+			}
+		]
+	},
+	{
+		base: "info",
+		tests: [
+			{
+				expected: false,
+				target: "debug"
+			},
+			{
+				expected: true,
+				target: "info"
+			},
+			{
+				expected: true,
+				target: "warn"
+			},
+			{
+				expected: true,
+				target: "error"
+			}
+		]
+	},
+	{
+		base: "warn",
+		tests: [
+			{
+				expected: false,
+				target: "debug"
+			},
+			{
+				expected: false,
+				target: "info"
+			},
+			{
+				expected: true,
+				target: "warn"
+			},
+			{
+				expected: true,
+				target: "error"
+			}
+		]
+	},
+	{
+		base: "error",
+		tests: [
+			{
+				expected: false,
+				target: "debug"
+			},
+			{
+				expected: false,
+				target: "info"
+			},
+			{
+				expected: false,
+				target: "warn"
+			},
+			{
+				expected: true,
+				target: "error"
+			}
+		]
+	},
+	{
+		base: "unknown",
+		tests: [
+			{
+				expected: false,
+				target: "debug"
+			},
+			{
+				expected: false,
+				target: "info"
+			},
+			{
+				expected: false,
+				target: "warn"
+			},
+			{
+				expected: false,
+				target: "error"
+			}
+		]
+	}
+];
+describe("ConsoleLogger", () => {
+	it("initializes with the asked level", () => {
+		expect(new ConsoleLogger("info").logLevel).toBe("info");
+	});
+	it("returns the proper level boolean", () => {
+		const log = vi.fn().mockImplementation(() => {});
+		const out = makeCallbackConsole(log);
+		for (const test of IS_LEVEL_ENOUGH_CASES) {
+			const logger = new ConsoleLogger(test.base, "", out);
+			setLogger(logger);
+			for (const elt of test.tests) {
+				log.mockReset();
+				logger[elt.target](elt.target);
+				if (elt.expected) expect(log).toHaveBeenCalledWith(elt.target);
+				else expect(log).not.toHaveBeenCalledWith(elt.target);
+			}
+		}
+	});
+	it("prints the indicated output", () => {
+		const prefix = "test:";
+		let latestMessage = "";
+		const logger = new ConsoleLogger("debug", prefix, makeCallbackConsole((message) => {
+			latestMessage = message;
+		}));
+		for (const method of allLogLevels) {
+			const randomStr = (Math.random() + 1).toString(36).substring(7);
+			logger[method](randomStr);
+			expect(latestMessage).toBe(`${prefix} ${randomStr}`);
+		}
+	});
+	it("prints no output (as loglevel is silent)", () => {
+		let latestMessage = "";
+		const logger = new ConsoleLogger("silent", "test:", makeCallbackConsole((message) => {
+			latestMessage = message;
+		}));
+		for (const method of allLogLevels) {
+			const randomStr = (Math.random() + 1).toString(36).substring(7);
+			logger[method](randomStr);
+			expect(latestMessage).toBe("");
+		}
+	});
+});
+describe("setLogger", () => {
+	it(`changes the logger object when called'`, () => {
+		const initialLogger = getLogger();
+		setLogger(new ConsoleLogger("info"));
+		expect(initialLogger).not.toBe(getLogger());
+	});
+	it(`changes the logLevel when updated`, () => {
+		setLogger(new ConsoleLogger("warn"));
+		const { logLevel } = getLogger();
+		setLogger(new ConsoleLogger("debug"));
+		expect(getLogger().logLevel).not.toBe(logLevel);
+		expect(getLogger().logLevel).toBe("debug");
+	});
+});
+describe("enableConsoleLogger", () => {
+	it(`initializes console logger with warn level by default`, () => {
+		setLogger(new ConsoleLogger("silent"));
+		expect(getLogger().logLevel).toBe("silent");
+		enableConsoleLogger();
+		expect(getLogger().logLevel).toBe("warn");
+	});
+	it(`initializes console logger with given level`, () => {
+		enableConsoleLogger("silent");
+		expect(getLogger().logLevel).toBe("silent");
+		enableConsoleLogger("debug");
+		expect(getLogger().logLevel).toBe("debug");
+		enableConsoleLogger("info");
+		expect(getLogger().logLevel).toBe("info");
+		enableConsoleLogger("warn");
+		expect(getLogger().logLevel).toBe("warn");
+		enableConsoleLogger("error");
+		expect(getLogger().logLevel).toBe("error");
+	});
+	it(`replaces custom logger with new console logger`, () => {
+		const customLogger = new ConsoleLogger("error");
+		setLogger(customLogger);
+		expect(getLogger().logLevel).toBe(customLogger.logLevel);
+		enableConsoleLogger("warn");
+		expect(getLogger().logLevel).toBe("warn");
+		expect(getLogger()).not.toBe(customLogger);
+	});
+});
+//#endregion

package/dist/internal/logger/console-logger.js

@@ -1,4 +1,5 @@
 import { LevelResolver, shouldLog } from "./level-resolver.js";
+//#region src/internal/logger/console-logger.ts
 /**
 * A Logger using console output.
 *
@@ -26,4 +27,5 @@ var ConsoleLogger = class {
 	info = this.makeMethod("info");
 	warn = this.makeMethod("warn");
 };
+//#endregion
 export { ConsoleLogger };

package/dist/internal/logger/index.js

@@ -1,4 +1,5 @@
 import { ConsoleLogger } from "./console-logger.js";
+//#region src/internal/logger/index.ts
 var sdkLogger = new ConsoleLogger("silent");
 /**
 * Sets a logger to be used within the SDK.
@@ -7,7 +8,7 @@ var sdkLogger = new ConsoleLogger("silent");
 *
 * @public
 */
-const setLogger = (logger) => {
+var setLogger = (logger) => {
 	sdkLogger = logger;
 };
 /**
@@ -18,11 +19,12 @@ const setLogger = (logger) => {
 *
 * @public
 */
-const enableConsoleLogger = (logLevel = "warn", prefix = "scaleway-sdk-js:") => setLogger(new ConsoleLogger(logLevel, prefix));
+var enableConsoleLogger = (logLevel = "warn", prefix = "scaleway-sdk-js:") => setLogger(new ConsoleLogger(logLevel, prefix));
 /**
 * Returns the active SDK logger.
 *
 * @internal
 */
-const getLogger = () => sdkLogger;
+var getLogger = () => sdkLogger;
+//#endregion
 export { enableConsoleLogger, getLogger, setLogger };

package/dist/internal/logger/level-resolver.js

@@ -1,4 +1,5 @@
-let LevelResolver = /* @__PURE__ */ function(LevelResolver) {
+//#region src/internal/logger/level-resolver.ts
+var LevelResolver = /* @__PURE__ */ function(LevelResolver) {
 	LevelResolver[LevelResolver["silent"] = 0] = "silent";
 	LevelResolver[LevelResolver["error"] = 1] = "error";
 	LevelResolver[LevelResolver["warn"] = 2] = "warn";
@@ -6,5 +7,6 @@ let LevelResolver = /* @__PURE__ */ function(LevelResolver) {
 	LevelResolver[LevelResolver["debug"] = 4] = "debug";
 	return LevelResolver;
 }({});
-const shouldLog = (currentLevel, level) => LevelResolver[level] <= currentLevel;
+var shouldLog = (currentLevel, level) => LevelResolver[level] <= currentLevel;
+//#endregion
 export { LevelResolver, shouldLog };

package/dist/internal/validations/__tests__/string-validation.test.js

@@ -0,0 +1,98 @@
+import { isAccessKey, isEmail, isOrganizationId, isProjectId, isRegion, isSecretKey, isURL, isUUID, isZone } from "../string-validation.js";
+import { describe, expect, it } from "vitest";
+//#region src/internal/validations/__tests__/string-validation.test.ts
+var validUUIDs = ["00000000-0000-0000-0000-000000000000", "123e4567-e89b-12d3-a456-426614174000"];
+var invalidUUIDs = [
+	"",
+	"1",
+	"23e4567-e89b-12d3-a456-426614174000"
+];
+var validators = [
+	{
+		invalids: invalidUUIDs,
+		name: "UUID",
+		validator: isUUID,
+		valids: validUUIDs
+	},
+	{
+		invalids: [
+			"",
+			"SCW012345678",
+			"WCS01234567890123456"
+		],
+		name: "AccessKey",
+		validator: isAccessKey,
+		valids: ["SCW01234567890123456"]
+	},
+	{
+		invalids: invalidUUIDs,
+		name: "SecretKey",
+		validator: isSecretKey,
+		valids: validUUIDs
+	},
+	{
+		invalids: invalidUUIDs,
+		name: "Organization",
+		validator: isOrganizationId,
+		valids: validUUIDs
+	},
+	{
+		invalids: invalidUUIDs,
+		name: "Project",
+		validator: isProjectId,
+		valids: validUUIDs
+	},
+	{
+		invalids: [
+			"",
+			"f-par",
+			"fr",
+			"-par",
+			"fr-pa"
+		],
+		name: "Region",
+		validator: isRegion,
+		valids: [
+			"fr-par",
+			"nl-ams",
+			"pl-waw"
+		]
+	},
+	{
+		invalids: [
+			"",
+			"fr-par",
+			"fr"
+		],
+		name: "Zone",
+		validator: isZone,
+		valids: [
+			"fr-par-1",
+			"fr-par-2",
+			"nl-ams-1",
+			"pl-waw-1",
+			"pl-waw-9"
+		]
+	},
+	{
+		invalids: ["", "api.scaleway.com"],
+		name: "URL",
+		validator: isURL,
+		valids: ["https://api.scaleway.com"]
+	},
+	{
+		invalids: ["", "@example.com"],
+		name: "Email",
+		validator: isEmail,
+		valids: ["john@example.com"]
+	}
+];
+for (const component of validators) describe(component.validator.name, () => {
+	it(`validates correct ${component.name} format`, () => {
+		for (const str of component.valids) expect(component.validator(str)).toStrictEqual(true);
+	});
+	it(`doesn't validate incorrect ${component.name} format`, () => {
+		for (const str of component.invalids) expect(component.validator(str)).toStrictEqual(false);
+	});
+});
+//#endregion

package/dist/internal/validations/string-validation.js

@@ -1,23 +1,25 @@
+//#region src/internal/validations/string-validation.ts
 var isAccessKeyRegex = /^SCW[A-Z0-9]{17}$/i;
+var isEmailRegex = /^.+@.+$/i;
 var isRegionRegex = /^[a-z]{2}-[a-z]{3}$/i;
 var isUUIDRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/i;
 var isZoneRegex = /^[a-z]{2}-[a-z]{3}-[1-9]$/i;
 /** Returns true if the given string has a valid UUID format. */
-const isUUID = (str) => isUUIDRegex.test(str);
+var isUUID = (str) => isUUIDRegex.test(str);
 /** Returns true if the given string has a valid Scaleway access key format. */
-const isAccessKey = (str) => isAccessKeyRegex.test(str);
+var isAccessKey = (str) => isAccessKeyRegex.test(str);
 /** Returns true if the given string has a valid Scaleway secret key format. */
-const isSecretKey = (str) => isUUID(str);
+var isSecretKey = (str) => isUUID(str);
 /** Returns true if the given string has a valid Scaleway organization ID format. */
-const isOrganizationId = (str) => isUUID(str);
+var isOrganizationId = (str) => isUUID(str);
 /** Returns true if the given string has a valid Scaleway project ID format. */
-const isProjectId = (str) => isUUID(str);
+var isProjectId = (str) => isUUID(str);
 /** Returns true if the given string has a valid region format. */
-const isRegion = (str) => isRegionRegex.test(str);
+var isRegion = (str) => isRegionRegex.test(str);
 /** Returns true if the given string has a valid zone format. */
-const isZone = (str) => isZoneRegex.test(str);
+var isZone = (str) => isZoneRegex.test(str);
 /** Returns true if the given string has a valid URL format and starts by `http(s):`. */
-const isURL = (str) => {
+var isURL = (str) => {
 	let url;
 	try {
 		url = new URL(str);
@@ -26,4 +28,7 @@ const isURL = (str) => {
 	}
 	return url.protocol === "http:" || url.protocol === "https:";
 };
-export { isAccessKey, isOrganizationId, isProjectId, isRegion, isSecretKey, isURL, isUUID, isZone };
+/** Returns true if the given string has an email format. */
+var isEmail = (str) => isEmailRegex.test(str);
+//#endregion
+export { isAccessKey, isEmail, isOrganizationId, isProjectId, isRegion, isSecretKey, isURL, isUUID, isZone };

package/dist/internals.js

@@ -1,8 +1,9 @@
-import "./helpers/json.js";
-import "./helpers/marshalling.js";
-import "./internal/async/interval-retrier.js";
-import "./internal/interceptors/helpers.js";
-import "./scw/api.js";
-import "./scw/auth.js";
-import "./scw/custom-marshalling.js";
-import "./scw/fetch/resource-paginator.js";
+import { isJSONObject } from "./helpers/json.js";
+import { resolveOneOf, unmarshalArrayOfObject, unmarshalDate, unmarshalMapOfObject, urlParams, validatePathParam } from "./helpers/marshalling.js";
+import { createExponentialBackoffStrategy, tryAtIntervals, waitForResource } from "./internal/async/interval-retrier.js";
+import { API } from "./scw/api.js";
+import { marshalBlobToScwFile, marshalDecimal, marshalMoney, marshalScwFile, marshalTimeSeries, unmarshalAnyRes, unmarshalDecimal, unmarshalMoney, unmarshalScwFile, unmarshalServiceInfo, unmarshalTimeSeries, unmarshalTimeSeriesPoint } from "./scw/custom-marshalling.js";
+import { enrichForPagination } from "./scw/fetch/resource-paginator.js";
+import { addAsyncHeaderInterceptor } from "./internal/interceptors/helpers.js";
+import { authenticateWithSessionToken } from "./scw/auth.js";
+export { API, addAsyncHeaderInterceptor, authenticateWithSessionToken, createExponentialBackoffStrategy, enrichForPagination, isJSONObject, marshalBlobToScwFile, marshalDecimal, marshalMoney, marshalScwFile, marshalTimeSeries, resolveOneOf, tryAtIntervals, unmarshalAnyRes, unmarshalArrayOfObject, unmarshalDate, unmarshalDecimal, unmarshalMapOfObject, unmarshalMoney, unmarshalScwFile, unmarshalServiceInfo, unmarshalTimeSeries, unmarshalTimeSeriesPoint, urlParams, validatePathParam, waitForResource };

package/dist/package.js

@@ -1,6 +1,6 @@
 var package_default = {
 	name: "@scaleway/sdk-client",
-	version: "2.2.0",
+	version: "2.2.2",
 	license: "Apache-2.0",
 	description: "Scaleway SDK Client",
 	keywords: [
@@ -29,4 +29,5 @@ var package_default = {
 		"default": "./dist/index.js"
 	} }
 };
+//#endregion
 export { package_default as default };

package/dist/scw/__tests__/api.test.js

@@ -0,0 +1,19 @@
+import { API } from "../api.js";
+import { createClient } from "../client.js";
+import { describe, expect, it } from "vitest";
+//#region src/scw/__tests__/api.test.ts
+var CustomAPI = class extends API {
+	getBaseURL = () => {
+		if (!this.client.settings.apiURL) throw new Error("API URL is missing");
+		return this.client.settings.apiURL;
+	};
+};
+describe("API", () => {
+	it("binds methods properly", () => {
+		const unboundMethod = new CustomAPI(createClient()).getBaseURL;
+		expect(() => {
+			unboundMethod();
+		}).not.toThrow();
+	});
+});
+//#endregion

package/dist/scw/__tests__/auth.test.js

@@ -0,0 +1,57 @@
+import { authenticateWithSecrets, authenticateWithSessionToken, obfuscateAuthHeadersEntry, obfuscateToken, obfuscateUUID } from "../auth.js";
+import { describe, expect, it } from "vitest";
+//#region src/scw/__tests__/auth.test.ts
+describe("obfuscateToken", () => {
+	it("hides anything after 5 characters", () => {
+		expect(obfuscateToken("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c")).toBe("eyJhbxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
+		expect(obfuscateToken("")).toBe("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
+	});
+});
+describe("obfuscateUUID", () => {
+	it("hides anything after 8 characters", () => {
+		expect(obfuscateUUID("db31db7b-473d-488e-bd2e-1b77ee426910")).toBe("db31db7b-xxxx-xxxx-xxxx-xxxxxxxxxxxx");
+		expect(obfuscateUUID("")).toBe("-xxxx-xxxx-xxxx-xxxxxxxxxxxx");
+	});
+});
+describe("obfuscateAuthHeadersEntry", () => {
+	it("obfuscates an auth token", () => {
+		expect(obfuscateAuthHeadersEntry(["x-auth-token", "db31db7b-473d-488e-bd2e-1b77ee426910"])).toStrictEqual(["x-auth-token", "db31db7b-xxxx-xxxx-xxxx-xxxxxxxxxxxx"]);
+	});
+	it("obfuscates a session token", () => {
+		expect(obfuscateAuthHeadersEntry(["x-session-token", "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"])).toStrictEqual(["x-session-token", "eyJhbxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"]);
+	});
+	it(`doesn't obfuscate unknown key`, () => {
+		expect(obfuscateAuthHeadersEntry(["x-unknown-key", "random-value"])).toStrictEqual(["x-unknown-key", "random-value"]);
+	});
+});
+describe("authenticateWithSessionToken", () => {
+	it("retrieves the token and updates the request header", async () => {
+		const dummyToken = "dummy";
+		const sourceReq = new Request("https://api.scaleway.com/my/path");
+		const updatedReq = await authenticateWithSessionToken(() => Promise.resolve(dummyToken))({ request: sourceReq });
+		const expectedReq = sourceReq.clone();
+		expectedReq.headers.append("x-session-token", "dummy");
+		expect(updatedReq).toMatchObject(expectedReq);
+	});
+});
+describe("authenticateWithSecrets", () => {
+	const sourceReq = new Request("https://api.scaleway.com/my/path");
+	it("updates the request header with the valid secrets", async () => {
+		const validSecrets = {
+			accessKey: "SCW01234567890123456",
+			secretKey: "e4b83996-4c60-449a-98d2-38f5de7b4e6b"
+		};
+		const updatedReq = await authenticateWithSecrets(validSecrets)({ request: sourceReq });
+		const expectedReq = sourceReq.clone();
+		expectedReq.headers.append("x-auth-token", validSecrets.secretKey);
+		expect(updatedReq).toMatchObject(expectedReq);
+	});
+	it("throws an exception for invalid secrets", () => {
+		const invalidSecrets = {
+			accessKey: "",
+			secretKey: ""
+		};
+		expect(() => authenticateWithSecrets(invalidSecrets)({ request: sourceReq })).toThrow();
+	});
+});
+//#endregion