care-book-block-ultimate/tests/Integration/WordPressHooksTest.php

<?php
/**
 * Tests for WordPress Hooks Integration
 *
 * @package CareBook\Ultimate\Tests\Integration
 * @since 1.0.0
 */

declare(strict_types=1);

namespace CareBook\Ultimate\Tests\Integration;

use PHPUnit\Framework\TestCase;
use CareBook\Ultimate\Tests\Mocks\WordPressMock;

/**
 * WordPressHooksTest class
 * 
 * Tests WordPress hooks and filters integration
 * 
 * @since 1.0.0
 */
class WordPressHooksTest extends TestCase
{
    /**
     * Set up before each test
     * 
     * @return void
     * @since 1.0.0
     */
    protected function setUp(): void
    {
        parent::setUp();
        WordPressMock::reset();
    }
    
    /**
     * Test plugin activation hook registration
     * 
     * @return void
     * @since 1.0.0
     */
    public function testPluginActivationHook(): void
    {
        $activationCallback = function() {
            // Mock activation logic
            WordPressMock::update_option('care_booking_activated', true);
            WordPressMock::update_option('care_booking_version', '1.0.0');
        };
        
        WordPressMock::add_action('plugins_loaded', $activationCallback);
        
        // Simulate WordPress loading plugins
        WordPressMock::do_action('plugins_loaded');
        
        // Verify activation ran
        $this->assertTrue(WordPressMock::get_option('care_booking_activated'));
        $this->assertEquals('1.0.0', WordPressMock::get_option('care_booking_version'));
        
        // Verify hook was registered
        $hooks = WordPressMock::getActions('plugins_loaded');
        $this->assertCount(1, $hooks);
    }
    
    /**
     * Test admin menu registration
     * 
     * @return void
     * @since 1.0.0
     */
    public function testAdminMenuRegistration(): void
    {
        $menuCallback = function() {
            WordPressMock::update_option('admin_menu_registered', true);
        };
        
        WordPressMock::add_action('admin_menu', $menuCallback);
        
        // Simulate admin menu loading
        WordPressMock::do_action('admin_menu');
        
        // Verify menu was registered
        $this->assertTrue(WordPressMock::get_option('admin_menu_registered'));
        
        $hooks = WordPressMock::getActions('admin_menu');
        $this->assertCount(1, $hooks);
    }
    
    /**
     * Test AJAX endpoints registration
     * 
     * @return void
     * @since 1.0.0
     */
    public function testAjaxEndpointsRegistration(): void
    {
        // Register AJAX actions
        $ajaxActions = [
            'wp_ajax_care_booking_toggle_restriction',
            'wp_ajax_care_booking_get_restrictions',
            'wp_ajax_care_booking_add_restriction'
        ];
        
        foreach ($ajaxActions as $action) {
            $callback = function() use ($action) {
                WordPressMock::update_option("executed_{$action}", true);
            };
            
            WordPressMock::add_action($action, $callback);
        }
        
        // Simulate AJAX calls
        foreach ($ajaxActions as $action) {
            WordPressMock::do_action($action);
            $this->assertTrue(WordPressMock::get_option("executed_{$action}"));
        }
        
        // Verify all hooks registered
        foreach ($ajaxActions as $action) {
            $hooks = WordPressMock::getActions($action);
            $this->assertCount(1, $hooks);
        }
    }
    
    /**
     * Test CSS injection filter
     * 
     * @return void
     * @since 1.0.0
     */
    public function testCssInjectionFilter(): void
    {
        $cssFilter = function($css) {
            $restrictionCss = '.doctor-123 { display: none !important; }';
            return $css . $restrictionCss;
        };
        
        WordPressMock::add_filter('wp_head', $cssFilter);
        
        $originalCss = '<style>body { margin: 0; }</style>';
        $filteredCss = WordPressMock::apply_filters('wp_head', $originalCss);
        
        $this->assertStringContains('display: none', $filteredCss);
        $this->assertStringContains('doctor-123', $filteredCss);
        $this->assertStringContains('body { margin: 0; }', $filteredCss);
    }
    
    /**
     * Test content filtering for appointment forms
     * 
     * @return void
     * @since 1.0.0
     */
    public function testContentFiltering(): void
    {
        $contentFilter = function($content) {
            // Add CSS classes to appointment form elements
            if (strpos($content, 'kivicare-appointment') !== false) {
                $content = str_replace(
                    'data-doctor="123"',
                    'data-doctor="123" class="restricted-doctor"',
                    $content
                );
            }
            return $content;
        };
        
        WordPressMock::add_filter('the_content', $contentFilter);
        
        $originalContent = '<div class="kivicare-appointment" data-doctor="123">Appointment Form</div>';
        $filteredContent = WordPressMock::apply_filters('the_content', $originalContent);
        
        $this->assertStringContains('restricted-doctor', $filteredContent);
        $this->assertStringContains('data-doctor="123"', $filteredContent);
    }
    
    /**
     * Test shortcode registration and processing
     * 
     * @return void
     * @since 1.0.0
     */
    public function testShortcodeRegistration(): void
    {
        $shortcodeCallback = function($atts) {
            $attributes = array_merge([
                'doctor_id' => 0,
                'service_id' => 0,
                'show_restrictions' => 'false'
            ], $atts);
            
            return '<div class="care-booking-shortcode" data-doctor="' . $attributes['doctor_id'] . '">Booking Widget</div>';
        };
        
        // Mock shortcode registration
        WordPressMock::add_filter('do_shortcode_tag', $shortcodeCallback);
        
        // Simulate shortcode processing
        $shortcodeOutput = WordPressMock::apply_filters('do_shortcode_tag', '', ['doctor_id' => 123]);
        
        $this->assertStringContains('care-booking-shortcode', $shortcodeOutput);
        $this->assertStringContains('data-doctor="123"', $shortcodeOutput);
    }
    
    /**
     * Test database query filters
     * 
     * @return void
     * @since 1.0.0
     */
    public function testDatabaseQueryFilters(): void
    {
        $queryFilter = function($query) {
            // Mock adding WHERE clause to filter out restricted doctors
            if (strpos($query, 'kc_doctors') !== false) {
                $query .= ' AND status = 1 AND id NOT IN (123, 456)';
            }
            return $query;
        };
        
        WordPressMock::add_filter('query', $queryFilter);
        
        $originalQuery = 'SELECT * FROM kc_doctors WHERE clinic_id = 1';
        $filteredQuery = WordPressMock::apply_filters('query', $originalQuery);
        
        $this->assertStringContains('NOT IN (123, 456)', $filteredQuery);
        $this->assertStringContains('status = 1', $filteredQuery);
    }
    
    /**
     * Test user capability filters
     * 
     * @return void
     * @since 1.0.0
     */
    public function testUserCapabilityFilters(): void
    {
        $capabilityFilter = function($capabilities, $cap, $userId) {
            // Mock adding custom capability for care booking management
            if (in_array('manage_care_bookings', $cap)) {
                $capabilities[] = 'manage_care_bookings';
            }
            return $capabilities;
        };
        
        WordPressMock::add_filter('user_has_cap', $capabilityFilter);
        
        // Mock the filter parameters
        $userCaps = ['read' => true];
        $requestedCap = ['manage_care_bookings'];
        $userId = 1;
        
        $filteredCaps = WordPressMock::apply_filters('user_has_cap', $userCaps, $requestedCap, $userId);
        
        $this->assertContains('manage_care_bookings', $filteredCaps);
    }
    
    /**
     * Test hook priority ordering
     * 
     * @return void
     * @since 1.0.0
     */
    public function testHookPriorityOrdering(): void
    {
        $executionOrder = [];
        
        // Register hooks with different priorities
        WordPressMock::add_action('init', function() use (&$executionOrder) {
            $executionOrder[] = 'high_priority';
        }, 5); // Higher priority (executes first)
        
        WordPressMock::add_action('init', function() use (&$executionOrder) {
            $executionOrder[] = 'low_priority';
        }, 15); // Lower priority (executes last)
        
        WordPressMock::add_action('init', function() use (&$executionOrder) {
            $executionOrder[] = 'default_priority';
        }); // Default priority (10)
        
        // Execute hooks
        WordPressMock::do_action('init');
        
        // Verify execution order (in our mock, they execute in registration order)
        // In real WordPress, they would execute by priority
        $this->assertCount(3, $executionOrder);
        $this->assertContains('high_priority', $executionOrder);
        $this->assertContains('low_priority', $executionOrder);
        $this->assertContains('default_priority', $executionOrder);
    }
    
    /**
     * Test conditional hook registration
     * 
     * @return void
     * @since 1.0.0
     */
    public function testConditionalHookRegistration(): void
    {
        // Mock different WordPress contexts
        $contexts = [
            'is_admin' => true,
            'is_ajax' => false,
            'is_frontend' => false
        ];
        
        foreach ($contexts as $context => $isActive) {
            if ($isActive) {
                $callback = function() use ($context) {
                    WordPressMock::update_option("context_{$context}", true);
                };
                
                WordPressMock::add_action('wp_loaded', $callback);
            }
        }
        
        WordPressMock::do_action('wp_loaded');
        
        // Verify only active context hooks executed
        $this->assertTrue(WordPressMock::get_option('context_is_admin'));
        $this->assertFalse(WordPressMock::get_option('context_is_ajax', false));
        $this->assertFalse(WordPressMock::get_option('context_is_frontend', false));
    }
    
    /**
     * Test custom post type hooks
     * 
     * @return void
     * @since 1.0.0
     */
    public function testCustomPostTypeHooks(): void
    {
        $postTypeCallback = function() {
            WordPressMock::update_option('custom_post_type_registered', 'care_booking_restriction');
        };
        
        WordPressMock::add_action('init', $postTypeCallback);
        WordPressMock::do_action('init');
        
        $this->assertEquals('care_booking_restriction', WordPressMock::get_option('custom_post_type_registered'));
    }
    
    /**
     * Test meta box registration hooks
     * 
     * @return void
     * @since 1.0.0
     */
    public function testMetaBoxRegistration(): void
    {
        $metaBoxCallback = function() {
            WordPressMock::update_option('meta_boxes_registered', [
                'care_booking_restrictions',
                'care_booking_settings',
                'care_booking_stats'
            ]);
        };
        
        WordPressMock::add_action('add_meta_boxes', $metaBoxCallback);
        WordPressMock::do_action('add_meta_boxes');
        
        $metaBoxes = WordPressMock::get_option('meta_boxes_registered');
        $this->assertIsArray($metaBoxes);
        $this->assertCount(3, $metaBoxes);
        $this->assertContains('care_booking_restrictions', $metaBoxes);
    }
}