class EventPropertyAccessTest

class EventPropertyAccessTest extends EventTestBase {
    
    /**
     * {@inheritdoc}
     */
    protected function setUp() : void {
        parent::setUp();
        // Must enable our test module to make its plugins discoverable.
        $this->enableModule('rules_test_event', [
            'Drupal\\rules_test_event' => __DIR__ . '/../../../../modules/rules_test_event/src',
        ]);
        // Tell the plugin manager where to look for plugins.
        $this->moduleHandler
            ->getModuleDirectories()
            ->willReturn([
            'rules_test_event' => __DIR__ . '/../../../../modules/rules_test_event/',
        ]);
        // Create a real plugin manager with a mock moduleHandler.
        $this->eventManager = new RulesEventManager($this->moduleHandler
            ->reveal(), $this->entityTypeBundleInfo
            ->reveal());
    }
    
    /**
     * Tests the event metadata to ensure that all properties may be accessed.
     *
     * Access to properties declared in the metadata is tested using code copied
     * from \Drupal\rules\EventSubscriber\GenericEventSubscriber, so this test
     * does not directly test GenericEventSubscriber - that is done correctly
     * in the Kernel test \Drupal\Tests\rules\Kernel\EventPropertyAccessTest.
     *
     * @param string $event_name
     *   The Plugin ID of the event being tested.
     * @param object $event
     *   The event object being tested.
     *   In Drupal 9 this will be a \Symfony\Component\EventDispatcher\Event,
     *   In Drupal 10 this will be a \Symfony\Contracts\EventDispatcher\Event.
     *
     * @dataProvider provideTestEvent
     */
    public function testEventContextDefinition($event_name, object $event) : void {
        $plugin = $this->eventManager
            ->createInstance($event_name);
        $context_definitions = $plugin->getContextDefinitions();
        foreach ($context_definitions as $name => $definition) {
            $this->assertSame('string', $definition->getDataType());
            // Properties for these test events should be named <visibility>Property.
            // We just want the <visibility> part.
            $visibility = substr($name, 0, -8);
            $this->assertSame('A ' . $visibility . ' string', $definition->getLabel());
            // If this is a GenericEvent, get the value of the context variable from
            // the event arguments.
            if ($event instanceof SymfonyGenericEvent) {
                $value = $event->getArgument($name);
            }
            elseif ($definition->hasGetter()) {
                $value = $event->{$definition->getGetter()}();
            }
            else {
                $getter = function ($property) {
                    return $this->{$property};
                };
                $value = $getter->call($event, $name);
            }
            $this->assertEquals($visibility . ' property', $value);
        }
    }
    
    /**
     * Provider for events to test.
     *
     * Passes an event name and an event object for each test case.
     * Here we use all the events defined in the rules_test_event test module.
     *
     * @return array
     *   Array of array of values to be passed to our test.
     */
    public function provideTestEvent() : array {
        return [
            'Plain event' => [
                'rules_test_event.plain_event',
                new PlainEvent(),
            ],
            'Generic event' => [
                'rules_test_event.generic_event',
                new GenericEvent('Test subject', [
                    'publicProperty' => 'public property',
                    'protectedProperty' => 'protected property',
                    'privateProperty' => 'private property',
                ]),
            ],
            'Getter event' => [
                'rules_test_event.getter_event',
                new GetterEvent(),
            ],
        ];
    }

}