@hla4ts/spacekit 0.1.0

package/src/declarative-runtime.test.ts

@@ -0,0 +1,271 @@
+import { expect, test } from "bun:test";
+import type {
+  AttributeHandle,
+  AttributeHandleSet,
+  InteractionClassHandle,
+  ObjectClassHandle,
+  ParameterHandle,
+  RTIAmbassador,
+} from "@hla4ts/hla-api";
+import { DeclarativeFom } from "./declarative.ts";
+import { DeclarativeRuntime } from "./declarative-runtime.ts";
+
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+
+function encodeString(value: string): Uint8Array {
+  return textEncoder.encode(value);
+}
+
+function decodeString(value: Uint8Array): string {
+  return textDecoder.decode(value);
+}
+
+function encodeInt32(value: number): Uint8Array {
+  const buffer = new ArrayBuffer(4);
+  new DataView(buffer).setInt32(0, value, false);
+  return new Uint8Array(buffer);
+}
+
+function decodeInt32(value: Uint8Array): number {
+  return new DataView(value.buffer, value.byteOffset, value.byteLength).getInt32(0, false);
+}
+
+class MockRti implements Partial<RTIAmbassador> {
+  private readonly _objectClassHandles = new Map<string, ObjectClassHandle>();
+  private readonly _interactionClassHandles = new Map<string, InteractionClassHandle>();
+  private readonly _objectClassNamesByHandle = new Map<string, string>();
+  private readonly _interactionClassNamesByHandle = new Map<string, string>();
+  private readonly _attributeHandles = new Map<string, AttributeHandle>();
+  private readonly _parameterHandles = new Map<string, ParameterHandle>();
+
+  readonly publishedObjectAttributes: Array<{ className: string; attributes: AttributeHandleSet }> = [];
+  readonly subscribedObjectAttributes: Array<{ className: string; attributes: AttributeHandleSet }> = [];
+  readonly publishedInteractions: string[] = [];
+  readonly subscribedInteractions: string[] = [];
+
+  private _handleKey(handle: Uint8Array): string {
+    return Array.from(handle)
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join("");
+  }
+
+  private _makeHandle(label: string): Uint8Array {
+    return textEncoder.encode(label);
+  }
+
+  async getObjectClassHandle(objectClassName: string): Promise<ObjectClassHandle> {
+    const existing = this._objectClassHandles.get(objectClassName);
+    if (existing) return existing;
+    const handle = this._makeHandle(`class:${objectClassName}`);
+    this._objectClassHandles.set(objectClassName, handle);
+    this._objectClassNamesByHandle.set(this._handleKey(handle), objectClassName);
+    return handle;
+  }
+
+  async getInteractionClassHandle(interactionClassName: string): Promise<InteractionClassHandle> {
+    const existing = this._interactionClassHandles.get(interactionClassName);
+    if (existing) return existing;
+    const handle = this._makeHandle(`interaction:${interactionClassName}`);
+    this._interactionClassHandles.set(interactionClassName, handle);
+    this._interactionClassNamesByHandle.set(this._handleKey(handle), interactionClassName);
+    return handle;
+  }
+
+  async getAttributeHandle(
+    objectClass: ObjectClassHandle,
+    attributeName: string
+  ): Promise<AttributeHandle> {
+    const className = this._objectClassNamesByHandle.get(this._handleKey(objectClass));
+    if (!className) {
+      throw new Error("Unknown object class handle.");
+    }
+    const key = `${className}:${attributeName}`;
+    const existing = this._attributeHandles.get(key);
+    if (existing) return existing;
+    const handle = this._makeHandle(`attr:${key}`);
+    this._attributeHandles.set(key, handle);
+    return handle;
+  }
+
+  async getParameterHandle(
+    interactionClass: InteractionClassHandle,
+    parameterName: string
+  ): Promise<ParameterHandle> {
+    const className = this._interactionClassNamesByHandle.get(this._handleKey(interactionClass));
+    if (!className) {
+      throw new Error("Unknown interaction class handle.");
+    }
+    const key = `${className}:${parameterName}`;
+    const existing = this._parameterHandles.get(key);
+    if (existing) return existing;
+    const handle = this._makeHandle(`param:${key}`);
+    this._parameterHandles.set(key, handle);
+    return handle;
+  }
+
+  async publishObjectClassAttributes(
+    objectClass: ObjectClassHandle,
+    attributes: AttributeHandleSet
+  ): Promise<void> {
+    const name = this._objectClassNamesByHandle.get(this._handleKey(objectClass)) ?? "unknown";
+    this.publishedObjectAttributes.push({ className: name, attributes });
+  }
+
+  async subscribeObjectClassAttributes(
+    objectClass: ObjectClassHandle,
+    attributes: AttributeHandleSet
+  ): Promise<void> {
+    const name = this._objectClassNamesByHandle.get(this._handleKey(objectClass)) ?? "unknown";
+    this.subscribedObjectAttributes.push({ className: name, attributes });
+  }
+
+  async publishInteractionClass(interactionClass: InteractionClassHandle): Promise<void> {
+    const name = this._interactionClassNamesByHandle.get(this._handleKey(interactionClass)) ?? "unknown";
+    this.publishedInteractions.push(name);
+  }
+
+  async subscribeInteractionClass(interactionClass: InteractionClassHandle): Promise<void> {
+    const name = this._interactionClassNamesByHandle.get(this._handleKey(interactionClass)) ?? "unknown";
+    this.subscribedInteractions.push(name);
+  }
+}
+
+test("DeclarativeRuntime wires handlers and pub/sub based on sharing", async () => {
+  const declarative = new DeclarativeFom();
+  const entityAdapter = declarative.defineObjectClass<{ name: string; value: number; state: string }>(
+    {
+      name: "HLAobjectRoot.TestEntity",
+      sharing: "PublishSubscribe",
+      attributes: {
+        name: {
+          name: "name",
+          dataType: "HLAunicodeString",
+          updateType: "Static",
+          updateCondition: "during initialization",
+          ownership: "NoTransfer",
+          sharing: "Publish",
+          transportation: "HLAreliable",
+          order: "TimeStamp",
+          encode: encodeString,
+          decode: decodeString,
+        },
+        value: {
+          name: "value",
+          dataType: "HLAinteger32BE",
+          updateType: "Periodic",
+          updateCondition: "when changes",
+          ownership: "DivestAcquire",
+          sharing: "Subscribe",
+          transportation: "HLAreliable",
+          order: "TimeStamp",
+          encode: encodeInt32,
+          decode: decodeInt32,
+        },
+        state: {
+          name: "state",
+          dataType: "HLAunicodeString",
+          updateType: "Conditional",
+          updateCondition: "when changes",
+          ownership: "DivestAcquire",
+          sharing: "PublishSubscribe",
+          transportation: "HLAreliable",
+          order: "TimeStamp",
+          encode: encodeString,
+          decode: decodeString,
+        },
+      },
+    }
+  );
+
+  const interactionAdapter = declarative.defineInteractionClass<{ message: string }>({
+    name: "HLAinteractionRoot.TestInteraction",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "Receive",
+    parameters: {
+      message: {
+        name: "message",
+        dataType: "HLAunicodeString",
+        encode: encodeString,
+        decode: decodeString,
+      },
+    },
+  });
+
+  const runtime = new DeclarativeRuntime(declarative);
+  const mockRti = new MockRti();
+  const rti = mockRti as unknown as RTIAmbassador;
+
+  let discoveredName: string | undefined;
+  let updateValues: Record<string, unknown> | undefined;
+  let interactionMessage: string | undefined;
+
+  runtime.registerObjectHandlers(entityAdapter, {
+    discover: ({ instance }) => {
+      discoveredName = instance.objectInstanceName;
+    },
+    update: ({ values }) => {
+      updateValues = values as Record<string, unknown>;
+    },
+  });
+
+  runtime.registerInteractionHandlers(interactionAdapter, {
+    receive: ({ values }) => {
+      interactionMessage = values.message as string;
+    },
+  });
+
+  await runtime.prepare(rti);
+
+  expect(mockRti.publishedObjectAttributes).toHaveLength(1);
+  expect(mockRti.subscribedObjectAttributes).toHaveLength(1);
+  expect(mockRti.publishedInteractions).toEqual(["HLAinteractionRoot.TestInteraction"]);
+  expect(mockRti.subscribedInteractions).toEqual(["HLAinteractionRoot.TestInteraction"]);
+
+  const publishedHandles = mockRti.publishedObjectAttributes[0]?.attributes ?? [];
+  const subscribedHandles = mockRti.subscribedObjectAttributes[0]?.attributes ?? [];
+
+  const nameHandle = entityAdapter.getAttributeHandle("name");
+  const valueHandle = entityAdapter.getAttributeHandle("value");
+  const stateHandle = entityAdapter.getAttributeHandle("state");
+
+  expect(publishedHandles).toContainEqual(nameHandle);
+  expect(publishedHandles).toContainEqual(stateHandle);
+  expect(publishedHandles).not.toContainEqual(valueHandle);
+  expect(subscribedHandles).toContainEqual(valueHandle);
+  expect(subscribedHandles).toContainEqual(stateHandle);
+  expect(subscribedHandles).not.toContainEqual(nameHandle);
+
+  const objectInstance = new Uint8Array([1]);
+  runtime.handlers.discoverObjectInstance?.(
+    objectInstance,
+    entityAdapter.classHandle,
+    "TestEntity-1",
+    new Uint8Array([9])
+  );
+
+  expect(discoveredName).toBe("TestEntity-1");
+
+  const updates = entityAdapter.encode({ name: "Alpha", value: 42, state: "OK" });
+  runtime.handlers.reflectAttributeValues?.(
+    objectInstance,
+    updates,
+    new Uint8Array(),
+    new Uint8Array(),
+    new Uint8Array([9])
+  );
+
+  expect(updateValues).toEqual({ name: "Alpha", value: 42, state: "OK" });
+
+  const interactionValues = interactionAdapter.encode({ message: "Hello" });
+  runtime.handlers.receiveInteraction?.(
+    interactionAdapter.interactionHandle,
+    interactionValues,
+    new Uint8Array(),
+    new Uint8Array(),
+    new Uint8Array([9])
+  );
+
+  expect(interactionMessage).toBe("Hello");
+});