JavaScript SDK: All unit tests passing (268/268), cross-SDK tests (138/138)

.gitignore

@@ -8,5 +8,6 @@ src/js/*
 !src/js/__tests__
 types
 js
-.claude/worktrees
+.claude/
+.DS_Store
 src/version.ts

.prettierignore

@@ -2,5 +2,7 @@ node_modules
 coverage
 dist
 es
+js
 lib
+types
 package-lock.json

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absmartly/javascript-sdk",
-	"version": "1.14.0-beta.1",
+	"version": "2.0.0",
 	"description": "A/B Smartly Javascript SDK",
 	"homepage": "https://github.com/absmartly/javascript-sdk#README.md",
 	"bugs": "https://github.com/absmartly/javascript-sdk/issues",

src/__tests__/abort-controller-shim.test.js

@@ -88,4 +88,45 @@ describe("AbortController", () => {
 
 		expect(aborter[Symbol.toStringTag]).toEqual("AbortController");
 	});
+
+	describe("signal.reason", () => {
+		it("should set default reason on abort()", () => {
+			const controller = new AbortController();
+			controller.abort();
+			expect(controller.signal.aborted).toBe(true);
+			expect(controller.signal.reason).toBeInstanceOf(Error);
+			expect(controller.signal.reason.message).toBe("The operation was aborted.");
+		});
+
+		it("should set custom reason on abort(reason)", () => {
+			const controller = new AbortController();
+			const customReason = new Error("custom abort");
+			controller.abort(customReason);
+			expect(controller.signal.reason).toBe(customReason);
+		});
+
+		it("should have undefined reason before abort", () => {
+			const controller = new AbortController();
+			expect(controller.signal.reason).toBeUndefined();
+		});
+	});
+
+	describe("dispatchEvent onabort handling", () => {
+		it("should call onabort handler on abort dispatch", () => {
+			const signal = new AbortSignal();
+			const handler = jest.fn();
+			signal.onabort = handler;
+			signal.dispatchEvent({ type: "abort" });
+			expect(handler).toHaveBeenCalledTimes(1);
+			expect(handler).toHaveBeenCalledWith({ type: "abort" });
+		});
+
+		it("should not call onabort for non-abort events", () => {
+			const signal = new AbortSignal();
+			const handler = jest.fn();
+			signal.onabort = handler;
+			signal.dispatchEvent({ type: "other" });
+			expect(handler).not.toHaveBeenCalled();
+		});
+	});
 });

src/__tests__/client.test.js

@@ -687,6 +687,29 @@
 			});
 	});
 
+	it("request() should not throw on unmatched surrogates in query parameters", () => {
+		fetch.mockResolvedValueOnce(responseMock(200, "OK", defaultMockResponse));
+
+		const client = new Client(clientOptions);
+
+		// A lone UTF-16 surrogate is accepted JavaScript string content but is not
+		// valid UTF-8; unlike URLSearchParams (which substitutes U+FFFD),
+		// encodeURIComponent() throws URIError on it directly, so it must be
+		// normalized to well-formed UTF-16 first.
+		return client
+			.request({
+				method: "GET",
+				path: "/context",
+				query: { application: "\uD800" },
+			})
+			.then((response) => {
+				expect(fetch).toHaveBeenCalledTimes(1);
+				expect(fetch).toHaveBeenLastCalledWith(`${endpoint}/context?application=%EF%BF%BD`, expect.any(Object));
+
+				expect(response).toEqual(defaultMockResponse);
+			});
+	});
+
 	it("request() should omit query parameters if dict empty", (done) => {
 		fetch.mockResolvedValueOnce(responseMock(200, "OK", defaultMockResponse));
 
@@ -1121,7 +1144,7 @@
 	});
 
 	it("getAgent() should return default agent when not specified", () => {
 		const { agent: _, ...optionsWithoutAgent } = clientOptions;
 		const client = new Client(optionsWithoutAgent);
 		expect(client.getAgent()).toEqual("javascript-client");
 	});
@@ -1188,4 +1211,41 @@
 				done();
 			});
 	});
+
+	describe("timeout option", () => {
+		it("should accept an explicit timeout of 0 (nullish coalescing, not falsy)", () => {
+			const client = new Client({
+				endpoint,
+				agent,
+				environment,
+				apiKey,
+				application,
+				timeout: 0,
+			});
+
+			expect(client).toBeInstanceOf(Client);
+		});
+
+		it("should still retry a failing-then-succeeding request when timeout is 0 (no deadline)", (done) => {
+			fetch
+				.mockResolvedValueOnce(responseMock(500, "server error", "server error text"))
+				.mockResolvedValueOnce(responseMock(200, "OK", defaultMockResponse));
+
+			const client = new Client(Object.assign({}, clientOptions, { timeout: 0, retries: 5 }));
+
+			client
+				.request({
+					method: "GET",
+					path: "/context",
+				})
+				.then((response) => {
+					expect(fetch).toHaveBeenCalledTimes(2);
+					expect(response).toEqual(defaultMockResponse);
+
+					done();
+				});
+
+			advanceFakeTimers();
+		});
+	});
 });

src/__tests__/constructor-options.test.js

@@ -0,0 +1,59 @@
+import SDK from "../sdk";
+import Client from "../client";
+
+describe("SDK and Client constructor option merging", () => {
+	it("should extract client options from SDK options and pass them to the real Client", () => {
+		const sdk = new SDK({
+			agent: "test-agent",
+			apiKey: "key",
+			application: "app",
+			endpoint: "http://localhost",
+			environment: "test",
+			timeout: 5000,
+		});
+
+		const client = sdk.getClient();
+		expect(client).toBeInstanceOf(Client);
+		expect(client.getAgent()).toBe("test-agent");
+		expect(client.getEnvironment()).toBe("test");
+		expect(client.getApplication()).toEqual({ name: "app", version: 0 });
+	});
+
+	it("should accept the SDK application option as an object", () => {
+		const sdk = new SDK({
+			agent: "test",
+			apiKey: "key",
+			application: { name: "myapp", version: "1.2.3" },
+			endpoint: "http://localhost",
+			environment: "prod",
+		});
+
+		expect(sdk.getClient().getApplication()).toEqual({ name: "myapp", version: "1.2.3" });
+	});
+
+	it("should merge provided Client options with the defaults", () => {
+		const client = new Client({
+			endpoint: "http://test",
+			agent: "custom-agent",
+			environment: "prod",
+			apiKey: "key123",
+			application: "myapp",
+			timeout: 10000,
+		});
+
+		expect(client.getAgent()).toBe("custom-agent");
+		expect(client.getEnvironment()).toBe("prod");
+		expect(client.getApplication()).toEqual({ name: "myapp", version: 0 });
+	});
+
+	it("should fall back to the default agent when it is omitted", () => {
+		const client = new Client({
+			endpoint: "http://test",
+			environment: "prod",
+			apiKey: "key123",
+			application: "myapp",
+		});
+
+		expect(client.getAgent()).toBe("javascript-client");
+	});
+});