increase code coverage (#2)

* more tests

* add a bunch more tests

* add more tests

* bump to 0.2.0

Author: goenning

CHANGELOG.md

@@ -1,11 +1,17 @@
+## 0.2.0
+
+- Automatic flush of events on app exit
+- Events are now sent in batches to reduce network overhead
+- While offline, events will be enqueue and sent when the app is back online
+
 ## 0.1.2
 
-Added an option to set the appVersion during init
+- Added an option to set the appVersion during init
 
 ## 0.1.1
 
-Fixed some links on package.json
+- Fixed some links on package.json
 
 ## 0.1.0
 
-Initial release
+- Initial release

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@aptabase/react-native",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "private": false,
   "description": "React Native SDK for Aptabase: Open Source, Privacy-First and Simple Analytics for Mobile, Desktop and Web Apps",
   "sideEffects": false,

package.json

@@ -1,6 +1,8 @@
 import createFetchMock from "vitest-fetch-mock";
 import { vi } from "vitest";
 
+vi.stubGlobal("__DEV__", true);
+
 const fetchMocker = createFetchMock(vi);
 
 fetchMocker.enableMocks();

setupVitest.ts

@@ -0,0 +1,122 @@
+import "vitest-fetch-mock";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { AptabaseClient } from "./client";
+import type { EnvironmentInfo } from "./env";
+
+const env: EnvironmentInfo = {
+  isDebug: false,
+  locale: "en-US",
+  osName: "iOS",
+  osVersion: "14.3",
+  appVersion: "1.0.0",
+  appBuildNumber: "1",
+  sdkVersion: "aptabase-reactnative@1.0.0",
+};
+
+describe("AptabaseClient", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    fetchMock.resetMocks();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("should allow override of appVersion", async () => {
+    const client = new AptabaseClient("A-DEV-000", env, {
+      appVersion: "2.0.0",
+    });
+
+    client.trackEvent("Hello");
+    await client.flush();
+
+    const body = await fetchMock.requests().at(0)?.json();
+    expect(body[0].eventName).toEqual("Hello");
+    expect(body[0].systemProps).toEqual({ ...env, appVersion: "2.0.0" });
+  });
+
+  it("should send event with correct props", async () => {
+    const client = new AptabaseClient("A-DEV-000", env);
+
+    client.trackEvent("test", { count: 1, foo: "bar" });
+    await client.flush();
+
+    const body = await fetchMock.requests().at(0)?.json();
+    expect(body[0].eventName).toEqual("test");
+    expect(body[0].props).toEqual({ count: 1, foo: "bar" });
+    expect(body[0].systemProps).toEqual(env);
+  });
+
+  it("should flush events every 500ms", async () => {
+    const client = new AptabaseClient("A-DEV-000", env);
+    client.startPolling(500);
+
+    client.trackEvent("Hello1");
+    vi.advanceTimersByTime(510);
+
+    expect(fetchMock.requests().length).toEqual(1);
+    const request1 = await fetchMock.requests().at(0)?.json();
+    expect(request1[0].eventName).toEqual("Hello1");
+
+    // after another tick, nothing should be sent
+    vi.advanceTimersByTime(510);
+    expect(fetchMock.requests().length).toEqual(1);
+
+    // after a trackEvent and another tick, the event should be sent
+    client.trackEvent("Hello2");
+    vi.advanceTimersByTime(510);
+    expect(fetchMock.requests().length).toEqual(2);
+    const request2 = await fetchMock.requests().at(1)?.json();
+    expect(request2[0].eventName).toEqual("Hello2");
+  });
+
+  it("should stop flush if polling stopped", async () => {
+    const client = new AptabaseClient("A-DEV-000", env);
+    client.startPolling(500);
+
+    client.trackEvent("Hello1");
+    vi.advanceTimersByTime(510);
+
+    expect(fetchMock.requests().length).toEqual(1);
+
+    // if polling stopped, no more events should be sent
+    client.stopPolling();
+    client.trackEvent("Hello2");
+    vi.advanceTimersByTime(5000);
+    expect(fetchMock.requests().length).toEqual(1);
+  });
+
+  it("should generate new session after long period of inactivity", async () => {
+    const client = new AptabaseClient("A-DEV-000", env);
+
+    client.trackEvent("Hello1");
+    await client.flush();
+
+    const request1 = await fetchMock.requests().at(0)?.json();
+    const sessionId1 = request1[0].sessionId;
+    expect(sessionId1).toBeDefined();
+
+    // after 10 minutes, the same session should be used
+    vi.advanceTimersByTime(10 * 60 * 1000);
+
+    client.trackEvent("Hello2");
+    await client.flush();
+
+    const request2 = await fetchMock.requests().at(1)?.json();
+    const sessionId2 = request2[0].sessionId;
+    expect(sessionId2).toBeDefined();
+    expect(sessionId2).toBe(sessionId1);
+
+    // after 2 hours, the same session should be used
+    vi.advanceTimersByTime(2 * 60 * 60 * 1000);
+
+    client.trackEvent("Hello3");
+    await client.flush();
+
+    const request3 = await fetchMock.requests().at(2)?.json();
+    const sessionId3 = request3[0].sessionId;
+    expect(sessionId3).toBeDefined();
+    expect(sessionId3).not.toBe(sessionId1);
+  });
+});

src/client.spec.ts

@@ -0,0 +1,83 @@
+import type { Platform } from "react-native";
+import type { AptabaseOptions } from "./types";
+import type { EnvironmentInfo } from "./env";
+import { EventDispatcher } from "./dispatcher";
+import { newSessionId } from "./session";
+import { HOSTS, SESSION_TIMEOUT } from "./constants";
+
+export class AptabaseClient {
+  private readonly _dispatcher: EventDispatcher;
+  private readonly _env: EnvironmentInfo;
+  private _sessionId = newSessionId();
+  private _lastTouched = new Date();
+  private _flushTimer: number | undefined;
+
+  constructor(appKey: string, env: EnvironmentInfo, options?: AptabaseOptions) {
+    const [_, region] = appKey.split("-");
+    const baseUrl = this.getBaseUrl(region, options);
+
+    this._env = { ...env };
+    if (options?.appVersion) {
+      this._env.appVersion = options.appVersion;
+    }
+
+    this._dispatcher = new EventDispatcher(appKey, baseUrl, env);
+  }
+
+  public trackEvent(
+    eventName: string,
+    props?: Record<string, string | number | boolean>
+  ) {
+    this._dispatcher.enqueue({
+      timestamp: new Date().toISOString(),
+      sessionId: this.evalSessionId(),
+      eventName: eventName,
+      systemProps: {
+        isDebug: this._env.isDebug,
+        locale: this._env.locale,
+        osName: this._env.osName,
+        osVersion: this._env.osVersion,
+        appVersion: this._env.appVersion,
+        appBuildNumber: this._env.appBuildNumber,
+        sdkVersion: this._env.sdkVersion,
+      },
+      props: props,
+    });
+  }
+
+  public startPolling(flushInterval: number) {
+    this.stopPolling();
+
+    this._flushTimer = setInterval(this.flush.bind(this), flushInterval);
+  }
+
+  public stopPolling() {
+    if (this._flushTimer) {
+      clearInterval(this._flushTimer);
+      this._flushTimer = undefined;
+    }
+  }
+
+  public flush(): Promise<void> {
+    return this._dispatcher.flush();
+  }
+
+  private evalSessionId() {
+    let now = new Date();
+    const diffInMs = now.getTime() - this._lastTouched.getTime();
+    if (diffInMs > SESSION_TIMEOUT) {
+      this._sessionId = newSessionId();
+    }
+    this._lastTouched = now;
+
+    return this._sessionId;
+  }
+
+  private getBaseUrl(region: string, options?: AptabaseOptions): string {
+    if (region === "SH") {
+      return options?.host ?? HOSTS.DEV;
+    }
+
+    return HOSTS[region];
+  }
+}

src/client.ts

@@ -0,0 +1,14 @@
+// Session expires after 1 hour of inactivity
+export const SESSION_TIMEOUT = 60 * 60 * 1000;
+
+// Flush events every 60 seconds in production, or 2 seconds in development
+export const FLUSH_INTERVAL = __DEV__ ? 2000 : 60000;
+
+// List of hosts for each region
+// To use a self-hosted (SH) deployment, the host must be set during init
+export const HOSTS: { [region: string]: string } = {
+  US: "https://us.aptabase.com",
+  EU: "https://eu.aptabase.com",
+  DEV: "http://localhost:3000",
+  SH: "",
+};

src/constants.ts

@@ -1,19 +1,23 @@
 import "vitest-fetch-mock";
 import { EventDispatcher } from "./dispatcher";
 import { beforeEach, describe, expect, it } from "vitest";
+import { EnvironmentInfo } from "./env";
+
+const env: EnvironmentInfo = {
+  isDebug: false,
+  locale: "en-US",
+  osName: "iOS",
+  osVersion: "14.3",
+  appVersion: "1.0.0",
+  appBuildNumber: "1",
+  sdkVersion: "aptabase-reactnative@1.0.0",
+};
 
 const createEvent = (eventName: string) => ({
   timestamp: new Date().toISOString(),
   sessionId: "123",
   eventName,
-  systemProps: {
-    isDebug: false,
-    locale: "en-US",
-    osName: "iOS",
-    osVersion: "14.3",
-    appVersion: "1.0.0",
-    sdkVersion: "1.0.0",
-  },
+  systemProps: { ...env },
 });
 
 const expectRequestCount = (count: number) => {
@@ -24,15 +28,19 @@ const expectEventsCount = async (
   requestIndex: number,
   expectedNumOfEvents: number
 ) => {
-  const body = await fetchMock.requests()[requestIndex].json();
+  const body = await fetchMock.requests().at(requestIndex)?.json();
   expect(body.length).toEqual(expectedNumOfEvents);
 };
 
 describe("EventDispatcher", () => {
   let dispatcher: EventDispatcher;
 
   beforeEach(() => {
-    dispatcher = new EventDispatcher("https://localhost:3000", "A-DEV-000");
+    dispatcher = new EventDispatcher(
+      "A-DEV-000",
+      "https://localhost:3000",
+      env
+    );
     fetchMock.resetMocks();
   });
 
@@ -42,6 +50,18 @@ describe("EventDispatcher", () => {
     expectRequestCount(0);
   });
 
+  it("should send even with correct headers", async () => {
+    dispatcher.enqueue(createEvent("app_started"));
+    await dispatcher.flush();
+
+    const request = await fetchMock.requests().at(0);
+    expect(request).not.toBeUndefined();
+    expect(request?.url).toEqual("https://localhost:3000/api/v0/events");
+    expect(request?.headers.get("Content-Type")).toEqual("application/json");
+    expect(request?.headers.get("App-Key")).toEqual("A-DEV-000");
+    expect(request?.headers.get("User-Agent")).toEqual("iOS/14.3 en-US");
+  });
+
   it("should dispatch single event", async () => {
     fetchMock.mockResponseOnce("{}");
 
@@ -103,4 +123,18 @@ describe("EventDispatcher", () => {
     expectRequestCount(2);
     await expectEventsCount(1, 1);
   });
+
+  it("should not retry requests that failed with 4xx", async () => {
+    fetchMock.mockResponseOnce("{}", { status: 400 });
+
+    dispatcher.enqueue(createEvent("hello_world"));
+    await dispatcher.flush();
+
+    expectRequestCount(1);
+    await expectEventsCount(0, 1);
+
+    await dispatcher.flush();
+
+    expectRequestCount(1);
+  });
 });