(texera) 02/02: test(frontend): add unit tests for serializePortIdentity (#6938)

[gi...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

github-merge-queue[bot] pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/texera.git

commit 06f8e42dfb2186ea722614ea1140e457d3e80b32
Author: Ranjani Veena Belavadi <16...@users.noreply.github.com>
AuthorDate: Tue Jul 28 16:34:32 2026 -0700

    test(frontend): add unit tests for serializePortIdentity (#6938)
    
    ### What changes were proposed in this PR?
    Adds `port-identity-serde.spec.ts` to cover `serializePortIdentity`, a
    previously untested pure utility function in `common/util/` that
    serializes a `PortIdentity` into the stable string key `id_internal`.
    
    This format is one half of a cross-language contract: the backend
    produces the identical string in
    `PortIdentityKeySerializer.portIdToString` and reads it back by
    splitting on `"_"` in `PortIdentityKeyDeserializer`. A format mismatch
    on either side would cause the frontend's schema lookup to silently
    return `undefined` rather than fail, so the exact output is worth
    pinning.
    
    Covers four groups of behavior:
    
    - **Format**: exact key for external and internal ports, including the
    `id: 0` falsy-number boundary and large and negative ids passing through
    unvalidated. These mirror `PortIdentityKeySerializerSpec.scala`'s case
    table exactly, so both ends of the contract are now pinned by matching
    assertions.
    - **Distinctness**: ports differing only by `id`, or only by `internal`,
    cannot collide on the same key.
    - **Stability**: equal inputs always serialize identically.
    - **Real usage**: the key works for object lookup when generated
    independently at write and read time, and remains splittable into
    exactly two fields for the backend deserializer.
    
    No production code was changed.
    
    
    ### Any related issues, documentation, discussions?
    Closes #6631
    
    
    ### How was this PR tested?
    Added 12 new unit tests in `port-identity-serde.spec.ts` covering all
    behavior described in the issue. Ran locally via `ng test --include
    src/app/common/util/port-identity-serde.spec.ts --watch=false`; all 12
    pass. Full suite also green via `yarn test` (3817 passed, 2 skipped, 198
    files).
    
    
    ### Was this PR authored or co-authored using generative AI tooling?
    Generated-by: Claude Code (Claude Opus 4.8)
    
    Co-authored-by: Yicong Huang <17...@users.noreply.github.com>
---
 .../app/common/util/port-identity-serde.spec.ts    | 80 ++++++++++++++++++++++
 1 file changed, 80 insertions(+)

diff --git a/frontend/src/app/common/util/port-identity-serde.spec.ts b/frontend/src/app/common/util/port-identity-serde.spec.ts
new file mode 100644
index 0000000000..b11b27d4db
--- /dev/null
+++ b/frontend/src/app/common/util/port-identity-serde.spec.ts
@@ -0,0 +1,80 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { serializePortIdentity } from "./port-identity-serde";
+import { PortIdentity } from "../type/proto/org/apache/texera/amber/core/workflow";
+
+describe("serializePortIdentity", () => {
+  it("should serialize an external port as id_internal", () => {
+    expect(serializePortIdentity({ id: 3, internal: false })).toBe("3_false");
+  });
+
+  it("should serialize an internal port", () => {
+    expect(serializePortIdentity({ id: 0, internal: true })).toBe("0_true");
+  });
+
+  it("should serialize port id zero", () => {
+    expect(serializePortIdentity({ id: 0, internal: false })).toBe("0_false");
+  });
+
+  it("should serialize a large multi-digit port id", () => {
+    expect(serializePortIdentity({ id: 999999, internal: false })).toBe("999999_false");
+  });
+
+  it("should serialize a large multi-digit internal port id", () => {
+    expect(serializePortIdentity({ id: 999999, internal: true })).toBe("999999_true");
+  });
+
+  it("should pass a negative port id through without validation", () => {
+    expect(serializePortIdentity({ id: -1, internal: false })).toBe("-1_false");
+  });
+
+  it("should pass a negative internal port id through without validation", () => {
+    expect(serializePortIdentity({ id: -1, internal: true })).toBe("-1_true");
+  });
+
+  it("should produce different keys for internal and external ports with the same id", () => {
+    expect(serializePortIdentity({ id: 0, internal: true })).not.toBe(
+      serializePortIdentity({ id: 0, internal: false })
+    );
+  });
+
+  it("should produce different keys for different ids", () => {
+    expect(serializePortIdentity({ id: 0, internal: false })).not.toBe(
+      serializePortIdentity({ id: 1, internal: false })
+    );
+  });
+
+  it("should be deterministic for equal inputs", () => {
+    const first: PortIdentity = { id: 5, internal: true };
+    const second: PortIdentity = { id: 5, internal: true };
+    expect(serializePortIdentity(first)).toBe(serializePortIdentity(second));
+  });
+
+  it("should work as an object key for schema lookup", () => {
+    const key = serializePortIdentity({ id: 1, internal: false });
+    const schemaByPort: Record<string, string> = { [key]: "my-schema" };
+    const lookupKey = serializePortIdentity({ id: 1, internal: false });
+    expect(schemaByPort[lookupKey]).toBe("my-schema");
+  });
+
+  it("should stay parseable by the backend deserializer format", () => {
+    expect(serializePortIdentity({ id: 3, internal: false }).split("_")).toEqual(["3", "false"]);
+  });
+});