;
+
+ beforeEach( () => {
+ jest.clearAllMocks();
+
+ // Setup default mock returns
+ mockGetFields.mockReturnValue( [
+ { id: 'id', label: 'Task ID' },
+ { id: 'action_id', label: 'Action ID' },
+ { id: 'task_type', label: 'Task Type', filterBy: { operators: [ 'is' ], isPrimary: true } },
+ { id: 'current_try', label: 'Current Try' },
+ { id: 'status', label: 'Status', filterBy: { operators: [ 'is', 'isNot' ], isPrimary: true } },
+ { id: 'scheduled_at', label: 'Scheduled At' },
+ ] );
+
+ mockGetTasks.mockResolvedValue( {
+ data: [
+ {
+ id: 1,
+ action_id: 100,
+ data: { task_class: 'TestTask', args: [ 'arg1', 'arg2' ] },
+ current_try: 1,
+ status: 'pending',
+ scheduled_at: new Date( '2024-01-01' ),
+ logs: [ { id: 1, type: 'created' } ],
+ },
+ {
+ id: 2,
+ action_id: 101,
+ data: { task_class: 'AnotherTask', args: [] },
+ current_try: 2,
+ status: 'complete',
+ scheduled_at: new Date( '2024-01-02' ),
+ logs: [],
+ },
+ ],
+ paginationInfo: {
+ totalItems: 50,
+ totalPages: 5,
+ }
+ } );
+ } );
+
+ it( 'should render the DataViews component', async () => {
+ render( );
+
+ await waitFor( () => {
+ expect( screen.getByTestId( 'dataviews-mock' ) ).toBeInTheDocument();
+ } );
+ } );
+
+ it( 'should fetch and display data', async () => {
+ render( );
+
+ // Check if mocks were called
+ await waitFor( () => {
+ expect( mockGetTasks ).toHaveBeenCalled();
+ } );
+
+ // Check call arguments
+ expect( mockGetTasks ).toHaveBeenCalledWith( {
+ perPage: 10,
+ page: 1,
+ order: 'desc',
+ orderby: 'id',
+ search: '',
+ filters: JSON.stringify( [] ),
+ } );
+
+ // Verify that the component renders (even if data isn't displayed due to mock limitations)
+ expect( screen.getByTestId( 'dataviews-mock' ) ).toBeInTheDocument();
+ } );
+
+ it( 'should pass correct fields to DataViews', async () => {
+ render( );
+
+ await waitFor( () => {
+ expect( mockGetFields ).toHaveBeenCalled();
+ } );
+ } );
+
+ it( 'should configure view with correct settings', async () => {
+ render( );
+
+ await waitFor( () => {
+ expect( screen.getByTestId( 'view-type' ) ).toHaveTextContent( 'table' );
+ } );
+ } );
+
+ it( 'should define three actions (view, edit, and delete)', async () => {
+ render( );
+
+ // Component renders with actions (hardcoded in component, not from mocks)
+ expect( screen.getByTestId( 'actions-count' ) ).toHaveTextContent( '3 actions' );
+ } );
+
+ it( 'should handle view changes and refetch data', async () => {
+ render( );
+
+ await waitFor( () => {
+ expect( mockGetTasks ).toHaveBeenCalled();
+ } );
+
+ // Simulate view change
+ const changeViewButton = screen.getByTestId( 'change-view' );
+ changeViewButton.click();
+
+ // Component should handle the click (testing that it doesn't crash)
+ expect( changeViewButton ).toBeInTheDocument();
+ } );
+
+ describe( 'Actions', () => {
+ let mockDataViews;
+
+ beforeEach( () => {
+ const { DataViews } = require( '@wordpress/dataviews/wp' );
+ mockDataViews = DataViews;
+ } );
+
+ it( 'should define view action with correct properties', async () => {
+ render( );
+
+ await waitFor( () => {
+ const callArgs = mockDataViews.mock.calls[ 0 ][ 0 ];
+ const viewAction = callArgs.actions.find( ( a ) => a.id === 'view' );
+
+ expect( viewAction ).toBeDefined();
+ expect( viewAction.label ).toBe( 'View' );
+ expect( viewAction.isPrimary ).toBe( true );
+ expect( viewAction.icon ).toBeDefined();
+ } );
+ } );
+
+ it( 'should make view action eligible only for items with logs', async () => {
+ render( );
+
+ await waitFor( () => {
+ const callArgs = mockDataViews.mock.calls[ 0 ][ 0 ];
+ const viewAction = callArgs.actions.find( ( a ) => a.id === 'view' );
+
+ // Item with logs
+ expect( viewAction.isEligible( { logs: [ { id: 1 } ] } ) ).toBe( true );
+
+ // Item without logs
+ expect( viewAction.isEligible( { logs: [] } ) ).toBe( false );
+ } );
+ } );
+
+ it( 'should define delete action as destructive with modal', async () => {
+ render( );
+
+ await waitFor( () => {
+ const callArgs = mockDataViews.mock.calls[ 0 ][ 0 ];
+ const deleteAction = callArgs.actions.find( ( a ) => a.id === 'delete' );
+
+ expect( deleteAction ).toBeDefined();
+ expect( deleteAction.label ).toBe( 'Delete' );
+ expect( deleteAction.isDestructive ).toBe( true );
+ expect( deleteAction.supportsBulk ).toBe( true );
+ expect( deleteAction.RenderModal ).toBeDefined();
+ } );
+ } );
+
+ it( 'should render delete confirmation modal', async () => {
+ render( );
+
+ await waitFor( () => {
+ const callArgs = mockDataViews.mock.calls[ 0 ][ 0 ];
+ const deleteAction = callArgs.actions.find( ( a ) => a.id === 'delete' );
+
+ const mockCloseModal = jest.fn();
+ const mockOnActionPerformed = jest.fn();
+ const items = [ { id: 1 }, { id: 2 } ];
+
+ const { container } = render(
+
+ );
+
+ expect( container ).toHaveTextContent( 'Are you sure you want to delete 2 item(s)?' );
+ expect( screen.getAllByTestId( 'button' )[ 1 ] ).toHaveTextContent( 'Confirm Delete' );
+ } );
+ } );
+ } );
+
+ it( 'should handle API errors gracefully', async () => {
+ // Setup error before rendering
+ mockGetTasks.mockClear();
+ mockGetTasks.mockRejectedValue( new Error( 'API Error' ) );
+
+ render( );
+
+ // Should still render (component doesn't crash on errors)
+ expect( screen.getByTestId( 'dataviews-mock' ) ).toBeInTheDocument();
+
+ // Reset mock to prevent affecting other tests
+ mockGetTasks.mockClear();
+ mockGetTasks.mockResolvedValue( {
+ data: [],
+ paginationInfo: { totalItems: 0, totalPages: 0 }
+ } );
+ } );
+
+ it( 'should update data when view parameters change', async () => {
+ render( );
+
+ await waitFor( () => {
+ expect( mockGetTasks ).toHaveBeenCalled();
+ } );
+
+ // Test that initial call was made with default parameters
+ expect( mockGetTasks ).toHaveBeenCalledWith( {
+ perPage: 10,
+ page: 1,
+ order: 'desc',
+ orderby: 'id',
+ search: '',
+ filters: JSON.stringify( [] ),
+ } );
+ } );
+} );
\ No newline at end of file
diff --git a/tests/js/app/data.spec.tsx b/tests/js/app/data.spec.tsx
new file mode 100644
index 0000000..45ee396
--- /dev/null
+++ b/tests/js/app/data.spec.tsx
@@ -0,0 +1,405 @@
+import React from 'react';
+import { render } from '@testing-library/react';
+import '@testing-library/jest-dom';
+// Data functions imported per test to avoid module cache issues
+import type { Field } from '@wordpress/dataviews';
+import type { Task } from '../../../app/types';
+
+// Mock WordPress dependencies
+jest.mock( '@wordpress/i18n', () => ( {
+ __: jest.fn( ( text ) => text ),
+} ) );
+
+jest.mock( '@wordpress/date', () => ( {
+ getSettings: jest.fn( () => ( {
+ formats: {
+ datetime: 'Y-m-d H:i:s',
+ date: 'Y-m-d',
+ },
+ } ) ),
+ humanTimeDiff: jest.fn( ( date1, date2 ) => '2 hours ago' ),
+ dateI18n: jest.fn( ( format, date ) => '2024-01-01' ),
+ getDate: jest.fn( ( dateString ) => {
+ if ( dateString === null ) {
+ return new Date();
+ }
+ return new Date( dateString );
+ } ),
+} ) );
+
+jest.mock( '@wordpress/api-fetch', () => jest.fn() );
+
+describe( 'data.tsx', () => {
+ beforeEach( () => {
+ // Reset global window object
+ delete global.window.shepherdData;
+ global.window.ajaxurl = 'http://example.com/wp-admin/admin-ajax.php';
+ jest.clearAllMocks();
+ // Clear module cache to reset unique values and defaultArgs
+ jest.resetModules();
+ } );
+
+ describe( 'getFields', () => {
+ const mockData = [
+ {
+ id: 1,
+ data: { task_class: 'TestTask' },
+ status: 'pending',
+ },
+ {
+ id: 2,
+ data: { task_class: 'AnotherTask' },
+ status: 'complete',
+ },
+ ];
+
+ it( 'should return all field definitions', () => {
+ const { getFields } = require( '../../../app/data' );
+ const fields = getFields( mockData );
+
+ expect( fields ).toHaveLength( 7 );
+ expect( fields.map( ( f ) => f.id ) ).toEqual( [
+ 'id',
+ 'action_id',
+ 'task_type',
+ 'task_args',
+ 'current_try',
+ 'status',
+ 'scheduled_at',
+ ] );
+ } );
+
+ it( 'should configure task ID field correctly', () => {
+ const { getFields } = require( '../../../app/data' );
+ const fields = getFields( mockData );
+ const idField = fields.find( ( f ) => f.id === 'id' );
+
+ expect( idField ).toBeDefined();
+ expect( idField.label ).toBe( 'Task ID' );
+ expect( idField.enableHiding ).toBe( false );
+ expect( idField.enableSorting ).toBe( true );
+ } );
+
+ it( 'should configure task type field with getValue and elements', () => {
+ const { getFields } = require( '../../../app/data' );
+ const fields = getFields( mockData );
+ const taskTypeField = fields.find( ( f ) => f.id === 'task_type' );
+
+ expect( taskTypeField ).toBeDefined();
+ expect( taskTypeField.getValue ).toBeDefined();
+ expect( taskTypeField.filterBy ).toEqual( {
+ operators: [ 'is' ],
+ isPrimary: true,
+ } );
+ expect( taskTypeField.elements ).toBeDefined();
+
+ // Test getValue function
+ const item = { data: { task_class: 'MyTask' } };
+ expect( taskTypeField.getValue( { item } ) ).toBe( 'MyTask' );
+ } );
+
+ it( 'should configure task args field with custom render', () => {
+ const { getFields } = require( '../../../app/data' );
+ const fields = getFields( mockData );
+ const argsField = fields.find( ( f ) => f.id === 'task_args' );
+
+ expect( argsField ).toBeDefined();
+ expect( argsField.render ).toBeDefined();
+
+ // Test render function
+ const item = { data: { args: [ 'arg1', 'arg2' ] } };
+ const { container } = render( { argsField.render( { item } ) }
);
+ const codeElement = container.querySelector( 'code' );
+
+ expect( codeElement ).toBeInTheDocument();
+ expect( codeElement ).toHaveStyle( {
+ whiteSpace: 'pre-wrap',
+ wordWrap: 'break-word',
+ } );
+ } );
+
+ it( 'should configure status field with elements and filtering', () => {
+ const { getFields } = require( '../../../app/data' );
+ const fields = getFields( mockData );
+ const statusField = fields.find( ( f ) => f.id === 'status' );
+
+ expect( statusField ).toBeDefined();
+ expect( statusField.elements ).toHaveLength( 5 );
+ expect( statusField.elements[ 0 ] ).toEqual( {
+ value: 'pending',
+ label: 'Pending',
+ } );
+ expect( statusField.filterBy ).toEqual( {
+ operators: [ 'is', 'isNot' ],
+ isPrimary: true,
+ } );
+ } );
+
+ it( 'should configure scheduled_at field with date rendering', () => {
+ const { getFields } = require( '../../../app/data' );
+ const fields = getFields( mockData );
+ const scheduledField = fields.find( ( f ) => f.id === 'scheduled_at' );
+
+ expect( scheduledField ).toBeDefined();
+ expect( scheduledField.render ).toBeDefined();
+
+ // Test render with null date
+ const itemNoDate = { scheduled_at: null };
+ const { container: containerNoDate } = render(
+ { scheduledField.render( { item: itemNoDate } ) }
+ );
+ expect( containerNoDate ).toHaveTextContent( 'Never' );
+
+ // Test render with recent date
+ const recentDate = new Date();
+ const itemRecent = { scheduled_at: recentDate };
+ const { container: containerRecent } = render(
+ { scheduledField.render( { item: itemRecent } ) }
+ );
+ expect( containerRecent ).toHaveTextContent( '2 hours ago' );
+
+ // Test render with old date
+ const oldDate = new Date( '2020-01-01' );
+ const itemOld = { scheduled_at: oldDate };
+ const { getDate } = require( '@wordpress/date' );
+ getDate.mockReturnValueOnce( new Date( '2024-01-01' ) );
+ const { container: containerOld } = render(
+ { scheduledField.render( { item: itemOld } ) }
+ );
+ expect( containerOld ).toHaveTextContent( '2024-01-01' );
+ } );
+ } );
+
+ describe( 'getTasks', () => {
+ const apiFetch = require( '@wordpress/api-fetch' );
+
+ it( 'should return data from window when using default args', async () => {
+ const defaultArgs = {
+ perPage: 10,
+ page: 1,
+ order: 'desc',
+ orderby: 'id',
+ search: '',
+ filters: '[]',
+ };
+
+ global.window.shepherdData = {
+ defaultArgs,
+ tasks: [
+ {
+ id: 1,
+ action_id: 100,
+ data: { task_class: 'TestTask', args: [ 'arg1' ] },
+ current_try: 1,
+ status: 'pending',
+ scheduled_at: { date: '2024-01-01 12:00:00' },
+ logs: [],
+ },
+ ],
+ totalItems: 1,
+ totalPages: 1,
+ };
+
+ // Import fresh module after setting window data
+ const { getTasks } = require( '../../../app/data' );
+ const result = await getTasks( defaultArgs );
+
+ expect( result.data ).toHaveLength( 1 );
+ expect( result.data[ 0 ].id ).toBe( 1 );
+ expect( result.data[ 0 ].scheduled_at ).toBeInstanceOf( Date );
+ expect( result.paginationInfo.totalItems ).toBe( 1 );
+ expect( apiFetch ).not.toHaveBeenCalled();
+ } );
+
+
+ it( 'should handle API errors gracefully', async () => {
+ global.window.shepherdData = {
+ defaultArgs: { perPage: 10 },
+ nonce: 'test-nonce',
+ };
+
+ // Import fresh module after setting window data
+ const { getTasks } = require( '../../../app/data' );
+
+ apiFetch.mockRejectedValue( new Error( 'Network error' ) );
+
+ const result = await getTasks( { perPage: 20 } );
+
+ expect( result.data ).toEqual( [] );
+ expect( result.paginationInfo ).toEqual( {
+ totalItems: 0,
+ totalPages: 0,
+ } );
+ } );
+
+ it( 'should handle unsuccessful API response', async () => {
+ global.window.shepherdData = {
+ defaultArgs: { perPage: 10 },
+ nonce: 'test-nonce',
+ };
+
+ // Import fresh module after setting window data
+ const { getTasks } = require( '../../../app/data' );
+
+ apiFetch.mockResolvedValue( {
+ success: false,
+ data: { message: 'Error occurred' },
+ } );
+
+ const result = await getTasks( { perPage: 20 } );
+
+ expect( result.data ).toEqual( [] );
+ expect( result.paginationInfo ).toEqual( {
+ totalItems: 0,
+ totalPages: 0,
+ } );
+ } );
+
+ it( 'should handle scheduled_at date conversion', async () => {
+ const { getDate } = require( '@wordpress/date' );
+ const mockDate = new Date( '2024-01-01T12:00:00Z' );
+ getDate.mockReturnValue( mockDate );
+
+ const defaultArgs = { perPage: 10, page: 1, order: 'desc', orderby: 'id', search: '', filters: '[]' };
+ global.window.shepherdData = {
+ defaultArgs,
+ tasks: [
+ {
+ id: 1,
+ action_id: 100,
+ data: { task_class: 'TestTask', args: [] },
+ current_try: 1,
+ status: 'pending',
+ scheduled_at: { date: '2024-01-01 12:00:00' },
+ logs: [],
+ },
+ ],
+ };
+
+ // Import fresh module after setting window data
+ const { getTasks } = require( '../../../app/data' );
+ const result = await getTasks( defaultArgs );
+
+ expect( getDate ).toHaveBeenCalledWith( '2024-01-01 12:00:00' );
+ expect( result.data[ 0 ].scheduled_at ).toBe( mockDate );
+ } );
+ } );
+
+ describe( 'getPaginationInfo', () => {
+ it( 'should return pagination info from window data', () => {
+ global.window.shepherdData = {
+ totalItems: 100,
+ totalPages: 10,
+ };
+
+ const { getPaginationInfo } = require( '../../../app/data' );
+ const paginationInfo = getPaginationInfo();
+
+ expect( paginationInfo ).toEqual( {
+ totalItems: 100,
+ totalPages: 10,
+ } );
+ } );
+
+ it( 'should return zero values when no data', () => {
+ const { getPaginationInfo } = require( '../../../app/data' );
+ const paginationInfo = getPaginationInfo();
+
+ expect( paginationInfo ).toEqual( {
+ totalItems: 0,
+ totalPages: 0,
+ } );
+ } );
+
+ it( 'should handle partial data', () => {
+ global.window.shepherdData = {
+ totalItems: 50,
+ };
+
+ const { getPaginationInfo } = require( '../../../app/data' );
+ const paginationInfo = getPaginationInfo();
+
+ expect( paginationInfo ).toEqual( {
+ totalItems: 50,
+ totalPages: 0,
+ } );
+ } );
+ } );
+
+ describe( 'getUniqueValuesOfData', () => {
+ const mockTasks = [
+ { id: 1, status: 'pending', data: { task_class: 'EmailTask' } },
+ { id: 2, status: 'complete', data: { task_class: 'EmailTask' } },
+ { id: 3, status: 'pending', data: { task_class: 'HTTPTask' } },
+ { id: 4, status: 'failed', data: { task_class: 'HTTPTask' } },
+ ];
+
+
+ it( 'should extract unique values from top-level fields', () => {
+ const { getUniqueValuesOfData } = require( '../../../app/data' );
+ const result = getUniqueValuesOfData( 'status', mockTasks );
+
+ expect( result ).toHaveLength( 3 );
+ expect( result ).toEqual( [
+ { label: 'pending', value: 'pending' },
+ { label: 'complete', value: 'complete' },
+ { label: 'failed', value: 'failed' },
+ ] );
+ } );
+
+ it( 'should extract unique values from nested data fields', () => {
+ const { getUniqueValuesOfData } = require( '../../../app/data' );
+ const result = getUniqueValuesOfData( 'task_class', mockTasks );
+
+ expect( result ).toHaveLength( 2 );
+ expect( result ).toEqual( [
+ { label: 'EmailTask', value: 'EmailTask' },
+ { label: 'HTTPTask', value: 'HTTPTask' },
+ ] );
+ } );
+
+ it( 'should cache unique values across multiple calls', () => {
+ const { getUniqueValuesOfData } = require( '../../../app/data' );
+ // First call
+ getUniqueValuesOfData( 'status', mockTasks.slice( 0, 2 ) );
+
+ // Second call with additional data
+ const result = getUniqueValuesOfData( 'status', mockTasks.slice( 2, 4 ) );
+
+ // Should have all unique values from both calls
+ expect( result ).toHaveLength( 3 );
+ } );
+
+ it( 'should handle undefined values', () => {
+ const { getUniqueValuesOfData } = require( '../../../app/data' );
+ const tasksWithUndefined = [
+ { id: 1, status: 'pending', data: {} },
+ { id: 2, data: {} }, // status is undefined
+ { id: 3, status: 'complete', data: {} },
+ ];
+
+ const result = getUniqueValuesOfData( 'status', tasksWithUndefined );
+
+ expect( result ).toHaveLength( 3 );
+ expect( result ).toEqual( [
+ { label: 'pending', value: 'pending' },
+ { label: undefined, value: undefined },
+ { label: 'complete', value: 'complete' },
+ ] );
+ } );
+ } );
+} );
+
+// Type augmentation for window object
+declare global {
+ interface Window {
+ shepherdData?: {
+ tasks?: any[];
+ totalItems?: number;
+ totalPages?: number;
+ defaultArgs?: any;
+ nonce?: string;
+ };
+ ajaxurl?: string;
+ }
+}
\ No newline at end of file
diff --git a/tests/js/setup.js b/tests/js/setup.js
new file mode 100644
index 0000000..4753ea0
--- /dev/null
+++ b/tests/js/setup.js
@@ -0,0 +1,12 @@
+// Jest setup file
+import '@testing-library/jest-dom';
+
+// Mock console methods to avoid cluttering test output
+global.console = {
+ ...console,
+ log: jest.fn(),
+ debug: jest.fn(),
+ info: jest.fn(),
+ warn: jest.fn(),
+ error: jest.fn(),
+};
\ No newline at end of file
diff --git a/tests/wpunit/Admin/Provider_Test.php b/tests/wpunit/Admin/Provider_Test.php
new file mode 100644
index 0000000..4427552
--- /dev/null
+++ b/tests/wpunit/Admin/Provider_Test.php
@@ -0,0 +1,283 @@
+set_fn_return( 'is_admin', true );
+ Config::set_render_admin_ui( true );
+ $this->provider = Config::get_container()->get( Provider::class );
+ $this->provider->register();
+ }
+
+ /**
+ * @after
+ */
+ public function cleanup_provider(): void {
+ Config::set_render_admin_ui( false );
+ $_POST = [];
+ }
+
+ /**
+ * @test
+ */
+ public function it_should_register_hooks(): void {
+ $this->assertNotFalse(
+ has_action( 'wp_ajax_shepherd_get_tasks', [ $this->provider, 'ajax_get_tasks' ] ),
+ 'AJAX action should be registered'
+ );
+
+ $this->assertNotFalse(
+ has_action( 'admin_menu', [ $this->provider, 'register_admin_menu' ] ),
+ 'Admin menu action should be registered'
+ );
+ }
+
+ /**
+ * Test admin page HTML rendering
+ * @test
+ */
+ public function it_should_render_admin_page(): void {
+ ob_start();
+ $this->provider->render_admin_page();
+ $output = ob_get_clean();
+
+ $this->assertMatchesHtmlSnapshot( $output );
+ }
+
+ /**
+ * Test custom title rendering
+ * @test
+ */
+ public function it_should_render_custom_titles(): void {
+ Config::set_admin_page_in_page_title_callback( fn() => 'Custom Unit Test Title' );
+
+ ob_start();
+ $this->provider->render_admin_page();
+ $output = ob_get_clean();
+
+ $this->assertMatchesHtmlSnapshot( $output );
+ }
+
+ /**
+ * Test asset enqueuing
+ * @test
+ */
+ public function it_should_enqueue_admin_page_assets(): void {
+ global $wp_scripts, $wp_styles;
+
+ $this->provider->enqueue_admin_page_assets();
+
+ // Check script is enqueued
+ $this->assertArrayHasKey( 'shepherd-admin-script', $wp_scripts->registered );
+ $this->assertContains( 'wp-components', $wp_scripts->registered['shepherd-admin-script']->deps );
+ $this->assertContains( 'wp-data', $wp_scripts->registered['shepherd-admin-script']->deps );
+
+ // Check style is enqueued
+ $this->assertArrayHasKey( 'shepherd-admin-style', $wp_styles->registered );
+ }
+
+ /**
+ * Test script localization
+ * @test
+ */
+ public function it_should_localize_script_data(): void {
+ global $wp_scripts;
+
+ $this->provider->enqueue_admin_page_assets();
+
+ // Check localized data exists
+ $localized = $wp_scripts->get_data( 'shepherd-admin-script', 'data' );
+ $this->assertStringContainsString( 'shepherdData', $localized );
+ $this->assertStringContainsString( 'tasks', $localized );
+ $this->assertStringContainsString( 'totalItems', $localized );
+ $this->assertStringContainsString( 'totalPages', $localized );
+ $this->assertStringContainsString( 'nonce', $localized );
+ }
+
+ /**
+ * Test capability configuration
+ * @test
+ */
+ public function it_should_respect_admin_page_capability(): void {
+ // Test default capability
+ $this->assertEquals( 'manage_options', Config::get_admin_page_capability() );
+
+ // Test setting custom capability
+ Config::set_admin_page_capability( 'edit_posts' );
+ $this->assertEquals( 'edit_posts', Config::get_admin_page_capability() );
+
+ // Reset to default
+ Config::set_admin_page_capability( 'manage_options' );
+ }
+
+ /**
+ * Test localized data structure
+ * @test
+ */
+ public function it_should_provide_correct_localized_data_structure(): void {
+ $reflection = new \ReflectionMethod( $this->provider, 'get_localized_data' );
+ $reflection->setAccessible( true );
+ $data = $reflection->invoke( $this->provider );
+
+ // Check required keys exist
+ $this->assertArrayHasKey( 'tasks', $data );
+ $this->assertArrayHasKey( 'totalItems', $data );
+ $this->assertArrayHasKey( 'totalPages', $data );
+ $this->assertArrayHasKey( 'defaultArgs', $data );
+ $this->assertArrayHasKey( 'nonce', $data );
+
+ // Check data types
+ $this->assertIsArray( $data['tasks'] );
+ $this->assertIsInt( $data['totalItems'] );
+ $this->assertIsInt( $data['totalPages'] );
+ $this->assertIsArray( $data['defaultArgs'] );
+ $this->assertIsString( $data['nonce'] );
+
+ // Check default args structure
+ $defaultArgs = $data['defaultArgs'];
+ $this->assertEquals( 10, $defaultArgs['perPage'] );
+ $this->assertEquals( 1, $defaultArgs['page'] );
+ $this->assertEquals( 'desc', $defaultArgs['order'] );
+ $this->assertEquals( 'id', $defaultArgs['orderby'] );
+ $this->assertEquals( '', $defaultArgs['search'] );
+ $this->assertEquals( '[]', $defaultArgs['filters'] );
+ }
+
+ /**
+ * Test get_tasks method parameter handling
+ * @test
+ */
+ public function it_should_handle_get_tasks_method_parameters(): void {
+ $reflection = new \ReflectionMethod( $this->provider, 'get_tasks' );
+ $reflection->setAccessible( true );
+
+ // Test basic call
+ $result = $reflection->invoke( $this->provider, [], 10, 1 );
+
+ $this->assertIsArray( $result );
+ $this->assertArrayHasKey( 'tasks', $result );
+ $this->assertArrayHasKey( 'totalItems', $result );
+ $this->assertArrayHasKey( 'totalPages', $result );
+
+ // Test with different parameters
+ $result2 = $reflection->invoke( $this->provider, [ 'orderby' => 'action_id' ], 5, 2 );
+ $this->assertIsArray( $result2 );
+ $this->assertArrayHasKey( 'tasks', $result2 );
+ }
+
+ /**
+ * Test AJAX method structure
+ * @test
+ */
+ public function it_should_have_proper_ajax_method(): void {
+ // Test method exists
+ $this->assertTrue( method_exists( $this->provider, 'ajax_get_tasks' ) );
+
+ // Test method visibility
+ $reflection = new \ReflectionMethod( $this->provider, 'ajax_get_tasks' );
+ $this->assertTrue( $reflection->isPublic() );
+
+ // Test method parameters
+ $this->assertEquals( 0, $reflection->getNumberOfParameters() );
+ }
+
+ /**
+ * Test provider registration state
+ * @test
+ */
+ public function it_should_track_registration_state(): void {
+ // Test that Provider tracks if it's registered
+ $this->assertTrue( Provider::is_registered() );
+
+ // Test multiple registrations don't cause issues
+ $this->provider->register();
+ $this->provider->register();
+ $this->assertTrue( Provider::is_registered() );
+ }
+
+ /**
+ * Test admin page rendering with various configurations
+ * @test
+ */
+ public function it_should_handle_various_title_configurations(): void {
+ // Test with page title callback
+ Config::set_admin_page_title_callback( fn() => 'Unit Test Page Title' );
+ $this->assertEquals( 'Unit Test Page Title', Config::get_admin_page_title() );
+
+ // Test with menu title callback
+ Config::set_admin_menu_title_callback( fn() => 'Unit Test Menu' );
+ $this->assertEquals( 'Unit Test Menu', Config::get_admin_menu_title() );
+
+ // Test with in-page title callback
+ Config::set_admin_page_in_page_title_callback( fn() => 'Unit Test In-Page' );
+ $this->assertEquals( 'Unit Test In-Page', Config::get_admin_page_in_page_title() );
+
+ // Test rendering reflects the in-page title
+ ob_start();
+ $this->provider->render_admin_page();
+ $output = ob_get_clean();
+ $this->assertStringContainsString( 'Unit Test In-Page', $output );
+
+ // Cleanup
+ Config::set_admin_page_title_callback( null );
+ Config::set_admin_menu_title_callback( null );
+ Config::set_admin_page_in_page_title_callback( null );
+ }
+
+ /**
+ * Test render_admin_ui configuration affects registration
+ * @test
+ */
+ public function it_should_respect_render_admin_ui_configuration(): void {
+ // Test that config setting affects behavior
+ $original_setting = Config::get_render_admin_ui();
+
+ Config::set_render_admin_ui( false );
+ $this->assertFalse( Config::get_render_admin_ui() );
+
+ Config::set_render_admin_ui( true );
+ $this->assertTrue( Config::get_render_admin_ui() );
+
+ // Restore original
+ Config::set_render_admin_ui( $original_setting );
+ }
+
+ /**
+ * Test that provider methods handle edge cases
+ * @test
+ */
+ public function it_should_handle_edge_cases_gracefully(): void {
+ // Test rendering with empty/null configurations
+ Config::set_admin_page_in_page_title_callback( fn() => '' );
+
+ ob_start();
+ $this->provider->render_admin_page();
+ $output = ob_get_clean();
+
+ $this->assertMatchesHtmlSnapshot( $output );
+ }
+}
diff --git a/tests/wpunit/Admin/__snapshots__/Provider_Test__it_should_handle_edge_cases_gracefully__0.snapshot.html b/tests/wpunit/Admin/__snapshots__/Provider_Test__it_should_handle_edge_cases_gracefully__0.snapshot.html
new file mode 100644
index 0000000..738e1f9
--- /dev/null
+++ b/tests/wpunit/Admin/__snapshots__/Provider_Test__it_should_handle_edge_cases_gracefully__0.snapshot.html
@@ -0,0 +1,6 @@
+
+
\ No newline at end of file
diff --git a/tests/wpunit/Admin/__snapshots__/Provider_Test__it_should_render_admin_page__0.snapshot.html b/tests/wpunit/Admin/__snapshots__/Provider_Test__it_should_render_admin_page__0.snapshot.html
new file mode 100644
index 0000000..dd81dd4
--- /dev/null
+++ b/tests/wpunit/Admin/__snapshots__/Provider_Test__it_should_render_admin_page__0.snapshot.html
@@ -0,0 +1,6 @@
+
+
+ Shepherd Task Manager (via foobar)
+
+
+
+ Custom Unit Test Title
+
+