@windstream/react-shared-components 0.1.93 → 0.1.95

package/src/contentful/blocks/anchored-bottom-banner/index.test.tsx

@@ -0,0 +1,287 @@
+import { AnchoredBottomBanner } from "./index";
+
+import { act, render, screen } from "@testing-library/react";
+
+// Mock next/link
+jest.mock("next/link", () => {
+  // eslint-disable-next-line react/display-name
+  return ({ children, href, target, ...rest }: any) => (
+    <a href={href} target={target} {...rest}>
+      {children}
+    </a>
+  );
+});
+
+describe("AnchoredBottomBanner", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date("2026-05-19T12:00:00Z"));
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it("renders with default anchorId", () => {
+    const { container } = render(<AnchoredBottomBanner />);
+    expect(container.querySelector("#anchored-banner")).toBeInTheDocument();
+  });
+
+  it("renders with custom anchorId", () => {
+    const { container } = render(
+      <AnchoredBottomBanner anchorId="custom-banner" />
+    );
+    expect(container.querySelector("#custom-banner")).toBeInTheDocument();
+  });
+
+  it("renders ctaButtonLabel", () => {
+    render(<AnchoredBottomBanner ctaButtonLabel="Shop now" />);
+    expect(screen.getByText("Shop now")).toBeInTheDocument();
+  });
+
+  it("renders ctaSuffixText", () => {
+    render(<AnchoredBottomBanner ctaSuffixText="Limited time" />);
+    expect(screen.getByText("Limited time")).toBeInTheDocument();
+  });
+
+  it("renders iconName", () => {
+    render(<AnchoredBottomBanner iconName="local_offer" />);
+    expect(screen.getByText("local_offer")).toBeInTheDocument();
+  });
+
+  it("does not render icon when iconName is not provided", () => {
+    const { container } = render(<AnchoredBottomBanner />);
+    expect(
+      container.querySelector(".material-symbols-rounded")
+    ).not.toBeInTheDocument();
+  });
+
+  it("uses ctaButtonLink in the link href", () => {
+    render(<AnchoredBottomBanner ctaButtonLink="/offers" />);
+    const link = screen.getByRole("link");
+    expect(link).toHaveAttribute("href", "/offers");
+  });
+
+  it("defaults link href to # when ctaButtonLink is not provided", () => {
+    render(<AnchoredBottomBanner />);
+    const link = screen.getByRole("link");
+    expect(link).toHaveAttribute("href", "#");
+  });
+
+  it("uses ctaButtonTarget for link target", () => {
+    render(<AnchoredBottomBanner ctaButtonTarget="_blank" />);
+    const link = screen.getByRole("link");
+    expect(link).toHaveAttribute("target", "_blank");
+  });
+
+  it("defaults link target to _self", () => {
+    render(<AnchoredBottomBanner />);
+    const link = screen.getByRole("link");
+    expect(link).toHaveAttribute("target", "_self");
+  });
+
+  // Background colors
+  it("applies yellow background by default (no backgroundColor)", () => {
+    const { container } = render(<AnchoredBottomBanner />);
+    const div = container.querySelector(".bg-bg-fill-brand-accent");
+    expect(div).toBeInTheDocument();
+  });
+
+  it("applies navy background", () => {
+    const { container } = render(
+      <AnchoredBottomBanner backgroundColor="navy" />
+    );
+    expect(container.querySelector(".bg-bg-fill-inverse")).toBeInTheDocument();
+  });
+
+  it("applies green background", () => {
+    const { container } = render(
+      <AnchoredBottomBanner backgroundColor="green" />
+    );
+    expect(container.querySelector(".bg-bg-fill-success")).toBeInTheDocument();
+  });
+
+  it("applies blue background", () => {
+    const { container } = render(
+      <AnchoredBottomBanner backgroundColor="blue" />
+    );
+    expect(
+      container.querySelector(".bg-bg-fill-brand-supporting")
+    ).toBeInTheDocument();
+  });
+
+  it("applies purple background", () => {
+    const { container } = render(
+      <AnchoredBottomBanner backgroundColor="purple" />
+    );
+    expect(
+      container.querySelector(".bg-bg-fill-brand-tertiary")
+    ).toBeInTheDocument();
+  });
+
+  it("applies white background", () => {
+    const { container } = render(
+      <AnchoredBottomBanner backgroundColor="white" />
+    );
+    expect(container.querySelector(".bg-white")).toBeInTheDocument();
+  });
+
+  // Text colors
+  it("uses dark text for yellow/white/no background", () => {
+    const { container } = render(
+      <AnchoredBottomBanner ctaButtonLabel="Test" />
+    );
+    expect(container.querySelector(".text-text-primary")).toBeInTheDocument();
+  });
+
+  it("uses white text for dark backgrounds", () => {
+    const { container } = render(
+      <AnchoredBottomBanner backgroundColor="navy" ctaButtonLabel="Test" />
+    );
+    expect(container.querySelector(".text-white")).toBeInTheDocument();
+  });
+
+  // Box shadow
+  it("uses default shadow when boxShadow is not provided", () => {
+    const { container } = render(<AnchoredBottomBanner />);
+    const div = container.querySelector(
+      '[class*="shadow-[0_-4px_10px_rgba(0,0,0,0.1)]"]'
+    );
+    expect(div).toBeInTheDocument();
+  });
+
+  it("uses boxShadow value when provided", () => {
+    const { container } = render(
+      <AnchoredBottomBanner boxShadow={true as any} />
+    );
+    const div = container.querySelector(
+      '[class*="shadow-[0_-4px_10px_rgba(0,0,0,0.1)]"]'
+    );
+    expect(div).not.toBeInTheDocument();
+  });
+
+  // Countdown timer
+  it("shows countdown when timer is enabled and within range", () => {
+    const end = new Date("2026-05-19T13:00:00Z").toISOString();
+    render(
+      <AnchoredBottomBanner
+        enableCountdownTimer={true}
+        countdownEndDateTime={end}
+      />
+    );
+    // 1 hour remaining: 01H : 00M : 00
+    expect(screen.getByText(/01H : 00M : 00/)).toBeInTheDocument();
+  });
+
+  it("does not show countdown when timer is disabled", () => {
+    const end = new Date("2026-05-19T13:00:00Z").toISOString();
+    render(<AnchoredBottomBanner countdownEndDateTime={end} />);
+    expect(screen.queryByText(/H :/)).not.toBeInTheDocument();
+  });
+
+  it("does not show countdown before start time", () => {
+    const start = new Date("2026-05-19T14:00:00Z").toISOString();
+    const end = new Date("2026-05-19T15:00:00Z").toISOString();
+    render(
+      <AnchoredBottomBanner
+        enableCountdownTimer={true}
+        countdownStartDateTime={start}
+        countdownEndDateTime={end}
+      />
+    );
+    expect(screen.queryByText(/H :/)).not.toBeInTheDocument();
+  });
+
+  it("does not show countdown after end time", () => {
+    const end = new Date("2026-05-19T11:00:00Z").toISOString();
+    render(
+      <AnchoredBottomBanner
+        enableCountdownTimer={true}
+        countdownEndDateTime={end}
+      />
+    );
+    expect(screen.queryByText(/H :/)).not.toBeInTheDocument();
+  });
+
+  it("updates countdown every second", () => {
+    const end = new Date("2026-05-19T12:00:10Z").toISOString();
+    render(
+      <AnchoredBottomBanner
+        enableCountdownTimer={true}
+        countdownEndDateTime={end}
+      />
+    );
+    expect(screen.getByText(/00H : 00M : 10/)).toBeInTheDocument();
+
+    act(() => {
+      jest.advanceTimersByTime(1000);
+    });
+    expect(screen.getByText(/00H : 00M : 09/)).toBeInTheDocument();
+  });
+
+  it("clears interval when countdown reaches zero", () => {
+    const end = new Date("2026-05-19T12:00:01Z").toISOString();
+    render(
+      <AnchoredBottomBanner
+        enableCountdownTimer={true}
+        countdownEndDateTime={end}
+      />
+    );
+
+    act(() => {
+      jest.advanceTimersByTime(2000);
+    });
+    // After expiry, countdown should not show
+    expect(screen.queryByText(/H :/)).not.toBeInTheDocument();
+  });
+
+  it("handles invalid countdownEndDateTime gracefully", () => {
+    const consoleSpy = jest.spyOn(console, "error").mockImplementation(() => {
+      /* noop */
+    });
+    render(
+      <AnchoredBottomBanner
+        enableCountdownTimer={true}
+        countdownEndDateTime="not-a-date"
+      />
+    );
+    expect(screen.queryByText(/H :/)).not.toBeInTheDocument();
+    consoleSpy.mockRestore();
+  });
+
+  it("handles invalid countdownStartDateTime gracefully", () => {
+    const consoleSpy = jest.spyOn(console, "error").mockImplementation(() => {
+      /* noop */
+    });
+    const end = new Date("2026-05-19T13:00:00Z").toISOString();
+    render(
+      <AnchoredBottomBanner
+        enableCountdownTimer={true}
+        countdownStartDateTime="not-a-date"
+        countdownEndDateTime={end}
+      />
+    );
+    expect(screen.queryByText(/H :/)).not.toBeInTheDocument();
+    consoleSpy.mockRestore();
+  });
+
+  it("logs error when start is after end", () => {
+    const consoleSpy = jest.spyOn(console, "error").mockImplementation(() => {
+      /* noop */
+    });
+    const start = new Date("2026-05-19T15:00:00Z").toISOString();
+    const end = new Date("2026-05-19T13:00:00Z").toISOString();
+    render(
+      <AnchoredBottomBanner
+        enableCountdownTimer={true}
+        countdownStartDateTime={start}
+        countdownEndDateTime={end}
+      />
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      "Invalid countdown range: start must be before end",
+      expect.any(Object)
+    );
+    consoleSpy.mockRestore();
+  });
+});

package/src/contentful/blocks/blogs-grid/BlogGrid.stories.tsx

@@ -109,9 +109,7 @@ export const EmptyState: Story = {
 
 export const CategoryFilterActive: Story = {
   args: {
-    paginatedArticles: ALL_ARTICLES.filter(
-      (a) => a.category === "Technology",
-    ),
+    paginatedArticles: ALL_ARTICLES.filter(a => a.category === "Technology"),
     totalArticles: 4,
     currentPage: 1,
     totalPages: 1,
@@ -139,7 +137,10 @@ export const WithoutCoverImages: Story = {
 
 export const MixedCoverImages: Story = {
   args: {
-    paginatedArticles: [...ARTICLES_WITH_COVERS.slice(4), ...ARTICLES_WITHOUT_COVERS],
+    paginatedArticles: [
+      ...ARTICLES_WITH_COVERS.slice(4),
+      ...ARTICLES_WITHOUT_COVERS,
+    ],
     totalArticles: 5,
     currentPage: 1,
     totalPages: 1,

package/src/contentful/blocks/blogs-grid/index.test.tsx

@@ -0,0 +1,355 @@
+import React from "react";
+import { BlogGrid } from "./index";
+import { BlogCategoryOption, BlogGridProps } from "./types";
+
+import { fireEvent, render, screen } from "@testing-library/react";
+
+const mockPush = jest.fn();
+let mockSearchParams = new URLSearchParams("");
+
+jest.mock("next/navigation", () => ({
+  useRouter: () => ({ push: mockPush }),
+  usePathname: () => "/blog",
+  useSearchParams: () => mockSearchParams,
+}));
+
+jest.mock("@shared/components/pagination", () => ({
+  Pagination: ({ currentPage, totalPages, onPageChange, ariaLabel }: any) => (
+    <nav aria-label={ariaLabel} data-testid="pagination">
+      <span>
+        Page {currentPage} of {totalPages}
+      </span>
+      <button data-testid="page-next" onClick={() => onPageChange(2)}>
+        Next
+      </button>
+      <button data-testid="page-first" onClick={() => onPageChange(1)}>
+        First
+      </button>
+    </nav>
+  ),
+}));
+
+jest.mock("@shared/components/select", () => ({
+  Select: ({ options, value, onChange, className }: any) => (
+    <select
+      data-testid="category-select"
+      className={className}
+      value={value?.value}
+      onChange={e => {
+        const opt = options.find((o: any) => o.value === e.target.value);
+        onChange(opt);
+      }}
+    >
+      {options.map((o: any) => (
+        <option key={o.value} value={o.value}>
+          {o.label}
+        </option>
+      ))}
+    </select>
+  ),
+}));
+
+jest.mock("@shared/components/text", () => ({
+  Text: ({ as: Tag = "span", children, className }: any) => (
+    <Tag className={className}>{children}</Tag>
+  ),
+}));
+
+jest.mock("@shared/contentful/blocks/cards/blog-card", () => ({
+  BlogCard: ({ href, title, category, image, index }: any) => (
+    <a
+      href={href}
+      data-testid={`blog-card-${index}`}
+      data-image-src={image?.src || ""}
+      data-image-alt={image?.alt || ""}
+      data-image-width={image?.width || ""}
+      data-image-height={image?.height || ""}
+    >
+      {title} - {category}
+    </a>
+  ),
+}));
+
+const categoryOptions: BlogCategoryOption[] = [
+  { value: "all", label: "All Categories" },
+  { value: "tech", label: "Technology" },
+  { value: "news", label: "News" },
+];
+
+const mockArticles = [
+  {
+    slug: "/article-1",
+    title: "Article One",
+    shortDescription: "Desc 1",
+    blogCreationDate: "2024-01-01",
+    category: "tech",
+    cover: {
+      url: "https://img.test/1.jpg",
+      width: 600,
+      height: 338,
+      title: "Cover 1",
+    },
+  },
+  {
+    slug: "article-2",
+    title: "Article Two",
+    shortDescription: "Desc 2",
+    blogCreationDate: "2024-02-01",
+    category: "news",
+    cover: {
+      url: "https://img.test/2.jpg",
+      width: 800,
+      height: 450,
+      title: "",
+    },
+  },
+  {
+    slug: "article-3",
+    title: "Article Three",
+    shortDescription: "Desc 3",
+    blogCreationDate: "2024-03-01",
+    category: "tech",
+  },
+];
+
+const defaultProps: BlogGridProps = {
+  paginatedArticles: mockArticles,
+  totalArticles: 10,
+  currentPage: 1,
+  totalPages: 3,
+  selectedCategory: categoryOptions[0],
+  categoryOptions,
+};
+
+describe("BlogGrid", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockSearchParams = new URLSearchParams("");
+    window.scrollTo = jest.fn();
+  });
+
+  describe("Rendering", () => {
+    it("renders section with correct aria-label and data attributes", () => {
+      const { container } = render(<BlogGrid {...defaultProps} />);
+      const section = container.querySelector("section");
+      expect(section).toHaveAttribute("aria-label", "Blog articles");
+      expect(section).toHaveAttribute("data-section-type", "blogs-grid");
+      expect(section).toHaveAttribute("data-section-index", "0");
+    });
+
+    it("renders article count text", () => {
+      render(<BlogGrid {...defaultProps} />);
+      expect(screen.getByText("3 of 10 articles")).toBeInTheDocument();
+    });
+
+    it("renders all blog cards", () => {
+      render(<BlogGrid {...defaultProps} />);
+      expect(screen.getByTestId("blog-card-0")).toBeInTheDocument();
+      expect(screen.getByTestId("blog-card-1")).toBeInTheDocument();
+      expect(screen.getByTestId("blog-card-2")).toBeInTheDocument();
+    });
+
+    it("renders blog card with correct href when slug starts with /", () => {
+      render(<BlogGrid {...defaultProps} />);
+      expect(screen.getByTestId("blog-card-0")).toHaveAttribute(
+        "href",
+        "/article-1"
+      );
+    });
+
+    it("prepends / to slug when it does not start with /", () => {
+      render(<BlogGrid {...defaultProps} />);
+      expect(screen.getByTestId("blog-card-1")).toHaveAttribute(
+        "href",
+        "/article-2"
+      );
+    });
+
+    it("renders empty state when no articles", () => {
+      render(<BlogGrid {...defaultProps} paginatedArticles={[]} />);
+      expect(screen.getByText("No articles found.")).toBeInTheDocument();
+    });
+
+    it("does not render pagination when totalPages is 1", () => {
+      render(<BlogGrid {...defaultProps} totalPages={1} />);
+      expect(screen.queryByTestId("pagination")).not.toBeInTheDocument();
+    });
+
+    it("renders pagination when totalPages > 1", () => {
+      render(<BlogGrid {...defaultProps} />);
+      expect(screen.getByTestId("pagination")).toBeInTheDocument();
+    });
+  });
+
+  describe("Category filter", () => {
+    it("navigates with category param on selection", () => {
+      render(<BlogGrid {...defaultProps} />);
+      fireEvent.change(screen.getByTestId("category-select"), {
+        target: { value: "tech" },
+      });
+      expect(mockPush).toHaveBeenCalledWith("/blog?category=tech", {
+        scroll: false,
+      });
+    });
+
+    it("removes category param when 'all' is selected", () => {
+      render(<BlogGrid {...defaultProps} />);
+      fireEvent.change(screen.getByTestId("category-select"), {
+        target: { value: "all" },
+      });
+      expect(mockPush).toHaveBeenCalledWith("/blog?", { scroll: false });
+    });
+
+    it("deletes page param when category changes", () => {
+      mockSearchParams = new URLSearchParams("page=3&category=news");
+      render(<BlogGrid {...defaultProps} />);
+      fireEvent.change(screen.getByTestId("category-select"), {
+        target: { value: "tech" },
+      });
+      expect(mockPush).toHaveBeenCalledWith("/blog?category=tech", {
+        scroll: false,
+      });
+    });
+
+    it("does nothing when onChange receives falsy value", () => {
+      render(<BlogGrid {...defaultProps} />);
+      // Simulate onChange with a value not found in options (returns undefined)
+      fireEvent.change(screen.getByTestId("category-select"), {
+        target: { value: "nonexistent" },
+      });
+      expect(mockPush).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("Pagination", () => {
+    it("navigates with page param on page change", () => {
+      render(<BlogGrid {...defaultProps} />);
+      fireEvent.click(screen.getByTestId("page-next"));
+      expect(mockPush).toHaveBeenCalledWith("/blog?page=2", { scroll: false });
+      expect(window.scrollTo).toHaveBeenCalledWith({
+        top: 0,
+        behavior: "smooth",
+      });
+    });
+
+    it("removes page param when navigating to page 1", () => {
+      render(<BlogGrid {...defaultProps} currentPage={2} />);
+      fireEvent.click(screen.getByTestId("page-first"));
+      expect(mockPush).toHaveBeenCalledWith("/blog?", { scroll: false });
+    });
+  });
+
+  describe("Cover image handling", () => {
+    it("renders card with full cover image data", () => {
+      render(<BlogGrid {...defaultProps} />);
+      const card = screen.getByTestId("blog-card-0");
+      expect(card).toHaveAttribute("data-image-src", "https://img.test/1.jpg");
+      expect(card).toHaveAttribute("data-image-alt", "Cover 1");
+      expect(card).toHaveAttribute("data-image-width", "600");
+      expect(card).toHaveAttribute("data-image-height", "338");
+    });
+
+    it("renders card without cover image when cover is undefined", () => {
+      render(<BlogGrid {...defaultProps} />);
+      const card = screen.getByTestId("blog-card-2");
+      expect(card).toHaveAttribute("data-image-src", "");
+    });
+
+    it("uses article title as alt fallback when cover title is empty", () => {
+      const articles = [
+        {
+          slug: "test-article",
+          title: "Test Title",
+          cover: {
+            url: "https://img.test/x.jpg",
+            width: 600,
+            height: 338,
+            title: "",
+          },
+        },
+      ];
+      render(<BlogGrid {...defaultProps} paginatedArticles={articles} />);
+      expect(screen.getByTestId("blog-card-0")).toHaveAttribute(
+        "data-image-alt",
+        "Test Title"
+      );
+    });
+
+    it("uses default alt text when both cover title and article title are missing", () => {
+      const articles = [
+        {
+          slug: "no-title",
+          cover: { url: "https://img.test/y.jpg" },
+        },
+      ];
+      render(<BlogGrid {...defaultProps} paginatedArticles={articles} />);
+      expect(screen.getByTestId("blog-card-0")).toHaveAttribute(
+        "data-image-alt",
+        "Blog article image"
+      );
+    });
+
+    it("uses default width and height when not provided in cover", () => {
+      const articles = [
+        {
+          slug: "no-dimensions",
+          title: "No Dimensions",
+          cover: { url: "https://img.test/z.jpg", title: "Cover" },
+        },
+      ];
+      render(<BlogGrid {...defaultProps} paginatedArticles={articles} />);
+      const card = screen.getByTestId("blog-card-0");
+      expect(card).toHaveAttribute("data-image-width", "600");
+      expect(card).toHaveAttribute("data-image-height", "338");
+    });
+
+    it("uses provided width and height from cover", () => {
+      const articles = [
+        {
+          slug: "with-dimensions",
+          title: "With Dimensions",
+          cover: {
+            url: "https://img.test/w.jpg",
+            title: "Cover",
+            width: 800,
+            height: 450,
+          },
+        },
+      ];
+      render(<BlogGrid {...defaultProps} paginatedArticles={articles} />);
+      const card = screen.getByTestId("blog-card-0");
+      expect(card).toHaveAttribute("data-image-width", "800");
+      expect(card).toHaveAttribute("data-image-height", "450");
+    });
+
+    it("handles article with cover set to null", () => {
+      const articles = [
+        {
+          slug: "null-cover",
+          title: "Null Cover",
+          cover: null as any,
+        },
+      ];
+      render(<BlogGrid {...defaultProps} paginatedArticles={articles} />);
+      expect(screen.getByTestId("blog-card-0")).toHaveAttribute(
+        "data-image-src",
+        ""
+      );
+    });
+
+    it("handles article with cover url empty string", () => {
+      const articles = [
+        {
+          slug: "empty-url",
+          title: "Empty URL",
+          cover: { url: "", title: "Cover" },
+        },
+      ];
+      render(<BlogGrid {...defaultProps} paginatedArticles={articles} />);
+      expect(screen.getByTestId("blog-card-0")).toHaveAttribute(
+        "data-image-src",
+        ""
+      );
+    });
+  });
+});