@oneuptime/common 9.2.20 → 9.2.21

package/Tests/UI/Components/Modal.test.tsx

@@ -72,7 +72,7 @@ describe("Modal", () => {
       </Modal>,
     );
 
-    expect(getByTestId("modal")).toHaveClass("sm:max-w-lg");
+    expect(getByTestId("modal")).toHaveClass("md:max-w-lg");
   });
 
   it("displays the modal with the correct width when modalWidth is set", () => {
@@ -88,7 +88,7 @@ describe("Modal", () => {
       </Modal>,
     );
 
-    expect(getByTestId("modal")).toHaveClass("sm:max-w-3xl");
+    expect(getByTestId("modal")).toHaveClass("md:max-w-3xl");
   });
 
   it("displays the children passed to the modal", () => {
@@ -112,7 +112,7 @@ describe("Modal", () => {
       </Modal>,
     );
 
-    expect(getByTestId("loader")).toBeInTheDocument();
+    expect(getByTestId("bar-loader")).toBeInTheDocument();
   });
 
   it("does not display the loader when isBodyLoading is false", () => {
@@ -124,7 +124,7 @@ describe("Modal", () => {
       </Modal>,
     );
 
-    expect(queryByTestId("loader")).not.toBeInTheDocument();
+    expect(queryByTestId("bar-loader")).not.toBeInTheDocument();
   });
 
   it("does not display the loader when isBodyLoading is undefined", () => {
@@ -136,7 +136,7 @@ describe("Modal", () => {
       </Modal>,
     );
 
-    expect(queryByTestId("loader")).not.toBeInTheDocument();
+    expect(queryByTestId("bar-loader")).not.toBeInTheDocument();
   });
 
   it("disables the submit button when isLoading is true", () => {

package/Tests/UI/Components/NavBar.test.tsx

@@ -2,14 +2,27 @@ import Navbar, {
   ComponentProps,
   NavItem,
 } from "../../../UI/Components/Navbar/NavBar";
-import { describe, expect, it } from "@jest/globals";
+import { describe, expect, it, beforeEach } from "@jest/globals";
 import "@testing-library/jest-dom/extend-expect";
 import { render, screen } from "@testing-library/react";
 import React from "react";
 import Route from "../../../Types/API/Route";
 import IconProp from "../../../Types/Icon/IconProp";
+import Navigation from "../../../UI/Utils/Navigation";
+import { Location } from "react-router-dom";
 
 describe("Navbar", () => {
+  // Mock Navigation location for Navigation utility
+  beforeEach(() => {
+    const mockLocation: Location = {
+      pathname: "/",
+      search: "",
+      hash: "",
+      state: null,
+      key: "default",
+    };
+    Navigation.setLocation(mockLocation);
+  });
   const defaultProps: ComponentProps = {
     children: <div>Test</div>,
   };

package/Tests/UI/Components/OrderedStatesList.test.tsx

@@ -46,7 +46,7 @@ describe("OrderedSateList", () => {
       isLoading: true,
     };
     render(<OrderedStatesList {...props} />);
-    expect(screen.getByRole("bar-loader")).toBeInTheDocument();
+    expect(screen.getByTestId("bar-loader")).toBeInTheDocument();
   });
   it("should render an error message if error prop is present", () => {
     const props: ComponentProps<ItemData> = {

package/Tests/UI/Components/Pagination.test.tsx

@@ -59,7 +59,9 @@ describe("Pagination", () => {
 
     render(<Pagination {...props} />);
 
-    fireEvent.click(screen.getByText("Next"));
+    // There are multiple "Next" elements (mobile and desktop), get the first one
+    const nextButtons: HTMLElement[] = screen.getAllByText("Next");
+    fireEvent.click(nextButtons[0]!);
 
     await waitFor(() => {
       expect(mockOnNavigateToPage).toHaveBeenCalledWith(2, 10);
@@ -81,7 +83,9 @@ describe("Pagination", () => {
 
     render(<Pagination {...props} />);
 
-    fireEvent.click(screen.getByText("Previous"));
+    // There are multiple "Previous" elements (mobile and desktop), get the first one
+    const prevButtons: HTMLElement[] = screen.getAllByText("Previous");
+    fireEvent.click(prevButtons[0]!);
 
     await waitFor(() => {
       expect(mockOnNavigateToPage).toHaveBeenCalledWith(1, 10);

package/Tests/Utils/API.test.ts

@@ -396,33 +396,155 @@ describe.each(httpMethodTests)("$name", ({ name, method }: HTTPMethodType) => {
   });
 });
 
-describe.each(httpMethodTests)(".$name", ({ name, method }: HTTPMethodType) => {
-  test(`should make a ${method} request`, async () => {
-    const route: string = "fact";
-    const hostname: string = "catfact.ninja";
-    const api: API = new API(Protocol.HTTPS, new Hostname(hostname));
+// New tests replacing the skipped instance method tests
 
+describe("API.patch", () => {
+  test("should make a PATCH request", async () => {
     mockedAxios.mockResolvedValueOnce(createAxiosResponse());
 
     const url: URL = new URL(
-      api.protocol,
-      api.hostname,
-      api.baseRoute.addRoute(route),
+      Protocol.HTTPS,
+      "catfact.ninja",
+      new Route("fact"),
     );
-    const got: HTTPResponse<JSONObject> = await (api as any)[name]({
+    const got: HTTPResponse<JSONObject> = await API.patch({
       url,
       data: requestData,
       headers: requestHeaders,
     });
 
-    // Check method, url (protocol, hostname, route), headers, request data
     expect(axios).toBeCalledWith(
       createAxiosParameters({
+        method: "PATCH",
         url: "https://catfact.ninja/fact",
-        method,
         data: requestData,
+        headers: mergedHeaders,
       }),
     );
     expect(got).toBeInstanceOf(HTTPResponse);
   });
+
+  test("should make a PATCH request without data", async () => {
+    mockedAxios.mockResolvedValueOnce(createAxiosResponse());
+
+    const url: URL = new URL(
+      Protocol.HTTPS,
+      "catfact.ninja",
+      new Route("update"),
+    );
+    const got: HTTPResponse<JSONObject> = await API.patch({
+      url,
+    });
+
+    expect(axios).toBeCalledWith({
+      method: "PATCH",
+      url: "https://catfact.ninja/update",
+      headers: DEFAULT_HEADERS,
+      data: undefined,
+    });
+    expect(got).toBeInstanceOf(HTTPResponse);
+  });
+});
+
+describe("API.getFriendlyErrorMessage", () => {
+  test("should return error message from AxiosError", () => {
+    const errorMessage: string = "Request failed";
+    const axiosError: AxiosError = createAxiosError({
+      message: errorMessage,
+    });
+
+    const message: string = API.getFriendlyErrorMessage(axiosError);
+    expect(message).toBe(errorMessage);
+  });
+
+  test("should return error message from regular Error", () => {
+    const error: Error = new Error("Something went wrong");
+    const message: string = API.getFriendlyErrorMessage(error);
+    expect(message).toBe("Something went wrong");
+  });
+
+  test("should handle error and return non-empty string", () => {
+    const customError: Error = new Error("Network timeout occurred");
+    const message: string = API.getFriendlyErrorMessage(customError);
+    expect(message.length).toBeGreaterThan(0);
+  });
+
+  test("should return string type result", () => {
+    const error: Error = new Error("Test error");
+    const message: string = API.getFriendlyErrorMessage(error);
+    expect(typeof message).toBe("string");
+    expect(message.length).toBeGreaterThan(0);
+  });
+});
+
+describe("API instance properties", () => {
+  test("should return protocol with trailing slashes", () => {
+    const api: API = new API(Protocol.HTTPS, new Hostname("example.com"));
+    expect(api.protocol).toBe("https://");
+  });
+
+  test("should return protocol for HTTP", () => {
+    const api: API = new API(Protocol.HTTP, new Hostname("localhost"));
+    expect(api.protocol).toBe("http://");
+  });
+
+  test("should return hostname as string", () => {
+    const hostname: string = "api.example.com";
+    const api: API = new API(Protocol.HTTPS, new Hostname(hostname));
+    expect(api.hostname.toString()).toBe(hostname);
+  });
+
+  test("should handle nested route in base route", () => {
+    const api: API = new API(
+      Protocol.HTTPS,
+      new Hostname("api.example.com"),
+      new Route("/v1/api"),
+    );
+    expect(api.baseRoute.toString()).toBe("/v1/api");
+  });
+});
+
+describe("API.fetch with options", () => {
+  test("should make request with query parameters", async () => {
+    mockedAxios.mockResolvedValueOnce(
+      createAxiosResponse({ data: responseData }),
+    );
+
+    const params: Dictionary<string> = {
+      page: "1",
+      limit: "10",
+    };
+
+    await API.fetch({
+      method: HTTPMethod.GET,
+      url: new URL(Protocol.HTTPS, "api.example.com", new Route("items")),
+      params,
+    });
+
+    expect(axios).toBeCalledWith({
+      method: "GET",
+      url: "https://api.example.com/items?page=1&limit=10",
+      headers: DEFAULT_HEADERS,
+      data: undefined,
+    });
+  });
+
+  test("should handle empty params object", async () => {
+    mockedAxios.mockResolvedValueOnce(
+      createAxiosResponse({ data: responseData }),
+    );
+
+    await API.fetch({
+      method: HTTPMethod.GET,
+      url: new URL(Protocol.HTTPS, "api.example.com", new Route("items")),
+      params: {},
+    });
+
+    expect(axios).toBeCalledWith({
+      method: "GET",
+      url: "https://api.example.com/items",
+      headers: DEFAULT_HEADERS,
+      data: undefined,
+    });
+  });
 });

package/Tests/__mocks__/azure.js

@@ -0,0 +1,2 @@
+// Mock for @azure packages
+module.exports = {};

package/Tests/__mocks__/botbuilder-stdlib.js

@@ -0,0 +1,2 @@
+// Mock for botbuilder-stdlib package
+module.exports = {};

package/Tests/__mocks__/botbuilder.js

@@ -0,0 +1,10 @@
+// Mock for botbuilder, botbuilder-core, and botframework-connector packages
+module.exports = {
+  CloudAdapter: class CloudAdapter {},
+  ConfigurationBotFrameworkAuthentication: class ConfigurationBotFrameworkAuthentication {},
+  TeamsActivityHandler: class TeamsActivityHandler {},
+  TurnContext: class TurnContext {},
+  ActivityHandler: class ActivityHandler {},
+  MessageFactory: { text: jest.fn() },
+  CardFactory: { heroCard: jest.fn() },
+};

package/Tests/__mocks__/locter.js

@@ -0,0 +1,5 @@
+// Mock for locter package
+module.exports = {
+  locate: jest.fn(),
+  locateSync: jest.fn(),
+};

package/Tests/__mocks__/otpauth.js

@@ -0,0 +1,30 @@
+// Mock for otpauth package
+module.exports = {
+  HOTP: class HOTP {
+    generate() {
+      return "123456";
+    }
+    validate() {
+      return true;
+    }
+  },
+  TOTP: class TOTP {
+    generate() {
+      return "123456";
+    }
+    validate() {
+      return true;
+    }
+  },
+  Secret: class Secret {
+    static fromBase32() {
+      return new Secret();
+    }
+    base32 = "JBSWY3DPEHPK3PXP";
+  },
+  URI: {
+    parse: jest.fn(),
+    stringify: jest.fn(),
+  },
+  version: "9.0.0",
+};

package/Tests/__mocks__/simplewebauthn.js

@@ -0,0 +1,34 @@
+// Mock for @simplewebauthn/server package
+module.exports = {
+  generateRegistrationOptions: jest.fn().mockResolvedValue({
+    challenge: "mock-challenge",
+    rp: { name: "Mock RP", id: "localhost" },
+    user: { id: "user-id", name: "user@example.com", displayName: "User" },
+    pubKeyCredParams: [],
+    timeout: 60000,
+    attestation: "none",
+    excludeCredentials: [],
+    authenticatorSelection: {},
+  }),
+  verifyRegistrationResponse: jest.fn().mockResolvedValue({
+    verified: true,
+    registrationInfo: {
+      credentialID: Buffer.from("mock-credential-id"),
+      credentialPublicKey: Buffer.from("mock-public-key"),
+      counter: 0,
+    },
+  }),
+  generateAuthenticationOptions: jest.fn().mockResolvedValue({
+    challenge: "mock-challenge",
+    timeout: 60000,
+    rpId: "localhost",
+    allowCredentials: [],
+    userVerification: "preferred",
+  }),
+  verifyAuthenticationResponse: jest.fn().mockResolvedValue({
+    verified: true,
+    authenticationInfo: {
+      newCounter: 1,
+    },
+  }),
+};

package/Tests/__mocks__/styleMock.js

@@ -0,0 +1 @@
+module.exports = {};

package/Tests/__mocks__/uuid.js

@@ -0,0 +1,31 @@
+// Mock for uuid package with unique and valid UUID values
+let v1Counter = 0;
+let v4Counter = 0;
+
+// Generate a valid UUID by padding counter to create proper hex segments
+function padHex(num, length) {
+  return num.toString(16).padStart(length, "0").slice(-length);
+}
+
+module.exports = {
+  v1: jest.fn(() => {
+    v1Counter++;
+    // Generate valid v1 UUID format: xxxxxxxx-xxxx-1xxx-xxxx-xxxxxxxxxxxx
+    const p1 = padHex(v1Counter, 8);
+    const p2 = padHex(v1Counter * 2, 4);
+    const p3 = "1" + padHex(v1Counter * 3, 3);
+    const p4 = padHex(0x8000 + (v1Counter % 0x3fff), 4);
+    const p5 = padHex(v1Counter, 12);
+    return `${p1}-${p2}-${p3}-${p4}-${p5}`;
+  }),
+  v4: jest.fn(() => {
+    v4Counter++;
+    // Generate valid v4 UUID format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
+    const p1 = padHex(v4Counter + 0x10000000, 8);
+    const p2 = padHex(v4Counter * 2, 4);
+    const p3 = "4" + padHex(v4Counter * 3, 3);
+    const p4 = padHex(0x8000 + (v4Counter % 0x3fff), 4);
+    const p5 = padHex(v4Counter + 0x100000000000, 12);
+    return `${p1}-${p2}-${p3}-${p4}-${p5}`;
+  }),
+};

package/Tests/__mocks__/yaml.js

@@ -0,0 +1,11 @@
+// Mock for yaml package
+module.exports = {
+  parse: jest.fn((str) => {
+    return {};
+  }),
+  stringify: jest.fn((obj) => {
+    return "";
+  }),
+  parseDocument: jest.fn(),
+  parseAllDocuments: jest.fn(),
+};

package/Tests/jest.setup.ts

@@ -0,0 +1,14 @@
+import "@testing-library/jest-dom";
+import { TextEncoder, TextDecoder } from "util";
+
+// Polyfill TextEncoder/TextDecoder for jsdom
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+(global as any).TextEncoder = TextEncoder;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+(global as any).TextDecoder = TextDecoder;
+
+// Mock window.scrollTo for jsdom
+Object.defineProperty(window, "scrollTo", {
+  value: jest.fn(),
+  writable: true,
+});

package/UI/Components/AI/AITemplates.ts

@@ -0,0 +1,226 @@
+/*
+ * AI Template definitions for different note types
+ * These templates guide AI generation for various use cases
+ */
+
+export interface AITemplate {
+  id: string;
+  name: string;
+  content: string;
+}
+
+// Default hardcoded templates for incident postmortem
+export const POSTMORTEM_TEMPLATES: Array<AITemplate> = [
+  {
+    id: "default-standard",
+    name: "Standard Postmortem",
+    content: `## Executive Summary
+[Brief overview of the incident, its impact, and resolution]
+
+## Incident Timeline
+| Time | Event |
+|------|-------|
+| [Time] | [Event description] |
+
+## Root Cause Analysis
+[Detailed analysis of what caused the incident]
+
+## Impact Assessment
+- **Duration**: [How long the incident lasted]
+- **Users Affected**: [Number or percentage of affected users]
+- **Services Affected**: [List of affected services]
+
+## Resolution
+[Steps taken to resolve the incident]
+
+## Action Items
+- [ ] [Action item 1]
+- [ ] [Action item 2]
+- [ ] [Action item 3]
+
+## Lessons Learned
+[Key takeaways and improvements identified]`,
+  },
+  {
+    id: "default-detailed",
+    name: "Detailed Technical Postmortem",
+    content: `## Incident Overview
+**Incident Title**: [Title]
+**Severity**: [P1/P2/P3/P4]
+**Duration**: [Start time] - [End time]
+**Authors**: [Names]
+
+## Summary
+[2-3 sentence summary of the incident]
+
+## Detection
+- **How was the incident detected?** [Monitoring alert / Customer report / etc.]
+- **Time to detection**: [Duration from start to detection]
+
+## Timeline
+| Timestamp | Action | Owner |
+|-----------|--------|-------|
+| [Time] | [What happened] | [Who did it] |
+
+## Root Cause
+### Primary Cause
+[Detailed explanation of the root cause]
+
+### Contributing Factors
+1. [Factor 1]
+2. [Factor 2]
+
+## Impact
+### Customer Impact
+[Description of how customers were affected]
+
+### Business Impact
+[Description of business consequences]
+
+### Technical Impact
+[Systems and services affected]
+
+## Mitigation & Resolution
+### Immediate Actions
+[Steps taken to stop the bleeding]
+
+### Permanent Fix
+[Long-term solution implemented]
+
+## Prevention
+### What Went Well
+- [Item 1]
+- [Item 2]
+
+### What Went Wrong
+- [Item 1]
+- [Item 2]
+
+### Where We Got Lucky
+- [Item 1]
+
+## Action Items
+| Action | Owner | Priority | Due Date |
+|--------|-------|----------|----------|
+| [Action] | [Name] | [High/Medium/Low] | [Date] |
+
+## Appendix
+[Any additional technical details, logs, or graphs]`,
+  },
+  {
+    id: "default-brief",
+    name: "Brief Postmortem",
+    content: `## What Happened
+[Concise description of the incident]
+
+## Why It Happened
+[Root cause explanation]
+
+## How We Fixed It
+[Resolution steps]
+
+## How We Prevent It
+- [ ] [Prevention action 1]
+- [ ] [Prevention action 2]`,
+  },
+];
+
+// Default templates for public notes (customer-facing)
+export const PUBLIC_NOTE_TEMPLATES: Array<AITemplate> = [
+  {
+    id: "public-status-update",
+    name: "Status Update",
+    content: `## Current Status
+[Brief description of the current situation]
+
+## What We're Doing
+[Actions being taken to resolve the issue]
+
+## Next Update
+[Expected time for next update or resolution]`,
+  },
+  {
+    id: "public-resolution",
+    name: "Resolution Notice",
+    content: `## Issue Resolved
+[Brief description of what was resolved]
+
+## Summary
+[What happened and how it was fixed]
+
+## Prevention
+[Steps taken to prevent recurrence]
+
+Thank you for your patience.`,
+  },
+  {
+    id: "public-maintenance",
+    name: "Maintenance Update",
+    content: `## Maintenance Status
+[Current phase of the maintenance]
+
+## Progress
+[What has been completed]
+
+## Remaining Work
+[What still needs to be done]
+
+## Expected Completion
+[Estimated completion time]`,
+  },
+];
+
+// Default templates for internal notes (team-facing)
+export const INTERNAL_NOTE_TEMPLATES: Array<AITemplate> = [
+  {
+    id: "internal-investigation",
+    name: "Investigation Update",
+    content: `## Current Investigation Status
+[What we're looking at]
+
+## Findings So Far
+- [Finding 1]
+- [Finding 2]
+
+## Hypothesis
+[Current theory about the root cause]
+
+## Next Steps
+- [ ] [Action 1]
+- [ ] [Action 2]`,
+  },
+  {
+    id: "internal-technical",
+    name: "Technical Analysis",
+    content: `## Technical Details
+[Detailed technical observations]
+
+## Metrics/Logs
+[Relevant metrics or log entries]
+
+## Impact Assessment
+[Technical impact analysis]
+
+## Recommendations
+[Technical recommendations for resolution]`,
+  },
+  {
+    id: "internal-handoff",
+    name: "Shift Handoff",
+    content: `## Current State
+[Where things stand now]
+
+## Actions Taken
+[What has been done so far]
+
+## Open Questions
+[Things that still need investigation]
+
+## Immediate Priorities
+- [ ] [Priority 1]
+- [ ] [Priority 2]
+
+## Contacts
+[Key people involved or to contact]`,
+  },
+];