@embrace-io/react-native/lib/src/hooks/useEmbrace.test.js

A React Native wrapper for the Embrace SDK

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const react_native_1 = require("@testing-library/react-native");
const otlp_1 = require("../utils/otlp");
const useEmbrace_1 = require("./useEmbrace");
jest.mock("../utils/otlp", () => ({
    oltpGetStart: jest.fn(),
}));
const mockStartNativeEmbraceSDK = jest.fn().mockResolvedValue(true);
jest.mock("react-native", () => ({
    Platform: {
        OS: "ios",
    },
}));
const mockSetJavaScriptPatchNumber = jest.fn();
jest.mock("../EmbraceManagerModule", () => ({
    EmbraceManagerModule: {
        startNativeEmbraceSDK: () => mockStartNativeEmbraceSDK(),
        isStarted: jest.fn().mockResolvedValueOnce(false),
        setReactNativeSDKVersion: jest.fn(),
        setReactNativeVersion: jest.fn(),
        getDefaultJavaScriptBundlePath: jest.fn(),
        setJavaScriptBundlePath: jest.fn(),
        setJavaScriptPatchNumber: jest.fn(patch => mockSetJavaScriptPatchNumber(patch)),
    },
}));
const mockConsoleLog = jest.spyOn(console, "log").mockImplementation(m => m);
const mockConsoleWarn = jest.spyOn(console, "warn").mockImplementation(m => m);
describe("useEmbrace", () => {
    afterEach(() => {
        jest.clearAllMocks();
    });
    it("should start the Embrace React Native SDK", () => __awaiter(void 0, void 0, void 0, function* () {
        const { result, rerender } = (0, react_native_1.renderHook)(({ sdkConfig, patch, logLevel }) => (0, useEmbrace_1.useEmbrace)(sdkConfig, patch, logLevel), {
            initialProps: {
                sdkConfig: { ios: { appId: "test" } },
                patch: "v1",
                // testing default value for `logLevel`
                logLevel: undefined,
            },
        });
        yield (0, react_native_1.waitFor)(() => {
            expect(result.current.isPending).toBe(false);
            expect(result.current.isStarted).toBe(true);
            expect(mockConsoleLog).toHaveBeenCalledWith("[Embrace] native SDK was started");
            expect(mockSetJavaScriptPatchNumber).toHaveBeenCalledWith("v1");
        });
        mockConsoleLog.mockClear();
        mockSetJavaScriptPatchNumber.mockClear();
        // not updating what `EmbraceManagerModule.startNativeEmbraceSDK` returns
        // as we want to test again the same with the different `debug` value
        rerender({
            sdkConfig: { ios: { appId: "test" } },
            patch: undefined,
            logLevel: "error",
        });
        yield (0, react_native_1.waitFor)(() => {
            expect(mockConsoleLog).not.toHaveBeenCalled();
            expect(mockSetJavaScriptPatchNumber).not.toHaveBeenCalledWith("v1");
        });
    }));
    it("should show a warning message if for some reason Embrace React Native SKD can't initialize", () => __awaiter(void 0, void 0, void 0, function* () {
        jest.mocked(mockStartNativeEmbraceSDK).mockResolvedValueOnce(false);
        const { result } = (0, react_native_1.renderHook)(({ sdkConfig, patch, logLevel }) => (0, useEmbrace_1.useEmbrace)(sdkConfig, patch, logLevel), {
            initialProps: {
                sdkConfig: {
                    ios: { appId: "test" },
                    exporters: {
                        logExporter: {
                            endpoint: "http://localhost:8081",
                        },
                    },
                },
                patch: "v1",
                logLevel: "info",
            },
        });
        yield (0, react_native_1.waitFor)(() => {
            expect(mockStartNativeEmbraceSDK).toHaveBeenCalledTimes(1);
            expect(result.current.isPending).toBe(false);
            expect(result.current.isStarted).toBe(false);
            expect(mockConsoleWarn).toHaveBeenCalledWith("[Embrace] we could not initialize Embrace's native SDK, please check the Embrace integration docs at https://embrace.io/docs/react-native/integration/");
        });
    }));
    it("should start the Embrace React Native SDK using OTLP", () => __awaiter(void 0, void 0, void 0, function* () {
        const mockRNEmbraceOTLPInit = jest.fn().mockResolvedValue(true);
        const mockOltpGetStart = jest
            .mocked(otlp_1.oltpGetStart)
            .mockImplementation(() => mockRNEmbraceOTLPInit);
        const { result } = (0, react_native_1.renderHook)(({ sdkConfig, patch, logLevel }) => (0, useEmbrace_1.useEmbrace)(sdkConfig, patch, logLevel), {
            initialProps: {
                sdkConfig: {
                    ios: { appId: "test" },
                    exporters: {
                        logExporter: {
                            endpoint: "http://localhost:8081",
                        },
                    },
                },
                patch: "v1",
                logLevel: "info",
            },
        });
        yield (0, react_native_1.waitFor)(() => {
            expect(mockOltpGetStart).toHaveBeenCalledTimes(1);
            expect(mockRNEmbraceOTLPInit).toHaveBeenCalledTimes(1);
            expect(result.current.isPending).toBe(false);
            expect(result.current.isStarted).toBe(true);
        });
    }));
    it("should throw if something goes wrong with React Native OTLP Package and there was exporter configuration available", () => __awaiter(void 0, void 0, void 0, function* () {
        const mockOltpGetStart = jest
            .mocked(otlp_1.oltpGetStart)
            .mockImplementation(() => {
            try {
                // making `@embrace-io/react-native-otlp` throw
                throw new Error();
            }
            catch (_a) { }
        });
        const { result } = (0, react_native_1.renderHook)(({ sdkConfig, patch, logLevel }) => (0, useEmbrace_1.useEmbrace)(sdkConfig, patch, logLevel), {
            initialProps: {
                sdkConfig: {
                    ios: { appId: "test" },
                    exporters: {
                        logExporter: {
                            endpoint: "http://localhost:8081",
                        },
                    },
                },
                patch: "v1",
                logLevel: "info",
            },
        });
        yield (0, react_native_1.waitFor)(() => {
            expect(mockOltpGetStart).toHaveBeenCalledTimes(1);
            expect(result.current.isPending).toBe(false);
            // it should still initialize the SKD using the regular `@embrace-io/react-native` package
            expect(result.current.isStarted).toBe(true);
            expect(mockConsoleLog).toHaveBeenCalledWith("[Embrace] native SDK was started");
        });
    }));
    it("should not initialize the React Native Embrace SDK if the initialization from the OTLP side returns false", () => __awaiter(void 0, void 0, void 0, function* () {
        jest
            .mocked(otlp_1.oltpGetStart)
            .mockImplementation(jest.fn().mockResolvedValue(false));
        const { result } = (0, react_native_1.renderHook)(({ sdkConfig, patch, logLevel }) => (0, useEmbrace_1.useEmbrace)(sdkConfig, patch, logLevel), {
            initialProps: {
                sdkConfig: {
                    ios: { appId: "test" },
                    exporters: {
                        logExporter: {
                            endpoint: "http://localhost:8081",
                        },
                    },
                },
                patch: "v1",
                logLevel: "info",
            },
        });
        yield (0, react_native_1.waitFor)(() => {
            expect(mockConsoleWarn).toHaveBeenCalledWith("[Embrace] we could not initialize Embrace's native SDK, please check the Embrace integration docs at https://embrace.io/docs/react-native/integration/");
            expect(result.current.isPending).toBe(false);
            expect(result.current.isStarted).toBe(false);
        });
    }));
});