ECS Testing

package com.example.tests;

import com.frotty27.hrtk.api.annotation.EcsTest;
import com.frotty27.hrtk.api.annotation.HytaleSuite;
import com.frotty27.hrtk.api.annotation.Tag;
import com.frotty27.hrtk.api.annotation.DisplayName;
import com.frotty27.hrtk.api.annotation.Order;
import com.frotty27.hrtk.api.assert_.EcsAssert;
import com.frotty27.hrtk.api.assert_.HytaleAssert;
import com.frotty27.hrtk.api.context.EcsTestContext;
import com.frotty27.hrtk.api.lifecycle.IsolationStrategy;

import java.util.List;

@HytaleSuite(value = "ECS Surface Tests", isolation = IsolationStrategy.SNAPSHOT)
@Tag("ecs")
public class EcsSurfaceTests {

    @EcsTest
    @Order(1)
    @DisplayName("Create an entity and verify it exists")
    void testCreateEntity(EcsTestContext ctx) {
        // Creating an entity returns a Ref that points to the new entity in the store.
        // This is the most fundamental ECS operation - if this fails, nothing else works.
        Object ref = ctx.createEntity();

        // The ref must be non-null, meaning the store successfully allocated an entity slot.
        EcsAssert.assertRefValid(ref);
    }

    @EcsTest
    @Order(2)
    @DisplayName("Attach a TransformComponent and verify it is present")
    void testPutAndVerifyComponent(EcsTestContext ctx) {
        // Step 1: Create a bare entity with no components
        Object ref = ctx.createEntity();

        // Step 2: Attach a TransformComponent via the command buffer.
        // The command buffer batches operations and applies them on flush().
        ctx.putComponent(ref, TransformComponent.getComponentType(),
                         new TransformComponent());
        ctx.flush();

        // Step 3: Verify the component is now attached to the entity.
        // This confirms the archetype changed to include TransformComponent.
        HytaleAssert.assertTrue(
            "Entity should have TransformComponent after putComponent + flush",
            ctx.hasComponent(ref, TransformComponent.getComponentType())
        );
    }

    @EcsTest
    @Order(3)
    @DisplayName("Retrieve a component with assertGetComponent")
    void testAssertGetComponent(EcsTestContext ctx) {
        Object ref = ctx.createEntity();
        ctx.putComponent(ref, TransformComponent.getComponentType(),
                         new TransformComponent());
        ctx.flush();

        // assertGetComponent both asserts the component exists AND returns it.
        // This is useful when you need to inspect the component's data after retrieval.
        Object component = EcsAssert.assertGetComponent(
            ctx.getStore(), ref, TransformComponent.getComponentType()
        );
        HytaleAssert.assertNotNull("Retrieved component should not be null", component);
    }

    @EcsTest
    @Order(4)
    @DisplayName("Remove a component and verify it is gone")
    void testRemoveComponent(EcsTestContext ctx) {
        Object ref = ctx.createEntity();
        ctx.putComponent(ref, TransformComponent.getComponentType(),
                         new TransformComponent());
        ctx.flush();

        // Remove the component through the command buffer, then flush.
        ctx.removeComponent(ref, TransformComponent.getComponentType());
        ctx.flush();

        // The entity should no longer have the TransformComponent.
        // This verifies that the archetype reverted correctly.
        EcsAssert.assertNotHasComponent(
            ctx.getStore(), ref, TransformComponent.getComponentType()
        );
    }

    @EcsTest
    @Order(5)
    @DisplayName("Find entities by component type")
    void testFindEntitiesByComponent(EcsTestContext ctx) {
        // Create an entity and give it a TransformComponent so it shows up in queries.
        Object ref = ctx.createEntity();
        ctx.putComponent(ref, TransformComponent.getComponentType(),
                         new TransformComponent());
        ctx.flush();

        // findEntities returns all entity refs that have the given component type.
        // This is how game systems iterate over entities they care about.
        List<?> found = ctx.findEntities(TransformComponent.getComponentType());
        HytaleAssert.assertNotEmpty(found);

        // countEntities is a shortcut that returns the count without allocating a list.
        int count = ctx.countEntities(TransformComponent.getComponentType());
        HytaleAssert.assertGreaterThan(0, count);
    }

    @EcsTest
    @Order(6)
    @DisplayName("Verify an invalid ref is detected")
    void testInvalidRef(EcsTestContext ctx) {
        // Passing null as a ref should be caught by assertRefInvalid.
        // This is useful for testing error paths where entity creation might fail.
        EcsAssert.assertRefInvalid(null);
    }
}