primekit 1.0.8 → 1.0.10

package/src/lib/lib/atomix-table/atomix-table.component.spec.ts

@@ -0,0 +1,1648 @@
+import { ChangeDetectorRef, NO_ERRORS_SCHEMA } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { ConfirmationService } from 'primeng/api';
+import { DatePipe } from '@angular/common';
+import { AtomixTableComponent } from './atomix-table.component';
+import { Column, Row } from './atomix-table.models';
+
+describe('AtomixTableComponent', () => {
+  let component: AtomixTableComponent;
+  let fixture: ComponentFixture<AtomixTableComponent>;
+  let mockConfirmationService: { confirm: jest.Mock };
+  let mockDatePipe: { transform: jest.Mock };
+  let mockCdr: { detectChanges: jest.Mock };
+
+  beforeEach(() => {
+    mockConfirmationService = { confirm: jest.fn() };
+    mockDatePipe = { transform: jest.fn() };
+    mockCdr = { detectChanges: jest.fn() };
+
+    TestBed.configureTestingModule({
+      declarations: [AtomixTableComponent],
+      providers: [
+        { provide: ConfirmationService, useValue: mockConfirmationService },
+        { provide: DatePipe, useValue: mockDatePipe },
+        { provide: ChangeDetectorRef, useValue: mockCdr },
+      ],
+      schemas: [NO_ERRORS_SCHEMA],
+    });
+    fixture = TestBed.createComponent(AtomixTableComponent);
+    component = fixture.componentInstance;
+
+    // Initialize required inputs to prevent template errors
+    component.rows = [];
+    component.cols = [];
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+
+  describe('initialization with rows and cols', () => {
+    it('should accept rows input', () => {
+      const mockRows: Row[] = [
+        { id: '1', name: 'Item 1' },
+        { id: '2', name: 'Item 2' },
+      ];
+      component.rows = mockRows;
+      expect(component.rows).toEqual(mockRows);
+    });
+
+    it('should accept cols input', () => {
+      const mockCols: Column[] = [
+        { name: 'Name', field: 'name' },
+        { name: 'Status', field: 'status', type: 'string' },
+      ];
+      component.cols = mockCols;
+      expect(component.cols).toEqual(mockCols);
+    });
+
+    it('should accept rows as an array of data objects', () => {
+      const mockRows: Row[] = [
+        { id: '1', name: 'Product A', price: 10.99 },
+        { id: '2', name: 'Product B', price: 20.5 },
+        { id: '3', name: 'Product C', price: 5.0 },
+      ];
+      component.rows = mockRows;
+      expect(component.rows).toHaveLength(3);
+      expect(component.rows[0]).toEqual({ id: '1', name: 'Product A', price: 10.99 });
+    });
+
+    it('should accept cols as an array of column definitions', () => {
+      const mockCols: Column[] = [
+        { name: 'Product Name', field: 'name', type: 'string' },
+        { name: 'Price', field: 'price', type: 'number' },
+        { name: 'Created', field: 'createdAt', type: 'date', filterByDate: true },
+      ];
+      component.cols = mockCols;
+      expect(component.cols).toHaveLength(3);
+      expect(component.cols[2]).toEqual({
+        name: 'Created',
+        field: 'createdAt',
+        type: 'date',
+        filterByDate: true,
+      });
+    });
+
+    it('should initialize with both rows and cols together', () => {
+      const mockRows: Row[] = [
+        { id: '1', name: 'Item 1', status: 'active' },
+      ];
+      const mockCols: Column[] = [
+        { name: 'Name', field: 'name' },
+        { name: 'Status', field: 'status' },
+      ];
+      component.rows = mockRows;
+      component.cols = mockCols;
+      expect(component.rows).toEqual(mockRows);
+      expect(component.cols).toEqual(mockCols);
+    });
+  });
+
+  describe('row selection', () => {
+    const mockRows: Row[] = [
+      { id: '1', name: 'Item 1' },
+      { id: '2', name: 'Item 2' },
+      { id: '3', name: 'Item 3' },
+    ];
+
+    beforeEach(() => {
+      component.rows = mockRows;
+      component.cols = [{ name: 'Name', field: 'name' }];
+    });
+
+    describe('onRowSelect', () => {
+      it('should emit selectedRows with the current selectedTableRows', () => {
+        const emitSpy = jest.spyOn(component.selectedRows, 'emit');
+        component.selectedTableRows = [mockRows[0]];
+
+        component.onRowSelect();
+
+        expect(emitSpy).toHaveBeenCalledWith([mockRows[0]]);
+      });
+
+      it('should emit selectedRows with multiple selected rows', () => {
+        const emitSpy = jest.spyOn(component.selectedRows, 'emit');
+        component.selectedTableRows = [mockRows[0], mockRows[1]];
+
+        component.onRowSelect();
+
+        expect(emitSpy).toHaveBeenCalledWith([mockRows[0], mockRows[1]]);
+      });
+
+      it('should emit undefined when no rows are selected', () => {
+        const emitSpy = jest.spyOn(component.selectedRows, 'emit');
+        component.selectedTableRows = undefined;
+
+        component.onRowSelect();
+
+        expect(emitSpy).toHaveBeenCalledWith(undefined);
+      });
+    });
+
+    describe('onRowUnselect', () => {
+      it('should emit selectedRows after a row is unselected', () => {
+        const emitSpy = jest.spyOn(component.selectedRows, 'emit');
+        component.selectedTableRows = [mockRows[0], mockRows[1]];
+
+        // Simulate unselecting a row by removing it from selectedTableRows
+        component.selectedTableRows = [mockRows[0]];
+        component.onRowUnselect();
+
+        expect(emitSpy).toHaveBeenCalledWith([mockRows[0]]);
+      });
+
+      it('should emit empty array when all rows are unselected', () => {
+        const emitSpy = jest.spyOn(component.selectedRows, 'emit');
+        component.selectedTableRows = [];
+
+        component.onRowUnselect();
+
+        expect(emitSpy).toHaveBeenCalledWith([]);
+      });
+
+      it('should emit undefined when selectedTableRows is undefined', () => {
+        const emitSpy = jest.spyOn(component.selectedRows, 'emit');
+        component.selectedTableRows = undefined;
+
+        component.onRowUnselect();
+
+        expect(emitSpy).toHaveBeenCalledWith(undefined);
+      });
+    });
+
+    describe('onCheckboxSelect', () => {
+      it('should emit selectedRows with the current selectedTableRows', () => {
+        const emitSpy = jest.spyOn(component.selectedRows, 'emit');
+        component.selectedTableRows = [mockRows[0], mockRows[2]];
+
+        component.onCheckboxSelect();
+
+        expect(emitSpy).toHaveBeenCalledWith([mockRows[0], mockRows[2]]);
+      });
+
+      it('should emit all rows when all checkboxes are selected', () => {
+        const emitSpy = jest.spyOn(component.selectedRows, 'emit');
+        component.selectedTableRows = [...mockRows];
+
+        component.onCheckboxSelect();
+
+        expect(emitSpy).toHaveBeenCalledWith(mockRows);
+      });
+
+      it('should emit empty array when no checkboxes are selected', () => {
+        const emitSpy = jest.spyOn(component.selectedRows, 'emit');
+        component.selectedTableRows = [];
+
+        component.onCheckboxSelect();
+
+        expect(emitSpy).toHaveBeenCalledWith([]);
+      });
+    });
+
+    describe('selectedRows EventEmitter', () => {
+      it('should emit correct payload when subscribing to selectedRows output', () => {
+        const emittedValues: (Row[] | undefined)[] = [];
+        component.selectedRows.subscribe((value) => emittedValues.push(value));
+
+        component.selectedTableRows = [mockRows[0]];
+        component.onRowSelect();
+
+        component.selectedTableRows = [mockRows[0], mockRows[1]];
+        component.onCheckboxSelect();
+
+        component.selectedTableRows = [mockRows[1]];
+        component.onRowUnselect();
+
+        expect(emittedValues).toEqual([
+          [mockRows[0]],
+          [mockRows[0], mockRows[1]],
+          [mockRows[1]],
+        ]);
+      });
+
+      it('should emit the selectedTableRows reference each time a selection method is called', () => {
+        const emitSpy = jest.spyOn(component.selectedRows, 'emit');
+
+        component.selectedTableRows = [mockRows[2]];
+        component.onRowSelect();
+
+        component.selectedTableRows = [mockRows[0], mockRows[1], mockRows[2]];
+        component.onCheckboxSelect();
+
+        expect(emitSpy).toHaveBeenCalledTimes(2);
+        expect(emitSpy).toHaveBeenNthCalledWith(1, [mockRows[2]]);
+        expect(emitSpy).toHaveBeenNthCalledWith(2, [mockRows[0], mockRows[1], mockRows[2]]);
+      });
+    });
+  });
+
+  describe('selectAllOnInit behavior', () => {
+    const mockRows: Row[] = [
+      { id: '1', name: 'Item 1' },
+      { id: '2', name: 'Item 2' },
+      { id: '3', name: 'Item 3' },
+    ];
+
+    it('should select all rows when enableSelectAllOnInit is true and rows are provided', () => {
+      component.enableSelectAllOnInit = true;
+      component.rows = mockRows;
+
+      component.ngOnChanges({});
+
+      expect(component.selectedTableRows).toEqual(mockRows);
+    });
+
+    it('should NOT auto-select rows when enableSelectAllOnInit is false', () => {
+      component.enableSelectAllOnInit = false;
+      component.rows = mockRows;
+
+      component.ngOnChanges({});
+
+      expect(component.selectedTableRows).toBeUndefined();
+    });
+
+    it('should not set selectedTableRows when enableSelectAllOnInit is true but rows is empty', () => {
+      component.enableSelectAllOnInit = true;
+      component.rows = [];
+
+      component.ngOnChanges({});
+
+      // onRowsInit returns early when rows.length === 0, so selectedTableRows stays as initialized
+      expect(component.selectedTableRows).toBeUndefined();
+    });
+
+    it('should emit selectedRows when selectAllOnInit triggers with rows', () => {
+      const emitSpy = jest.spyOn(component.selectedRows, 'emit');
+      component.enableSelectAllOnInit = true;
+      component.rows = mockRows;
+
+      component.ngOnChanges({});
+
+      expect(emitSpy).toHaveBeenCalledWith(mockRows);
+    });
+
+    it('should not emit selectedRows when rows is empty (early return)', () => {
+      const emitSpy = jest.spyOn(component.selectedRows, 'emit');
+      component.enableSelectAllOnInit = true;
+      component.rows = [];
+
+      component.ngOnChanges({});
+
+      expect(emitSpy).not.toHaveBeenCalled();
+    });
+
+    it('should emit undefined for selectedRows when enableSelectAllOnInit is false', () => {
+      const emitSpy = jest.spyOn(component.selectedRows, 'emit');
+      component.enableSelectAllOnInit = false;
+      component.rows = mockRows;
+
+      component.ngOnChanges({});
+
+      expect(emitSpy).toHaveBeenCalledWith(undefined);
+    });
+  });
+
+  describe('filtering', () => {
+    beforeEach(() => {
+      component.rows = [
+        { id: '1', name: 'Item 1', status: 'active' },
+        { id: '2', name: 'Item 2', status: 'inactive' },
+      ];
+      component.cols = [
+        { name: 'Name', field: 'name' },
+        { name: 'Status', field: 'status' },
+      ];
+    });
+
+    describe('filterResults with text filters', () => {
+      it('should emit filterChange with processed text filter values', () => {
+        const emitSpy = jest.spyOn(component.filterChange, 'emit');
+
+        const event = {
+          filters: {
+            name: [{ value: 'Item 1', matchMode: 'contains', operator: 'and' }],
+          },
+        };
+
+        component.filterResults(event);
+
+        expect(emitSpy).toHaveBeenCalledWith({
+          name: [{ value: 'Item 1', matchMode: 'contains', operator: 'and' }],
+        });
+      });
+
+      it('should exclude filters with null values', () => {
+        const emitSpy = jest.spyOn(component.filterChange, 'emit');
+
+        const event = {
+          filters: {
+            name: [{ value: null, matchMode: 'contains', operator: 'and' }],
+            status: [{ value: 'active', matchMode: 'equals', operator: 'and' }],
+          },
+        };
+
+        component.filterResults(event);
+
+        expect(emitSpy).toHaveBeenCalledWith({
+          status: [{ value: 'active', matchMode: 'equals', operator: 'and' }],
+        });
+      });
+
+      it('should emit empty object when all filter values are null', () => {
+        const emitSpy = jest.spyOn(component.filterChange, 'emit');
+
+        const event = {
+          filters: {
+            name: [{ value: null, matchMode: 'contains', operator: 'and' }],
+            status: [{ value: null, matchMode: 'equals', operator: 'and' }],
+          },
+        };
+
+        component.filterResults(event);
+
+        expect(emitSpy).toHaveBeenCalledWith({});
+      });
+
+      it('should handle multiple non-null filters for the same field', () => {
+        const emitSpy = jest.spyOn(component.filterChange, 'emit');
+
+        const event = {
+          filters: {
+            name: [
+              { value: 'Item', matchMode: 'contains', operator: 'and' },
+              { value: 'Product', matchMode: 'contains', operator: 'or' },
+            ],
+          },
+        };
+
+        component.filterResults(event);
+
+        expect(emitSpy).toHaveBeenCalledWith({
+          name: [
+            { value: 'Item', matchMode: 'contains', operator: 'and' },
+            { value: 'Product', matchMode: 'contains', operator: 'or' },
+          ],
+        });
+      });
+
+      it('should normalize dateIs matchMode to equals', () => {
+        const emitSpy = jest.spyOn(component.filterChange, 'emit');
+
+        const event = {
+          filters: {
+            createdAt: [{ value: '2024-01-15', matchMode: 'dateIs', operator: 'and' }],
+          },
+        };
+
+        component.filterResults(event);
+
+        expect(emitSpy).toHaveBeenCalledWith({
+          createdAt: [{ value: '2024-01-15', matchMode: 'equals', operator: 'and' }],
+        });
+      });
+    });
+
+    describe('filterResults with date filters', () => {
+      it('should format Date objects using DatePipe and set matchMode to equals', () => {
+        const emitSpy = jest.spyOn(component.filterChange, 'emit');
+        const testDate = new Date(2024, 0, 15); // Jan 15, 2024
+        mockDatePipe.transform.mockReturnValue('2024-01-15');
+
+        const event = {
+          filters: {
+            createdAt: [{ value: testDate, matchMode: 'dateIs', operator: 'and' }],
+          },
+        };
+
+        component.filterResults(event);
+
+        expect(mockDatePipe.transform).toHaveBeenCalledWith(testDate, 'yyyy-MM-dd');
+        expect(emitSpy).toHaveBeenCalledWith({
+          createdAt: [{ value: '2024-01-15', matchMode: 'equals', operator: 'and' }],
+        });
+      });
+
+      it('should handle multiple date filters across different fields', () => {
+        const emitSpy = jest.spyOn(component.filterChange, 'emit');
+        const date1 = new Date(2024, 0, 10);
+        const date2 = new Date(2024, 5, 20);
+        mockDatePipe.transform.mockImplementation((date: Date) => {
+          if (date === date1) return '2024-01-10';
+          if (date === date2) return '2024-06-20';
+          return '';
+        });
+
+        const event = {
+          filters: {
+            createdAt: [{ value: date1, matchMode: 'dateIs', operator: 'and' }],
+            updatedAt: [{ value: date2, matchMode: 'dateIs', operator: 'and' }],
+          },
+        };
+
+        component.filterResults(event);
+
+        expect(emitSpy).toHaveBeenCalledWith({
+          createdAt: [{ value: '2024-01-10', matchMode: 'equals', operator: 'and' }],
+          updatedAt: [{ value: '2024-06-20', matchMode: 'equals', operator: 'and' }],
+        });
+      });
+    });
+
+    describe('filterResults with date range filters', () => {
+      it('should format date range arrays using DatePipe and set matchMode to between', () => {
+        const emitSpy = jest.spyOn(component.filterChange, 'emit');
+        const startDate = new Date(2024, 0, 1);
+        const endDate = new Date(2024, 0, 31);
+        mockDatePipe.transform.mockImplementation((date: Date) => {
+          if (date === startDate) return '2024-01-01';
+          if (date === endDate) return '2024-01-31';
+          return '';
+        });
+
+        const event = {
+          filters: {
+            createdAt: [{ value: [startDate, endDate], matchMode: 'dateIs', operator: 'and' }],
+          },
+        };
+
+        component.filterResults(event);
+
+        expect(mockDatePipe.transform).toHaveBeenCalledWith(startDate, 'yyyy-MM-dd');
+        expect(mockDatePipe.transform).toHaveBeenCalledWith(endDate, 'yyyy-MM-dd');
+        expect(emitSpy).toHaveBeenCalledWith({
+          createdAt: [{ value: ['2024-01-01', '2024-01-31'], matchMode: 'between', operator: 'and' }],
+        });
+      });
+
+      it('should not treat arrays of non-Date values as date ranges', () => {
+        const emitSpy = jest.spyOn(component.filterChange, 'emit');
+
+        const event = {
+          filters: {
+            tags: [{ value: ['tag1', 'tag2'], matchMode: 'in', operator: 'and' }],
+          },
+        };
+
+        component.filterResults(event);
+
+        expect(emitSpy).toHaveBeenCalledWith({
+          tags: [{ value: ['tag1', 'tag2'], matchMode: 'in', operator: 'and' }],
+        });
+      });
+    });
+
+    describe('clearFilters', () => {
+      it('should call dt1.clear() and emit empty object via filterChange', () => {
+        const emitSpy = jest.spyOn(component.filterChange, 'emit');
+        const mockDt1 = { clear: jest.fn() };
+        (component as any).dt1 = mockDt1;
+
+        component.clearFilters();
+
+        expect(mockDt1.clear).toHaveBeenCalled();
+        expect(emitSpy).toHaveBeenCalledWith({});
+      });
+
+      it('should not emit or throw when dt1 is undefined', () => {
+        const emitSpy = jest.spyOn(component.filterChange, 'emit');
+        (component as any).dt1 = undefined;
+
+        expect(() => component.clearFilters()).not.toThrow();
+        expect(emitSpy).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('pagination', () => {
+    beforeEach(() => {
+      component.rows = [
+        { id: '1', name: 'Item 1' },
+        { id: '2', name: 'Item 2' },
+      ];
+      component.cols = [{ name: 'Name', field: 'name' }];
+    });
+
+    describe('onPage', () => {
+      it('should calculate page 0 when event.first is 0', () => {
+        const emitSpy = jest.spyOn(component.pageChange, 'emit');
+
+        component.onPage({ first: 0, rows: 10 } as any);
+
+        expect(emitSpy).toHaveBeenCalledWith({ page: 0, size: 10 });
+      });
+
+      it('should calculate page 1 when first equals rows (second page)', () => {
+        const emitSpy = jest.spyOn(component.pageChange, 'emit');
+
+        component.onPage({ first: 10, rows: 10 } as any);
+
+        expect(emitSpy).toHaveBeenCalledWith({ page: 1, size: 10 });
+      });
+
+      it('should calculate page 2 when first is twice the rows', () => {
+        const emitSpy = jest.spyOn(component.pageChange, 'emit');
+
+        component.onPage({ first: 50, rows: 25 } as any);
+
+        expect(emitSpy).toHaveBeenCalledWith({ page: 2, size: 25 });
+      });
+
+      it('should calculate page 3 when first is 75 and rows is 25', () => {
+        const emitSpy = jest.spyOn(component.pageChange, 'emit');
+
+        component.onPage({ first: 75, rows: 25 } as any);
+
+        expect(emitSpy).toHaveBeenCalledWith({ page: 3, size: 25 });
+      });
+
+      it('should pass the correct size from event.rows with page size 50', () => {
+        const emitSpy = jest.spyOn(component.pageChange, 'emit');
+
+        component.onPage({ first: 100, rows: 50 } as any);
+
+        expect(emitSpy).toHaveBeenCalledWith({ page: 2, size: 50 });
+      });
+
+      it('should handle page size of 100', () => {
+        const emitSpy = jest.spyOn(component.pageChange, 'emit');
+
+        component.onPage({ first: 300, rows: 100 } as any);
+
+        expect(emitSpy).toHaveBeenCalledWith({ page: 3, size: 100 });
+      });
+    });
+
+    describe('pageChange EventEmitter', () => {
+      it('should emit correct page and size values when subscribing to pageChange', () => {
+        const emittedValues: { page: number; size: number }[] = [];
+        component.pageChange.subscribe((value) => emittedValues.push(value));
+
+        component.onPage({ first: 0, rows: 25 } as any);
+        component.onPage({ first: 25, rows: 25 } as any);
+        component.onPage({ first: 50, rows: 25 } as any);
+
+        expect(emittedValues).toEqual([
+          { page: 0, size: 25 },
+          { page: 1, size: 25 },
+          { page: 2, size: 25 },
+        ]);
+      });
+
+      it('should emit updated size when page size changes', () => {
+        const emittedValues: { page: number; size: number }[] = [];
+        component.pageChange.subscribe((value) => emittedValues.push(value));
+
+        component.onPage({ first: 0, rows: 10 } as any);
+        component.onPage({ first: 0, rows: 50 } as any);
+
+        expect(emittedValues).toEqual([
+          { page: 0, size: 10 },
+          { page: 0, size: 50 },
+        ]);
+      });
+
+      it('should emit page 0 with size 500 for large page sizes', () => {
+        const emitSpy = jest.spyOn(component.pageChange, 'emit');
+
+        component.onPage({ first: 500, rows: 500 } as any);
+
+        expect(emitSpy).toHaveBeenCalledWith({ page: 1, size: 500 });
+      });
+    });
+  });
+
+  describe('sorting', () => {
+    beforeEach(() => {
+      component.rows = [
+        { id: '1', name: 'Banana', status: 'active' },
+        { id: '2', name: 'Apple', status: 'inactive' },
+      ];
+      component.cols = [
+        { name: 'Name', field: 'name' },
+        { name: 'Status', field: 'status' },
+      ];
+      component.sortBy = '';
+      component.orderBy = '';
+    });
+
+    describe('customSort direction cycling', () => {
+      it('should set direction to asc on first call for a column', () => {
+        const emitSpy = jest.spyOn(component.sortHandler, 'emit');
+
+        component.customSort('name');
+
+        expect(component.sortBy).toBe('name');
+        expect(component.orderBy).toBe('asc');
+        expect(emitSpy).toHaveBeenCalledWith({ columnName: 'name', direction: 'asc' });
+      });
+
+      it('should set direction to desc on second call for the same column', () => {
+        component.customSort('name'); // first call -> asc
+
+        const emitSpy = jest.spyOn(component.sortHandler, 'emit');
+        component.customSort('name'); // second call -> desc
+
+        expect(component.sortBy).toBe('name');
+        expect(component.orderBy).toBe('desc');
+        expect(emitSpy).toHaveBeenCalledWith({ columnName: 'name', direction: 'desc' });
+      });
+
+      it('should clear direction on third call for the same column', () => {
+        component.customSort('name'); // first call -> asc
+        component.customSort('name'); // second call -> desc
+
+        const emitSpy = jest.spyOn(component.sortHandler, 'emit');
+        component.customSort('name'); // third call -> clear
+
+        expect(component.sortBy).toBe('name');
+        expect(component.orderBy).toBe('');
+        expect(emitSpy).toHaveBeenCalledWith({ columnName: 'name', direction: '' });
+      });
+
+      it('should cycle back to asc after clearing', () => {
+        component.customSort('name'); // asc
+        component.customSort('name'); // desc
+        component.customSort('name'); // clear
+
+        const emitSpy = jest.spyOn(component.sortHandler, 'emit');
+        component.customSort('name'); // back to asc
+
+        expect(component.sortBy).toBe('name');
+        expect(component.orderBy).toBe('asc');
+        expect(emitSpy).toHaveBeenCalledWith({ columnName: 'name', direction: 'asc' });
+      });
+    });
+
+    describe('sortHandler emission', () => {
+      it('should emit sortHandler with columnName and direction', () => {
+        const emitSpy = jest.spyOn(component.sortHandler, 'emit');
+
+        component.customSort('status');
+
+        expect(emitSpy).toHaveBeenCalledTimes(1);
+        expect(emitSpy).toHaveBeenCalledWith({ columnName: 'status', direction: 'asc' });
+      });
+
+      it('should emit on every call to customSort', () => {
+        const emittedValues: any[] = [];
+        component.sortHandler.subscribe((value: any) => emittedValues.push(value));
+
+        component.customSort('name');
+        component.customSort('name');
+        component.customSort('name');
+
+        expect(emittedValues).toEqual([
+          { columnName: 'name', direction: 'asc' },
+          { columnName: 'name', direction: 'desc' },
+          { columnName: 'name', direction: '' },
+        ]);
+      });
+    });
+
+    describe('sorting different columns', () => {
+      it('should reset direction to asc when switching to a different column', () => {
+        component.customSort('name'); // name -> asc
+        component.customSort('name'); // name -> desc
+
+        const emitSpy = jest.spyOn(component.sortHandler, 'emit');
+        component.customSort('status'); // switch to status -> asc
+
+        expect(component.sortBy).toBe('status');
+        expect(component.orderBy).toBe('asc');
+        expect(emitSpy).toHaveBeenCalledWith({ columnName: 'status', direction: 'asc' });
+      });
+
+      it('should start fresh cycling on the new column after switching', () => {
+        component.customSort('name'); // name -> asc
+        component.customSort('status'); // status -> asc (new column)
+
+        const emitSpy = jest.spyOn(component.sortHandler, 'emit');
+        component.customSort('status'); // status -> desc
+
+        expect(component.sortBy).toBe('status');
+        expect(component.orderBy).toBe('desc');
+        expect(emitSpy).toHaveBeenCalledWith({ columnName: 'status', direction: 'desc' });
+      });
+
+      it('should reset to asc when switching columns even after clearing', () => {
+        component.customSort('name'); // name -> asc
+        component.customSort('name'); // name -> desc
+        component.customSort('name'); // name -> clear
+
+        const emitSpy = jest.spyOn(component.sortHandler, 'emit');
+        component.customSort('status'); // switch to status -> asc
+
+        expect(component.sortBy).toBe('status');
+        expect(component.orderBy).toBe('asc');
+        expect(emitSpy).toHaveBeenCalledWith({ columnName: 'status', direction: 'asc' });
+      });
+    });
+  });
+
+  describe('row reorder', () => {
+    const mockRows: Row[] = [
+      { id: '1', name: 'Item 1' },
+      { id: '2', name: 'Item 2' },
+      { id: '3', name: 'Item 3' },
+      { id: '4', name: 'Item 4' },
+    ];
+
+    beforeEach(() => {
+      component.rows = mockRows;
+      component.cols = [{ name: 'Name', field: 'name' }];
+    });
+
+    describe('onRowReorder', () => {
+      it('should emit rowReordered with previousIndex and currentIndex from the event', () => {
+        const emitSpy = jest.spyOn(component.rowReordered, 'emit');
+
+        component.onRowReorder({ dragIndex: 0, dropIndex: 2 } as any);
+
+        expect(emitSpy).toHaveBeenCalledWith({ previousIndex: 0, currentIndex: 2 });
+      });
+
+      it('should emit rowReordered when moving a row down', () => {
+        const emitSpy = jest.spyOn(component.rowReordered, 'emit');
+
+        component.onRowReorder({ dragIndex: 1, dropIndex: 3 } as any);
+
+        expect(emitSpy).toHaveBeenCalledWith({ previousIndex: 1, currentIndex: 3 });
+      });
+
+      it('should emit rowReordered when moving a row up', () => {
+        const emitSpy = jest.spyOn(component.rowReordered, 'emit');
+
+        component.onRowReorder({ dragIndex: 3, dropIndex: 0 } as any);
+
+        expect(emitSpy).toHaveBeenCalledWith({ previousIndex: 3, currentIndex: 0 });
+      });
+
+      it('should emit rowReordered when drag and drop indices are the same', () => {
+        const emitSpy = jest.spyOn(component.rowReordered, 'emit');
+
+        component.onRowReorder({ dragIndex: 2, dropIndex: 2 } as any);
+
+        expect(emitSpy).toHaveBeenCalledWith({ previousIndex: 2, currentIndex: 2 });
+      });
+
+      it('should emit rowReordered when moving from first to last position', () => {
+        const emitSpy = jest.spyOn(component.rowReordered, 'emit');
+
+        component.onRowReorder({ dragIndex: 0, dropIndex: 3 } as any);
+
+        expect(emitSpy).toHaveBeenCalledWith({ previousIndex: 0, currentIndex: 3 });
+      });
+
+      it('should emit rowReordered when moving from last to first position', () => {
+        const emitSpy = jest.spyOn(component.rowReordered, 'emit');
+
+        component.onRowReorder({ dragIndex: 3, dropIndex: 0 } as any);
+
+        expect(emitSpy).toHaveBeenCalledWith({ previousIndex: 3, currentIndex: 0 });
+      });
+    });
+
+    describe('rowReordered EventEmitter', () => {
+      it('should emit correct payload when subscribing to rowReordered output', () => {
+        const emittedValues: { previousIndex: number; currentIndex: number }[] = [];
+        component.rowReordered.subscribe((value) => emittedValues.push(value));
+
+        component.onRowReorder({ dragIndex: 0, dropIndex: 2 } as any);
+        component.onRowReorder({ dragIndex: 3, dropIndex: 1 } as any);
+
+        expect(emittedValues).toEqual([
+          { previousIndex: 0, currentIndex: 2 },
+          { previousIndex: 3, currentIndex: 1 },
+        ]);
+      });
+
+      it('should emit once per onRowReorder call', () => {
+        const emitSpy = jest.spyOn(component.rowReordered, 'emit');
+
+        component.onRowReorder({ dragIndex: 1, dropIndex: 2 } as any);
+
+        expect(emitSpy).toHaveBeenCalledTimes(1);
+      });
+    });
+  });
+
+  describe('delete/action confirmations', () => {
+    const mockRowData: Row = { id: '1', name: 'Item 1', status: 'active' };
+
+    beforeEach(() => {
+      component.rows = [mockRowData];
+      component.cols = [{ name: 'Name', field: 'name' }];
+    });
+
+    describe('deleteRowConfirmation', () => {
+      it('should call ConfirmationService.confirm with correct message', () => {
+        component.deleteRowConfirmation(mockRowData);
+
+        expect(mockConfirmationService.confirm).toHaveBeenCalledTimes(1);
+        expect(mockConfirmationService.confirm).toHaveBeenCalledWith(
+          expect.objectContaining({ message: 'Delete this item?' })
+        );
+      });
+
+      it('should emit deleteRow when the confirmation is accepted', () => {
+        const emitSpy = jest.spyOn(component.deleteRow, 'emit');
+
+        mockConfirmationService.confirm.mockImplementation((config: any) => {
+          config.accept();
+        });
+
+        component.deleteRowConfirmation(mockRowData);
+
+        expect(emitSpy).toHaveBeenCalledWith(mockRowData);
+      });
+
+      it('should not emit deleteRow if accept is not called', () => {
+        const emitSpy = jest.spyOn(component.deleteRow, 'emit');
+
+        mockConfirmationService.confirm.mockImplementation(() => {
+          // Simulate user dismissing the dialog without accepting
+        });
+
+        component.deleteRowConfirmation(mockRowData);
+
+        expect(emitSpy).not.toHaveBeenCalled();
+      });
+
+      it('should pass the rowData to deleteRow emit on acceptance', () => {
+        const emitSpy = jest.spyOn(component.deleteRow, 'emit');
+        const specificRow: Row = { id: '99', name: 'Special Item', price: 42 };
+
+        mockConfirmationService.confirm.mockImplementation((config: any) => {
+          config.accept();
+        });
+
+        component.deleteRowConfirmation(specificRow);
+
+        expect(emitSpy).toHaveBeenCalledWith(specificRow);
+      });
+    });
+
+    describe('actionRowConfirmation with confirmation flag', () => {
+      beforeEach(() => {
+        component.actionButtonConfig = {
+          enabled: true,
+          icon: 'pi pi-check',
+          message: 'Are you sure you want to perform this action?',
+          confirmation: true,
+          class: 'p-button-rounded p-button-help',
+        };
+      });
+
+      it('should call ConfirmationService.confirm when confirmation is true', () => {
+        component.actionRowConfirmation(mockRowData);
+
+        expect(mockConfirmationService.confirm).toHaveBeenCalledTimes(1);
+        expect(mockConfirmationService.confirm).toHaveBeenCalledWith(
+          expect.objectContaining({
+            message: 'Are you sure you want to perform this action?',
+          })
+        );
+      });
+
+      it('should emit actionButton when the confirmation is accepted', () => {
+        const emitSpy = jest.spyOn(component.actionButton, 'emit');
+
+        mockConfirmationService.confirm.mockImplementation((config: any) => {
+          config.accept();
+        });
+
+        component.actionRowConfirmation(mockRowData);
+
+        expect(emitSpy).toHaveBeenCalledWith(mockRowData);
+      });
+
+      it('should not emit actionButton if accept is not called', () => {
+        const emitSpy = jest.spyOn(component.actionButton, 'emit');
+
+        mockConfirmationService.confirm.mockImplementation(() => {
+          // User dismisses without accepting
+        });
+
+        component.actionRowConfirmation(mockRowData);
+
+        expect(emitSpy).not.toHaveBeenCalled();
+      });
+
+      it('should use the actionButtonConfig.message in the confirmation dialog', () => {
+        component.actionButtonConfig.message = 'Custom confirmation message';
+
+        component.actionRowConfirmation(mockRowData);
+
+        expect(mockConfirmationService.confirm).toHaveBeenCalledWith(
+          expect.objectContaining({ message: 'Custom confirmation message' })
+        );
+      });
+    });
+
+    describe('actionRowConfirmation without confirmation flag', () => {
+      beforeEach(() => {
+        component.actionButtonConfig = {
+          enabled: true,
+          icon: 'pi pi-check',
+          message: '',
+          confirmation: false,
+          class: 'p-button-rounded p-button-help',
+        };
+      });
+
+      it('should emit actionButton directly without calling ConfirmationService', () => {
+        const emitSpy = jest.spyOn(component.actionButton, 'emit');
+
+        component.actionRowConfirmation(mockRowData);
+
+        expect(mockConfirmationService.confirm).not.toHaveBeenCalled();
+        expect(emitSpy).toHaveBeenCalledWith(mockRowData);
+      });
+
+      it('should emit the correct rowData directly', () => {
+        const emitSpy = jest.spyOn(component.actionButton, 'emit');
+        const specificRow: Row = { id: '5', name: 'Direct Action Item' };
+
+        component.actionRowConfirmation(specificRow);
+
+        expect(emitSpy).toHaveBeenCalledWith(specificRow);
+      });
+
+      it('should not show confirmation dialog when confirmation is false', () => {
+        component.actionRowConfirmation(mockRowData);
+
+        expect(mockConfirmationService.confirm).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('helper methods', () => {
+    describe('getRowDataValue', () => {
+      it('should return value for a simple field path', () => {
+        const rowData = { name: 'Test Item', status: 'active' };
+
+        const result = component.getRowDataValue(rowData, 'name', 'string');
+
+        expect(result).toBe('Test Item');
+      });
+
+      it('should return value for a nested field path', () => {
+        const rowData = { address: { city: 'Dallas', state: 'TX' } };
+
+        const result = component.getRowDataValue(rowData, 'address.city', 'string');
+
+        expect(result).toBe('Dallas');
+      });
+
+      it('should return value for a deeply nested field path', () => {
+        const rowData = { user: { profile: { email: 'test@example.com' } } };
+
+        const result = component.getRowDataValue(rowData, 'user.profile.email', 'string');
+
+        expect(result).toBe('test@example.com');
+      });
+
+      it('should return undefined for a non-existent nested path', () => {
+        const rowData = { name: 'Test' };
+
+        const result = component.getRowDataValue(rowData, 'address.city', 'string');
+
+        expect(result).toBeUndefined();
+      });
+
+      it('should format value using DatePipe when type is date', () => {
+        const rowData = { createdAt: '2024-01-15T00:00:00Z' };
+        mockDatePipe.transform.mockReturnValue('01/15/2024');
+
+        const result = component.getRowDataValue(rowData, 'createdAt', 'date');
+
+        expect(mockDatePipe.transform).toHaveBeenCalledWith('2024-01-15T00:00:00Z', 'MM/dd/yyyy');
+        expect(result).toBe('01/15/2024');
+      });
+
+      it('should not call DatePipe when type is not date', () => {
+        const rowData = { name: 'Test' };
+
+        component.getRowDataValue(rowData, 'name', 'string');
+
+        expect(mockDatePipe.transform).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('copyHandler', () => {
+      let mockEvent: { stopPropagation: jest.Mock };
+      let mockWriteText: jest.Mock;
+
+      beforeEach(() => {
+        mockEvent = { stopPropagation: jest.fn() };
+        mockWriteText = jest.fn().mockResolvedValue(undefined);
+        Object.assign(navigator, {
+          clipboard: { writeText: mockWriteText },
+        });
+        // Mock the snackbar component
+        (component as any).atomixSnackbarComponent = { showSnackbar: jest.fn() };
+      });
+
+      it('should stop event propagation', () => {
+        component.copyHandler(mockEvent as any, 'test-value');
+
+        expect(mockEvent.stopPropagation).toHaveBeenCalled();
+      });
+
+      it('should call navigator.clipboard.writeText with the element value', () => {
+        component.copyHandler(mockEvent as any, 'SKU-12345');
+
+        expect(mockWriteText).toHaveBeenCalledWith('SKU-12345');
+      });
+
+      it('should show snackbar with copied message', () => {
+        component.copyHandler(mockEvent as any, 'order-789');
+
+        expect((component as any).atomixSnackbarComponent.showSnackbar).toHaveBeenCalledWith(
+          'Copied order-789 to clipboard'
+        );
+      });
+    });
+
+    describe('shouldShowAction', () => {
+      it('should return true when action is null', () => {
+        expect(component.shouldShowAction(null, {})).toBe(true);
+      });
+
+      it('should return true when action has no showOnlyWhen property', () => {
+        const action = { icon: 'pi pi-pencil', tooltip: 'Edit' };
+        const rowData = { status: 'active' };
+
+        expect(component.shouldShowAction(action, rowData)).toBe(true);
+      });
+
+      it('should return true when row data matches showOnlyWhen condition', () => {
+        const action = { showOnlyWhen: { status: 'active' } };
+        const rowData = { status: 'active', name: 'Item 1' };
+
+        expect(component.shouldShowAction(action, rowData)).toBe(true);
+      });
+
+      it('should return false when row data does not match showOnlyWhen condition', () => {
+        const action = { showOnlyWhen: { status: 'active' } };
+        const rowData = { status: 'inactive', name: 'Item 1' };
+
+        expect(component.shouldShowAction(action, rowData)).toBe(false);
+      });
+
+      it('should match case-insensitively', () => {
+        const action = { showOnlyWhen: { status: 'Active' } };
+        const rowData = { status: 'active' };
+
+        expect(component.shouldShowAction(action, rowData)).toBe(true);
+      });
+
+      it('should return false when row data key is missing', () => {
+        const action = { showOnlyWhen: { status: 'active' } };
+        const rowData = { name: 'Item 1' };
+
+        expect(component.shouldShowAction(action, rowData)).toBe(false);
+      });
+
+      it('should require all showOnlyWhen conditions to match', () => {
+        const action = { showOnlyWhen: { status: 'active', type: 'order' } };
+        const rowData = { status: 'active', type: 'return' };
+
+        expect(component.shouldShowAction(action, rowData)).toBe(false);
+      });
+
+      it('should return true when all multiple conditions match', () => {
+        const action = { showOnlyWhen: { status: 'active', type: 'order' } };
+        const rowData = { status: 'active', type: 'order', name: 'Item' };
+
+        expect(component.shouldShowAction(action, rowData)).toBe(true);
+      });
+    });
+
+    describe('hasChildRows', () => {
+      it('should return false when secondaryRowsKey is not set', () => {
+        component.secondaryRowsKey = '';
+        const rowData = { items: [{ id: 1 }] };
+
+        expect(component.hasChildRows(rowData)).toBe(false);
+      });
+
+      it('should return true when row has child rows array with items', () => {
+        component.secondaryRowsKey = 'items';
+        const rowData = { items: [{ id: 1 }, { id: 2 }] };
+
+        expect(component.hasChildRows(rowData)).toBe(true);
+      });
+
+      it('should return false when row has empty child rows array', () => {
+        component.secondaryRowsKey = 'items';
+        const rowData = { items: [] };
+
+        expect(component.hasChildRows(rowData)).toBe(false);
+      });
+
+      it('should return false when row does not have the secondaryRowsKey property', () => {
+        component.secondaryRowsKey = 'items';
+        const rowData = { name: 'Test' };
+
+        expect(component.hasChildRows(rowData)).toBe(false);
+      });
+
+      it('should return false when child rows value is not an array', () => {
+        component.secondaryRowsKey = 'items';
+        const rowData = { items: 'not-an-array' };
+
+        expect(component.hasChildRows(rowData)).toBe(false);
+      });
+    });
+
+    describe('shouldShowActionButton', () => {
+      it('should return true when no special conditions apply', () => {
+        component.hideMainRowActionsWhenExpanded = false;
+        component.secondaryRowsKey = '';
+        const action = {};
+        const rowData = { name: 'Test' };
+
+        expect(component.shouldShowActionButton(action, rowData)).toBe(true);
+      });
+
+      it('should return false when hideMainRowActionsWhenExpanded is true and row has child rows', () => {
+        component.hideMainRowActionsWhenExpanded = true;
+        component.secondaryRowsKey = 'items';
+        const action = {};
+        const rowData = { items: [{ id: 1 }] };
+
+        expect(component.shouldShowActionButton(action, rowData)).toBe(false);
+      });
+
+      it('should return true when hideMainRowActionsWhenExpanded is true but row has no child rows', () => {
+        component.hideMainRowActionsWhenExpanded = true;
+        component.secondaryRowsKey = 'items';
+        const action = {};
+        const rowData = { items: [] };
+
+        expect(component.shouldShowActionButton(action, rowData)).toBe(true);
+      });
+
+      it('should return false when action.showOnlyWhenNoChildRows is true and row has child rows', () => {
+        component.hideMainRowActionsWhenExpanded = false;
+        component.secondaryRowsKey = 'items';
+        const action = { showOnlyWhenNoChildRows: true };
+        const rowData = { items: [{ id: 1 }] };
+
+        expect(component.shouldShowActionButton(action, rowData)).toBe(false);
+      });
+
+      it('should return true when action.showOnlyWhenNoChildRows is true but row has no child rows', () => {
+        component.hideMainRowActionsWhenExpanded = false;
+        component.secondaryRowsKey = 'items';
+        const action = { showOnlyWhenNoChildRows: true };
+        const rowData = { items: [] };
+
+        expect(component.shouldShowActionButton(action, rowData)).toBe(true);
+      });
+
+      it('should return true when action.showOnlyWhenNoChildRows is false even if row has child rows', () => {
+        component.hideMainRowActionsWhenExpanded = false;
+        component.secondaryRowsKey = 'items';
+        const action = { showOnlyWhenNoChildRows: false };
+        const rowData = { items: [{ id: 1 }] };
+
+        expect(component.shouldShowActionButton(action, rowData)).toBe(true);
+      });
+    });
+  });
+
+  describe('checkbox functionality', () => {
+    const mockRows: Row[] = [
+      { id: '1', name: 'Item 1', isSelected: false },
+      { id: '2', name: 'Item 2', isSelected: false },
+      { id: '3', name: 'Item 3', isSelected: false },
+    ];
+
+    beforeEach(() => {
+      component.rows = mockRows.map((row) => ({ ...row }));
+      component.cols = [{ name: 'Name', field: 'name' }];
+      component.isAllSelected = false;
+    });
+
+    describe('isAnyRowSelected', () => {
+      it('should return false and set isAllSelected to false when no rows are selected', () => {
+        component.rows = [
+          { id: '1', name: 'Item 1', isSelected: false },
+          { id: '2', name: 'Item 2', isSelected: false },
+        ];
+
+        const result = component.isAnyRowSelected();
+
+        expect(result).toBe(false);
+        expect(component.isAllSelected).toBe(false);
+      });
+
+      it('should return true and set isAllSelected to true when some rows are selected', () => {
+        component.rows = [
+          { id: '1', name: 'Item 1', isSelected: true },
+          { id: '2', name: 'Item 2', isSelected: false },
+          { id: '3', name: 'Item 3', isSelected: false },
+        ];
+
+        const result = component.isAnyRowSelected();
+
+        expect(result).toBe(true);
+        expect(component.isAllSelected).toBe(true);
+      });
+
+      it('should return false and set isAllSelected to true when ALL rows are selected', () => {
+        component.rows = [
+          { id: '1', name: 'Item 1', isSelected: true },
+          { id: '2', name: 'Item 2', isSelected: true },
+          { id: '3', name: 'Item 3', isSelected: true },
+        ];
+
+        const result = component.isAnyRowSelected();
+
+        expect(result).toBe(false);
+        expect(component.isAllSelected).toBe(true);
+      });
+
+      it('should return false when rows is empty (every returns true for empty array)', () => {
+        component.rows = [];
+
+        const result = component.isAnyRowSelected();
+
+        // Array.every() returns true for empty arrays (vacuous truth),
+        // so isAllSelected is set to true and the method returns false
+        expect(result).toBe(false);
+        expect(component.isAllSelected).toBe(true);
+      });
+    });
+
+    describe('toggleAllRows', () => {
+      it('should set all rows isSelected to true when isAllSelected is true', () => {
+        component.isAllSelected = true;
+
+        component.toggleAllRows({ checked: true } as any);
+
+        component.rows.forEach((row) => {
+          expect(row.isSelected).toBe(true);
+        });
+      });
+
+      it('should set all rows isSelected to false when isAllSelected is false', () => {
+        component.rows = [
+          { id: '1', name: 'Item 1', isSelected: true },
+          { id: '2', name: 'Item 2', isSelected: true },
+        ];
+        component.isAllSelected = false;
+
+        component.toggleAllRows({ checked: false } as any);
+
+        component.rows.forEach((row) => {
+          expect(row.isSelected).toBe(false);
+        });
+      });
+
+      it('should emit headerCheckboxHandler with isAllSelected value', () => {
+        const emitSpy = jest.spyOn(component.headerCheckboxHandler, 'emit');
+        component.isAllSelected = true;
+
+        component.toggleAllRows({ checked: true } as any);
+
+        expect(emitSpy).toHaveBeenCalledWith(true);
+      });
+
+      it('should emit headerCheckboxHandler with false when deselecting all', () => {
+        const emitSpy = jest.spyOn(component.headerCheckboxHandler, 'emit');
+        component.isAllSelected = false;
+
+        component.toggleAllRows({ checked: false } as any);
+
+        expect(emitSpy).toHaveBeenCalledWith(false);
+      });
+
+      it('should emit checkboxHandler when toggling all rows', () => {
+        const emitSpy = jest.spyOn(component.checkboxHandler, 'emit');
+        component.isAllSelected = true;
+
+        component.toggleAllRows({ checked: true } as any);
+
+        expect(emitSpy).toHaveBeenCalled();
+      });
+    });
+
+    describe('singleCheckboxHandler', () => {
+      it('should set isAllSelected to true', () => {
+        component.isAllSelected = false;
+        const row = { id: '1', name: 'Item 1', isSelected: true };
+
+        component.singleCheckboxHandler({ checked: true } as any, row);
+
+        expect(component.isAllSelected).toBe(true);
+      });
+
+      it('should emit headerCheckboxHandler with false', () => {
+        const emitSpy = jest.spyOn(component.headerCheckboxHandler, 'emit');
+        const row = { id: '1', name: 'Item 1', isSelected: true };
+
+        component.singleCheckboxHandler({ checked: true } as any, row);
+
+        expect(emitSpy).toHaveBeenCalledWith(false);
+      });
+
+      it('should emit checkboxHandler', () => {
+        const emitSpy = jest.spyOn(component.checkboxHandler, 'emit');
+        const row = { id: '1', name: 'Item 1', isSelected: true };
+
+        component.singleCheckboxHandler({ checked: true } as any, row);
+
+        expect(emitSpy).toHaveBeenCalled();
+      });
+
+      it('should emit headerCheckboxHandler with false regardless of row state', () => {
+        const emitSpy = jest.spyOn(component.headerCheckboxHandler, 'emit');
+        const row = { id: '2', name: 'Item 2', isSelected: false };
+
+        component.singleCheckboxHandler({ checked: false } as any, row);
+
+        expect(emitSpy).toHaveBeenCalledWith(false);
+      });
+    });
+
+    describe('headerCheckboxHandler EventEmitter', () => {
+      it('should emit boolean values when subscribing to headerCheckboxHandler', () => {
+        const emittedValues: boolean[] = [];
+        component.headerCheckboxHandler.subscribe((value) => emittedValues.push(value));
+
+        component.isAllSelected = true;
+        component.toggleAllRows({ checked: true } as any);
+
+        component.isAllSelected = false;
+        component.toggleAllRows({ checked: false } as any);
+
+        expect(emittedValues).toEqual([true, false]);
+      });
+
+      it('should emit false from singleCheckboxHandler calls', () => {
+        const emittedValues: boolean[] = [];
+        component.headerCheckboxHandler.subscribe((value) => emittedValues.push(value));
+
+        const row1 = { id: '1', name: 'Item 1', isSelected: true };
+        const row2 = { id: '2', name: 'Item 2', isSelected: true };
+
+        component.singleCheckboxHandler({ checked: true } as any, row1);
+        component.singleCheckboxHandler({ checked: true } as any, row2);
+
+        expect(emittedValues).toEqual([false, false]);
+      });
+    });
+  });
+
+  describe('dropdown and child row actions', () => {
+    beforeEach(() => {
+      component.rows = [
+        { id: '1', name: 'Item 1', status: 'active' },
+        { id: '2', name: 'Item 2', status: 'inactive' },
+      ];
+      component.cols = [{ name: 'Name', field: 'name' }];
+    });
+
+    describe('dropdownHandler', () => {
+      it('should emit pageDropdownChange with the event value', () => {
+        const emitSpy = jest.spyOn(component.pageDropdownChange, 'emit');
+
+        component.dropdownHandler({ value: 50 });
+
+        expect(emitSpy).toHaveBeenCalledWith(50);
+      });
+
+      it('should emit pageDropdownChange with undefined when event has no value', () => {
+        const emitSpy = jest.spyOn(component.pageDropdownChange, 'emit');
+
+        component.dropdownHandler({});
+
+        expect(emitSpy).toHaveBeenCalledWith(undefined);
+      });
+
+      it('should emit pageDropdownChange with undefined when event is null', () => {
+        const emitSpy = jest.spyOn(component.pageDropdownChange, 'emit');
+
+        component.dropdownHandler(null);
+
+        expect(emitSpy).toHaveBeenCalledWith(undefined);
+      });
+
+      it('should emit the correct value for different page sizes', () => {
+        const emittedValues: any[] = [];
+        component.pageDropdownChange.subscribe((value) => emittedValues.push(value));
+
+        component.dropdownHandler({ value: 10 });
+        component.dropdownHandler({ value: 25 });
+        component.dropdownHandler({ value: 100 });
+
+        expect(emittedValues).toEqual([10, 25, 100]);
+      });
+    });
+
+    describe('handleActionClick', () => {
+      it('should call the action click handler with the row data', () => {
+        const mockClick = jest.fn();
+        const action = { click: mockClick, icon: 'pi pi-pencil' };
+        const rowData = { id: '1', name: 'Item 1' };
+
+        component.handleActionClick(action, rowData);
+
+        expect(mockClick).toHaveBeenCalledWith(rowData);
+      });
+
+      it('should not throw when action has no click handler', () => {
+        const action = { icon: 'pi pi-pencil' };
+        const rowData = { id: '1', name: 'Item 1' };
+
+        expect(() => component.handleActionClick(action, rowData)).not.toThrow();
+      });
+
+      it('should pass the correct row data to the click handler', () => {
+        const mockClick = jest.fn();
+        const action = { click: mockClick };
+        const rowData = { id: '99', name: 'Special', status: 'pending', amount: 42.5 };
+
+        component.handleActionClick(action, rowData);
+
+        expect(mockClick).toHaveBeenCalledWith(rowData);
+      });
+
+      it('should not call click when action.click is undefined', () => {
+        const action = { click: undefined, icon: 'pi pi-trash' };
+        const rowData = { id: '1', name: 'Item 1' };
+
+        expect(() => component.handleActionClick(action, rowData)).not.toThrow();
+      });
+    });
+
+    describe('handleChildActionClick', () => {
+      it('should call the action click handler when action has a click function', () => {
+        const mockClick = jest.fn();
+        const action = { click: mockClick, icon: 'pi pi-eye' };
+        const rowData = { id: 'child-1', name: 'Child Item' };
+
+        component.handleChildActionClick(action, rowData);
+
+        expect(mockClick).toHaveBeenCalledWith(rowData);
+      });
+
+      it('should not emit childRowAction when action has a click handler', () => {
+        const emitSpy = jest.spyOn(component.childRowAction, 'emit');
+        const mockClick = jest.fn();
+        const action = { click: mockClick };
+        const rowData = { id: 'child-1', name: 'Child Item' };
+
+        component.handleChildActionClick(action, rowData);
+
+        expect(emitSpy).not.toHaveBeenCalled();
+      });
+
+      it('should emit childRowAction with action name when no click handler exists', () => {
+        const emitSpy = jest.spyOn(component.childRowAction, 'emit');
+        const action = { action: 'edit', icon: 'pi pi-pencil' };
+        const rowData = { id: 'child-1', name: 'Child Item' };
+
+        component.handleChildActionClick(action, rowData);
+
+        expect(emitSpy).toHaveBeenCalledWith({ action: 'edit', childRow: rowData });
+      });
+
+      it('should use tooltip as action name when action.action is not defined', () => {
+        const emitSpy = jest.spyOn(component.childRowAction, 'emit');
+        const action = { tooltip: 'Delete', icon: 'pi pi-trash' };
+        const rowData = { id: 'child-2', name: 'Child Item 2' };
+
+        component.handleChildActionClick(action, rowData);
+
+        expect(emitSpy).toHaveBeenCalledWith({ action: 'Delete', childRow: rowData });
+      });
+
+      it('should use the action object itself as action name when neither action nor tooltip exist', () => {
+        const emitSpy = jest.spyOn(component.childRowAction, 'emit');
+        const action = { icon: 'pi pi-check' };
+        const rowData = { id: 'child-3', name: 'Child Item 3' };
+
+        component.handleChildActionClick(action, rowData);
+
+        // actionName = action?.action || action?.tooltip || action
+        // Both action.action and action.tooltip are undefined, so it falls through to the action object itself
+        expect(emitSpy).toHaveBeenCalledWith({ action: { icon: 'pi pi-check' }, childRow: rowData });
+      });
+
+      it('should prefer action.action over action.tooltip for the action name', () => {
+        const emitSpy = jest.spyOn(component.childRowAction, 'emit');
+        const action = { action: 'view', tooltip: 'View Details', icon: 'pi pi-eye' };
+        const rowData = { id: 'child-4', name: 'Child Item 4' };
+
+        component.handleChildActionClick(action, rowData);
+
+        expect(emitSpy).toHaveBeenCalledWith({ action: 'view', childRow: rowData });
+      });
+    });
+
+    describe('handlePageChange', () => {
+      it('should emit pageChange with the event', () => {
+        const emitSpy = jest.fn();
+        component.pageChange.subscribe(emitSpy);
+
+        const event = { page: 2, rows: 10 };
+        component.handlePageChange(event);
+
+        expect(emitSpy).toHaveBeenCalledWith(event);
+      });
+    });
+
+    describe('isString', () => {
+      it('should return true for string values', () => {
+        expect(component.isString('hello')).toBe(true);
+        expect(component.isString('')).toBe(true);
+      });
+
+      it('should return false for non-string values', () => {
+        expect(component.isString(123)).toBe(false);
+        expect(component.isString(null)).toBe(false);
+        expect(component.isString(undefined)).toBe(false);
+        expect(component.isString({})).toBe(false);
+        expect(component.isString([])).toBe(false);
+      });
+    });
+
+    describe('handleDateRangeFilter', () => {
+      it('should call filterCallback when value is an array of 2 Date objects', () => {
+        const filterCallback = jest.fn();
+        const startDate = new Date(2024, 0, 1);
+        const endDate = new Date(2024, 0, 31);
+
+        component.handleDateRangeFilter([startDate, endDate], filterCallback);
+
+        expect(filterCallback).toHaveBeenCalledWith([startDate, endDate]);
+      });
+
+      it('should not call filterCallback when value is an array with only 1 Date', () => {
+        const filterCallback = jest.fn();
+        const startDate = new Date(2024, 0, 1);
+
+        component.handleDateRangeFilter([startDate], filterCallback);
+
+        expect(filterCallback).not.toHaveBeenCalled();
+      });
+
+      it('should not call filterCallback when value is an array with non-Date items', () => {
+        const filterCallback = jest.fn();
+
+        component.handleDateRangeFilter(['2024-01-01', '2024-01-31'], filterCallback);
+
+        expect(filterCallback).not.toHaveBeenCalled();
+      });
+
+      it('should call filterCallback with null when value is null (clear filter)', () => {
+        const filterCallback = jest.fn();
+
+        component.handleDateRangeFilter(null, filterCallback);
+
+        expect(filterCallback).toHaveBeenCalledWith(null);
+      });
+
+      it('should not call filterCallback when value is undefined', () => {
+        const filterCallback = jest.fn();
+
+        component.handleDateRangeFilter(undefined, filterCallback);
+
+        expect(filterCallback).not.toHaveBeenCalled();
+      });
+
+      it('should not call filterCallback when value is an empty array', () => {
+        const filterCallback = jest.fn();
+
+        component.handleDateRangeFilter([], filterCallback);
+
+        expect(filterCallback).not.toHaveBeenCalled();
+      });
+
+      it('should not call filterCallback when array has 2 items but one is not a Date', () => {
+        const filterCallback = jest.fn();
+        const startDate = new Date(2024, 0, 1);
+
+        component.handleDateRangeFilter([startDate, '2024-01-31'], filterCallback);
+
+        expect(filterCallback).not.toHaveBeenCalled();
+      });
+
+      it('should call filterCallback with the exact date array passed in', () => {
+        const filterCallback = jest.fn();
+        const startDate = new Date(2024, 5, 15);
+        const endDate = new Date(2024, 11, 31);
+        const dateArray = [startDate, endDate];
+
+        component.handleDateRangeFilter(dateArray, filterCallback);
+
+        expect(filterCallback).toHaveBeenCalledWith(dateArray);
+      });
+    });
+  });
+});