External events scheduling e2e tests

e2e-tests/src/main/java/gov/nasa/jpl/aerie/e2e/procedural/scheduling/procedures/ExternalEventsQueryGoal.java

@@ -0,0 +1,31 @@
+package gov.nasa.jpl.aerie.e2e.procedural.scheduling.procedures;
+
+import gov.nasa.ammos.aerie.procedural.scheduling.Goal;
+import gov.nasa.ammos.aerie.procedural.scheduling.annotations.SchedulingProcedure;
+import gov.nasa.ammos.aerie.procedural.scheduling.plan.EditablePlan;
+import gov.nasa.ammos.aerie.procedural.timeline.payloads.activities.DirectiveStart;
+import gov.nasa.ammos.aerie.procedural.timeline.plan.EventQuery;
+import gov.nasa.jpl.aerie.merlin.protocol.types.SerializedValue;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.Map;
+
+@SchedulingProcedure
+public record ExternalEventsQueryGoal() implements Goal {
+  @Override
+  public void run(@NotNull final EditablePlan plan) {
+
+    // demonstrate more complicated query functionality
+    EventQuery eventQuery = new EventQuery(
+        List.of("TestGroup", "TestGroup_2"),
+        List.of("TestType"),
+        null
+    );
+
+    for (final var e: plan.events(eventQuery)) {
+      plan.create("BiteBanana", new DirectiveStart.Absolute(e.getInterval().start), Map.of("biteSize", SerializedValue.of(1)));
+    }
+    plan.commit();
+  }
+}

procedural/examples/foo-procedures/src/main/java/gov/nasa/ammos/aerie/procedural/examples/fooprocedures/procedures/ExternalEventsTest.java → e2e-tests/src/main/java/gov/nasa/jpl/aerie/e2e/procedural/scheduling/procedures/ExternalEventsSimpleGoal.java

@@ -1,4 +1,4 @@
-package gov.nasa.ammos.aerie.procedural.examples.fooprocedures.procedures;
+package gov.nasa.jpl.aerie.e2e.procedural.scheduling.procedures;
 
 import gov.nasa.ammos.aerie.procedural.scheduling.annotations.SchedulingProcedure;
 import gov.nasa.ammos.aerie.procedural.scheduling.Goal;
@@ -10,13 +10,12 @@
 import java.util.Map;
 
 @SchedulingProcedure
-public record ExternalEventsTest() implements Goal {
+public record ExternalEventsSimpleGoal() implements Goal {
   @Override
   public void run(@NotNull final EditablePlan plan) {
-    for (final var e: plan.events("Derivation Test Default")) {
+    for (final var e: plan.events("TestGroup")) {
       plan.create("BiteBanana", new DirectiveStart.Absolute(e.getInterval().start), Map.of("biteSize", SerializedValue.of(1)));
     }
-
     plan.commit();
   }
 }

e2e-tests/src/test/java/gov/nasa/jpl/aerie/e2e/procedural/scheduling/ExternalEventsTests.java

@@ -0,0 +1,208 @@
+package gov.nasa.jpl.aerie.e2e.procedural.scheduling;
+
+import gov.nasa.jpl.aerie.e2e.types.GoalInvocationId;
+import gov.nasa.jpl.aerie.e2e.types.Plan;
+import gov.nasa.jpl.aerie.e2e.utils.GatewayRequests;
+import gov.nasa.jpl.aerie.e2e.utils.HasuraRequests;
+import gov.nasa.jpl.aerie.merlin.protocol.types.Duration;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ExternalEventsTests extends ProceduralSchedulingSetup {
+  private GoalInvocationId procedureId;
+  private final static String SOURCE_TYPE = "TestType";
+  private final static String EVENT_TYPE = "TestType";
+  private final static String ADDITIONAL_EVENT_TYPE = EVENT_TYPE + "_2";
+  private final static String DERIVATION_GROUP = "TestGroup";
+  private final static String ADDITIONAL_DERIVATION_GROUP = DERIVATION_GROUP + "_2";
+
+  private final HasuraRequests.ExternalSource externalSource = new HasuraRequests.ExternalSource(
+      "Test.json",
+      SOURCE_TYPE,
+      DERIVATION_GROUP,
+      "2024-01-01T00:00:00Z",
+      "2023-01-01T00:00:00Z",
+      "2023-01-08T00:00:00Z",
+      "2024-10-01T00:00:00Z"
+  );
+  private final List<HasuraRequests.ExternalEvent> externalEvents = List.of(
+      new HasuraRequests.ExternalEvent(
+          "Event_01",
+          EVENT_TYPE,
+          externalSource.key(),
+          externalSource.derivation_group_name(),
+          "2023-01-01T01:00:00Z",
+          "00:10:00"
+      ),
+      new HasuraRequests.ExternalEvent(
+          "Event_02",
+          EVENT_TYPE,
+          externalSource.key(),
+          externalSource.derivation_group_name(),
+          "2023-01-01T03:00:00Z",
+          "00:10:00"
+      ),
+      new HasuraRequests.ExternalEvent(
+          "Event_03",
+          EVENT_TYPE,
+          externalSource.key(),
+          externalSource.derivation_group_name(),
+          "2023-01-01T05:00:00Z",
+          "00:10:00"
+      )
+  );
+
+  private final HasuraRequests.ExternalSource additionalExternalSource = new HasuraRequests.ExternalSource(
+      "NewTest.json",
+      SOURCE_TYPE,
+      ADDITIONAL_DERIVATION_GROUP,
+      "2024-01-02T00:00:00Z",
+      "2023-01-01T00:00:00Z",
+      "2023-01-08T00:00:00Z",
+      "2024-10-01T00:00:00Z"
+  );
+
+  private final List<HasuraRequests.ExternalEvent> additionalExternalEvents = List.of(
+      new HasuraRequests.ExternalEvent(
+          "Event_01",
+          EVENT_TYPE,
+          additionalExternalSource.key(),
+          additionalExternalSource.derivation_group_name(),
+          "2023-01-02T01:00:00Z",
+          "00:10:00"
+      ),
+      new HasuraRequests.ExternalEvent(
+          "Event_02",
+          ADDITIONAL_EVENT_TYPE,
+          additionalExternalSource.key(),
+          additionalExternalSource.derivation_group_name(),
+          "2023-01-02T03:00:00Z",
+          "00:10:00"
+      ),
+      new HasuraRequests.ExternalEvent(
+          "Event_03",
+          ADDITIONAL_EVENT_TYPE,
+          additionalExternalSource.key(),
+          additionalExternalSource.derivation_group_name(),
+          "2023-01-02T05:00:00Z",
+          "00:10:00"
+      )
+  );
+
+  @BeforeEach
+  void localBeforeEach() throws IOException {
+    // Upload some External Events (and associated infrastructure)
+    hasura.insertExternalSourceType(SOURCE_TYPE);
+    hasura.insertExternalEventType(EVENT_TYPE);
+    hasura.insertDerivationGroup(DERIVATION_GROUP, SOURCE_TYPE);
+    hasura.insertExternalSource(externalSource);
+    hasura.insertExternalEvents(externalEvents);
+    hasura.insertPlanDerivationGroupAssociation(planId, DERIVATION_GROUP);
+
+    // Upload additional External Events in a different derivation group and of a different type
+    hasura.insertExternalEventType(ADDITIONAL_EVENT_TYPE);
+    hasura.insertDerivationGroup(ADDITIONAL_DERIVATION_GROUP, SOURCE_TYPE);
+    hasura.insertExternalSource(additionalExternalSource);
+    hasura.insertExternalEvents(additionalExternalEvents);
+    hasura.insertPlanDerivationGroupAssociation(planId, ADDITIONAL_DERIVATION_GROUP);
+  }
+
+  @AfterEach
+  void localAfterEach() throws IOException {
+    hasura.deleteSchedulingGoal(procedureId.goalId());
+
+    // External Event Related
+    hasura.deletePlanDerivationGroupAssociation(planId, DERIVATION_GROUP);
+    hasura.deletePlanDerivationGroupAssociation(planId, ADDITIONAL_DERIVATION_GROUP);
+    hasura.deleteExternalSource(externalSource);
+    hasura.deleteExternalSource(additionalExternalSource);
+    hasura.deleteDerivationGroup(DERIVATION_GROUP);
+    hasura.deleteDerivationGroup(ADDITIONAL_DERIVATION_GROUP);
+    hasura.deleteExternalSourceType(SOURCE_TYPE);
+    hasura.deleteExternalEventType(EVENT_TYPE);
+    hasura.deleteExternalEventType(ADDITIONAL_EVENT_TYPE);
+  }
+
+  @Test
+  void testExternalEventSimple() throws IOException {
+    // first, run the goal
+    try (final var gateway = new GatewayRequests(playwright)) {
+      int procedureJarId = gateway.uploadJarFile("build/libs/ExternalEventsSimpleGoal.jar");
+      // Add Scheduling Procedure
+      procedureId = hasura.createSchedulingSpecProcedure(
+          "Test Scheduling Procedure",
+          procedureJarId,
+          specId,
+          0
+      );
+    }
+    hasura.awaitScheduling(specId);
+    final var plan = hasura.getPlan(planId);
+    final var activities = plan.activityDirectives();
+
+    // ensure the order lines up with the events'
+    activities.sort(Comparator.comparing(Plan.ActivityDirective::startOffset));
+
+    // compare arrays
+    assertEquals(externalEvents.size(), activities.size());
+    for (int i = 0; i < activities.size(); i++) {
+      Instant activityStartTime = Duration.addToInstant(
+          Instant.parse(planStartTimestamp),
+          Duration.fromString(activities.get(i).startOffset())
+      );
+      assertEquals(externalEvents.get(i).start_time(), activityStartTime.toString());
+    }
+  }
+
+  @Test
+  void testExternalEventQuery() throws IOException {
+    // first, run the goal
+    try (final var gateway = new GatewayRequests(playwright)) {
+      int procedureJarId = gateway.uploadJarFile("build/libs/ExternalEventsQueryGoal.jar");
+      // Add Scheduling Procedure
+      procedureId = hasura.createSchedulingSpecProcedure(
+          "Test Scheduling Procedure",
+          procedureJarId,
+          specId,
+          0
+      );
+    }
+    hasura.awaitScheduling(specId);
+    final var plan = hasura.getPlan(planId);
+    final var activities = plan.activityDirectives();
+
+    // ensure the orderings line up
+    activities.sort(Comparator.comparing(Plan.ActivityDirective::startOffset));
+
+    // get the set of events we expect (anything in TestGroup or TestGroup_2, and of type TestType)
+    List<HasuraRequests.ExternalEvent> expected = new ArrayList<>();
+    expected.addAll(externalEvents);
+    expected.addAll(
+        additionalExternalEvents.stream()
+                                .filter(e -> e.event_type_name().equals(EVENT_TYPE))
+                                .toList()
+    );
+
+    // explicitly ensure the orderings line up
+    expected.sort(Comparator.comparing(HasuraRequests.ExternalEvent::start_time));
+
+    // compare arrays
+    assertEquals(expected.size(), activities.size());
+    for (int i = 0; i < activities.size(); i++) {
+      Instant activityStartTime = Duration.addToInstant(
+          Instant.parse(planStartTimestamp),
+          Duration.fromString(activities.get(i).startOffset())
+      );
+      assertEquals(activityStartTime.toString(), expected.get(i).start_time());
+    }
+  }
+}

e2e-tests/src/test/java/gov/nasa/jpl/aerie/e2e/utils/GQL.java

@@ -82,6 +82,38 @@ mutation CreateActivityDirective($activityDirectiveInsertInput: activity_directi
         id
       }
     }"""),
+  CREATE_EXTERNAL_EVENT_TYPE("""
+    mutation CreateExternalEventType($eventType: external_event_type_insert_input!) {
+      createExternalEventType: insert_external_event_type_one(object: $eventType) {
+        name
+      }
+    }"""),
+  CREATE_EXTERNAL_EVENTS("""
+    mutation InsertExternalEvents($objects: [external_event_insert_input!]!) {
+      insertExternalEvents: insert_external_event(objects: $objects) {
+        returning {
+           key
+        }
+      }
+    }"""),
+  CREATE_EXTERNAL_SOURCE("""
+    mutation InsertExternalSource($object: external_source_insert_input!) {
+      insertExternalSource: insert_external_source_one(object: $object) {
+        key
+      }
+    }"""),
+  CREATE_EXTERNAL_SOURCE_TYPE("""
+    mutation CreateExternalSourceType($sourceType: external_source_type_insert_input!) {
+      createExternalSourceType: insert_external_source_type_one(object: $sourceType) {
+        name
+      }
+    }"""),
+  CREATE_DERIVATION_GROUP("""
+    mutation CreateDerivationGroup($derivationGroup: derivation_group_insert_input!) {
+      createDerivationGroup: insert_derivation_group_one(object: $derivationGroup) {
+        name
+      }
+    }"""),
   CREATE_MISSION_MODEL("""
     mutation CreateMissionModel($model: mission_model_insert_input!) {
       insert_mission_model_one(object: $model) {
@@ -95,6 +127,12 @@ mutation CreatePlan($plan: plan_insert_input!) {
         revision
       }
     }"""),
+  CREATE_PLAN_DERIVATION_GROUP("""
+    mutation CreatePlanDerivationGroup($source: plan_derivation_group_insert_input!) {
+      planExternalSourceLink: insert_plan_derivation_group_one(object: $source) {
+        derivation_group_name
+      }
+    }"""),
   CREATE_SCHEDULING_SPEC_GOAL("""
     mutation CreateSchedulingSpecGoal($spec_goal: scheduling_specification_goals_insert_input!) {
       insert_scheduling_specification_goals_one(object: $spec_goal) {
@@ -140,12 +178,38 @@ mutation DeleteConstraint($id: Int!) {
         id
       }
     }"""),
+  DELETE_DERIVATION_GROUP("""
+    mutation DeleteDerivationGroup($name: String!) {
+      deleteDerivationGroup: delete_derivation_group(where: { name: { _eq: $name } }) {
+        returning {
+          name
+        }
+      }
+    }"""),
   DELETE_EXTERNAL_DATASET("""
     mutation deleteExtProfile($plan_id: Int!, $dataset_id: Int!) {
       delete_plan_dataset_by_pk(plan_id:$plan_id, dataset_id:$dataset_id) {
         dataset_id
       }
     }"""),
+  DELETE_EXTERNAL_EVENT_TYPE("""
+    mutation DeleteExternalEventType($name: String!) {
+      deleteExternalEventType: delete_external_event_type_by_pk(name: $name) {
+        name
+      }
+    }"""),
+  DELETE_EXTERNAL_SOURCE("""
+    mutation DeleteExternalSource($derivationGroupName: String!, $sourceKey: String!) {
+      deleteExternalSource: delete_external_source_by_pk(derivation_group_name: $derivationGroupName, key: $sourceKey) {
+        key
+      }
+    }"""),
+  DELETE_EXTERNAL_SOURCE_TYPE("""
+    mutation DeleteExternalSourceType($name: String!) {
+      deleteExternalSourceType: delete_external_source_type_by_pk(name: $name) {
+        name
+      }
+    }"""),
   DELETE_MISSION_MODEL("""
     mutation DeleteModel($id: Int!) {
       delete_mission_model_by_pk(id: $id) {
@@ -174,6 +238,12 @@ mutation DeletePlan($id: Int!) {
         }
       }
     }"""),
+  DELETE_PLAN_DERIVATION_GROUP("""
+    mutation DeletePlanExternalSource($derivationGroupName: String!, $planId: Int!) {
+      planDerivationGroupLink: delete_plan_derivation_group_by_pk(derivation_group_name: $derivationGroupName, plan_id: $planId) {
+        derivation_group_name
+      }
+    }"""),
   DELETE_SCHEDULING_GOAL("""
     mutation DeleteSchedulingGoal($goalId: Int!) {
       delete_scheduling_specification_goals(where: {goal_id: {_eq: $goalId}}){