/**
* SPDX-FileCopyrightText: Copyright contributors to the CopilotJ project.
*
* SPDX-License-Identifier: Apache-2.0
*/
package copilotj.awt.container;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.awt.Component;
import java.awt.Container;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.jupiter.api.Test;
import copilotj.awt.Action;
import copilotj.awt.component.ComponentNode;
/**
* Tests {@link AbstractContainerNode}'s action aggregation and path routing.
*
*
The node is built from a Mockito {@link Container} (NOT a real
* {@code java.awt.Panel}/{@code Button}) and its children are injected mock
* {@link ComponentNode}s. This is required because real AWT component
* construction throws {@link java.awt.HeadlessException} on headless Linux CI
* ("no headful library support was found"), even though it works on a mac with a
* full AWT toolkit. {@code getActions()} has no activation gate and is exercised
* directly; {@code runAction} is reached via a subclass overriding
* {@code isActivate()} to true.
*/
public class AbstractContainerNodeTest {
/** A mock Container whose getComponents() won't NPE the constructor's child loop. */
private static Container mockContainer() {
final Container c = mock(Container.class);
when(c.getComponents()).thenReturn(new Component[0]);
return c;
}
private static void setChildren(final AbstractContainerNode> node, final List children) {
try {
final Field f = AbstractContainerNode.class.getField("children"); // public final
f.setAccessible(true);
f.set(node, children);
} catch (final ReflectiveOperationException e) {
throw new AssertionError("cannot set children field", e);
}
}
private static AbstractContainerNode node(final List children) {
final AbstractContainerNode node = new UnknownContainerNode(mockContainer());
setChildren(node, children);
return node;
}
/** A node that reports itself activated, bypassing the headless isShowing() gate. */
private static AbstractContainerNode activated(final List children) {
final AbstractContainerNode node = new UnknownContainerNode(mockContainer()) {
@Override
public boolean isActivate() {
return true;
}
};
setChildren(node, children);
return node;
}
private static ComponentNode childWithClickAction() {
final ComponentNode child = mock(ComponentNode.class);
when(child.getActions()).thenReturn(Collections.singletonList(Action.builder("t.click", "Click", "d").build()));
return child;
}
private static String last(final List path) {
return path.get(path.size() - 1);
}
// ===== getActions() =====
@Test
public void getActionsNullForChildlessContainer() {
assertNull(new UnknownContainerNode(mockContainer()).getActions(), "no children -> null");
}
@Test
public void getActionsPrefixesEachChildPath() {
final AbstractContainerNode n = node(Arrays.asList(childWithClickAction(), childWithClickAction()));
final List actions = n.getActions();
assertEquals(2, actions.size(), "one aggregated action per child");
assertEquals("children[0]", last(actions.get(0).path));
assertEquals("children[1]", last(actions.get(1).path));
}
// ===== runAction() =====
@Test
public void runActionThrowsWhenNotActivated() {
// node() does not override isActivate() -> permanently deactivated (mock isShowing()=false).
final AbstractContainerNode n = node(Arrays.asList(childWithClickAction()));
final IllegalStateException ex = assertThrows(IllegalStateException.class,
() -> n.runAction(new ArrayList<>(Arrays.asList("children[0]")), "x", null));
assertTrue(ex.getMessage().contains("not activated"));
}
@Test
public void runActionThrowsOnEmptyPath() {
final AbstractContainerNode n = activated(Arrays.asList(childWithClickAction()));
final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
() -> n.runAction(new ArrayList<>(), "x", null));
assertTrue(ex.getMessage().contains("at least 1 element"));
}
@Test
public void runActionThrowsOnMalformedPath() {
final AbstractContainerNode n = activated(Arrays.asList(childWithClickAction()));
final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
() -> n.runAction(new ArrayList<>(Arrays.asList("foo")), "x", null));
assertTrue(ex.getMessage().contains("Invalid path"));
}
@Test
public void runActionThrowsOnOutOfRangeIndex() {
final AbstractContainerNode n = activated(Arrays.asList(childWithClickAction(), childWithClickAction()));
assertThrows(IndexOutOfBoundsException.class,
() -> n.runAction(new ArrayList<>(Arrays.asList("children[99]")), "x", null));
}
@Test
public void runActionDelegatesToIndexedChild() {
// Distinguishable children: children[0] vs children[1] return different sentinels,
// so this proves the index is parsed and routed correctly (not just "some child answered").
final ComponentNode child0 = mock(ComponentNode.class);
when(child0.runAction(any(), any(), any())).thenReturn("from-0");
final ComponentNode child1 = mock(ComponentNode.class);
when(child1.runAction(any(), any(), any())).thenReturn("from-1");
final AbstractContainerNode n = activated(Arrays.asList(child0, child1));
assertEquals("from-0", n.runAction(new ArrayList<>(Arrays.asList("children[0]")), "t", null));
assertEquals("from-1", n.runAction(new ArrayList<>(Arrays.asList("children[1]")), "t", null));
}
}