11 remaining test cases

Author: kuhe

packages/core/src/submodules/cbor/cbor.spec.ts

@@ -176,9 +176,15 @@ describe("cbor", () => {
       const bytes = toBytes(input);
       const jsObject = translateTestData(_expect);
 
-      xit(`serialization for ${description}`, () => {
+      it(`serialization for ${description}`, () => {
         const serialized = cbor.serialize(jsObject);
-        expect(serialized).toEqual(bytes);
+        const redeserialized = cbor.deserialize(serialized);
+        /**
+         * We cannot assert that serialized == bytes,
+         * because there are multiple serializations
+         * that deserialize to the same object.
+         */
+        expect(redeserialized).toEqual(jsObject);
       });
       it(`deserialization for ${description}`, () => {
         const deserialized = cbor.deserialize(bytes);

packages/core/src/submodules/cbor/cbor.ts

@@ -10,12 +10,18 @@ import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
 /**
  *
  */
-type CborItemType = undefined | boolean | number | [CborSliceType, Uint64Imprecise] | string | CborTagType;
+type CborItemType =
+  | undefined
+  | boolean
+  | number
+  | [CborUnstructuredByteStringType, Uint64Imprecise]
+  | string
+  | CborTagType;
 type CborTagType = {
   tag: Uint64Imprecise;
   value: CborValueType;
 };
-type CborSliceType = Uint8Array;
+type CborUnstructuredByteStringType = Uint8Array;
 type CborListType<T = any> = Array<T>;
 type CborMapType<T = any> = Record<string, T>;
 type CborCollectionType<T = any> = CborMapType<T> | CborListType<T>;
@@ -174,38 +180,43 @@ const decodeNegativeInt = (payload: Uint8Array): [Uint64Imprecise, CborArgumentL
   return [-1 - i, offset];
 };
 
+const decodeUnstructuredByteString = (payload: Uint8Array): [CborUnstructuredByteStringType, CborOffset] => {
+  return decodeString(payload, majorUnstructuredByteString);
+};
+
+const decodeUtf8String = (payload: Uint8Array): [string, CborOffset] => {
+  return decodeString(payload, majorUtf8String);
+};
+
 const decodeString = <M extends typeof majorUtf8String | typeof majorUnstructuredByteString>(
   payload: Uint8Array,
   inner: M
-): [M extends typeof majorUtf8String ? string : CborSliceType, CborOffset] => {
+): [M extends typeof majorUtf8String ? string : CborUnstructuredByteStringType, CborOffset] => {
   const minor = peekMinor(payload);
+
   if (minor === minorIndefinite) {
-    return decodeUnstructuredByteStringIndefinite(payload) as [
-      M extends typeof majorUtf8String ? string : CborSliceType,
+    const [decoded, offset] = decodeStringIndefinite(payload, inner);
+    return (inner === majorUnstructuredByteString ? [decoded, offset] : [toUtf8(decoded), offset]) as [
+      M extends typeof majorUtf8String ? string : CborUnstructuredByteStringType,
       CborOffset,
     ];
   }
 
   const [length, offset] = decodeArgument(payload);
   payload = payload.subarray(offset);
   if (payload.length < length) {
-    throw new Error(`slice len ${length} greater than remaining buf len.`);
+    throw new Error(`unstructured byte string len ${length} greater than remaining buf len.`);
   }
 
   const value =
     inner === majorUnstructuredByteString ? payload.subarray(0, length) : toUtf8(payload.subarray(0, length));
-  return [value as M extends typeof majorUtf8String ? string : CborSliceType, offset + length];
+  return [value as M extends typeof majorUtf8String ? string : CborUnstructuredByteStringType, offset + length];
 };
 
-const decodeUnstructuredByteString = (payload: Uint8Array): [CborSliceType, CborOffset] => {
-  return decodeString(payload, majorUnstructuredByteString);
-};
-
-const decodeUtf8String = (payload: Uint8Array): [string, CborOffset] => {
-  return decodeString(payload, majorUtf8String);
-};
-
-const decodeUnstructuredByteStringIndefinite = (payload: Uint8Array): [CborSliceType, CborOffset] => {
+const decodeStringIndefinite = <I extends typeof majorUtf8String | typeof majorUnstructuredByteString>(
+  payload: Uint8Array,
+  inner: I
+): [CborUnstructuredByteStringType, CborOffset] => {
   payload = payload.subarray(1);
 
   const buffer = [];
@@ -217,18 +228,24 @@ const decodeUnstructuredByteStringIndefinite = (payload: Uint8Array): [CborSlice
 
     const major = peekMajor(payload);
     const minor = peekMinor(payload);
-    if (major !== majorUnstructuredByteString) {
-      throw new Error(`unexpected major type ${major} in indefinite slice.`);
+    if (major !== inner) {
+      throw new Error(`unexpected major type ${major} in indefinite string.`);
     }
     if (minor === minorIndefinite) {
-      throw new Error("nested indefinite slice.");
+      throw new Error("nested indefinite string.");
     }
 
-    const [byteString, length] = decodeUnstructuredByteString(payload);
-    payload = payload.subarray(length);
-
-    buffer.push(byteString);
-    offset += length;
+    if (inner === majorUtf8String) {
+      const [str, length] = decodeUtf8String(payload);
+      payload = payload.subarray(length);
+      buffer.push(fromUtf8(str));
+      offset += length;
+    } else {
+      const [byteString, length] = decodeUnstructuredByteString(payload);
+      payload = payload.subarray(length);
+      buffer.push(byteString);
+      offset += length;
+    }
   }
   throw new Error("expected break marker.");
 };
@@ -530,6 +547,11 @@ const encode = (input: any, buffer: Uint8Array): CborOffset => {
       offset += encode(vv, buffer.subarray(offset));
     }
     return offset;
+  } else if (input instanceof Uint8Array) {
+    // serialize as UnstructuredByteString
+    const offset = encodeHeader(majorUnstructuredByteString, input.length, buffer);
+    buffer.subarray(offset).set(input);
+    return offset + input.length;
   } else if (typeof input === "object") {
     const entries = Object.entries(input).filter(([, v]) => {
       return v !== undefined;