@dcl/sdk 7.1.4-4578951400.commit-3810356 → 7.1.4-4598967522.commit-538c49d

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@dcl/sdk",
   "description": "",
-  "version": "7.1.4-4578951400.commit-3810356",
+  "version": "7.1.4-4598967522.commit-538c49d",
   "author": "Decentraland",
   "dependencies": {
-    "@dcl/ecs": "7.1.4-4578951400.commit-3810356",
+    "@dcl/ecs": "7.1.4-4598967522.commit-538c49d",
     "@dcl/ecs-math": "2.0.1-20221129185242.commit-40495c1",
     "@dcl/explorer": "1.0.92953-20230320185045.commit-aed694a",
-    "@dcl/js-runtime": "7.1.4-4578951400.commit-3810356",
-    "@dcl/react-ecs": "7.1.4-4578951400.commit-3810356",
-    "@dcl/sdk-commands": "7.1.4-4578951400.commit-3810356"
+    "@dcl/js-runtime": "7.1.4-4598967522.commit-538c49d",
+    "@dcl/react-ecs": "7.1.4-4598967522.commit-538c49d",
+    "@dcl/sdk-commands": "7.1.4-4598967522.commit-538c49d"
   },
   "keywords": [],
   "license": "Apache-2.0",
@@ -30,5 +30,5 @@
   },
   "types": "./index.d.ts",
   "typings": "./index.d.ts",
-  "commit": "3810356217029030ea170aba0c9e95f43a422252"
+  "commit": "538c49d420ba1bf75ad9e6d821aec3c4afe26c69"
 }

package/src/testing/assert.ts

@@ -0,0 +1,134 @@
+// VERBATIM COPY OF https://github.com/LemonPi/deep-close-to
+
+import type { Entity, LastWriteWinElementSetComponentDefinition } from '@dcl/ecs'
+
+const pSlice = Array.prototype.slice
+
+const floatEpsilon = 0.0000001
+
+type Options = { strict: boolean; comp: typeof closeTo }
+
+export function assertEquals(a: any, b: any, message: string = 'Values are not equal') {
+  if (!deepCloseTo(a, b)) throw new Error(`${message} - ${JSON.stringify(a)} != ${JSON.stringify(b)}`)
+}
+
+export function assert(a: any, message: string = 'assertion failed') {
+  if (!a) throw new Error(message)
+}
+
+export function assertComponentValue<T>(
+  entity: Entity,
+  component: LastWriteWinElementSetComponentDefinition<T>,
+  value: T
+) {
+  assert(component.has(entity), `The entity doesn't have a ${component.componentName} component`)
+  assertEquals(component.get(entity)!, value, `Invalid ${component.componentName} values`)
+}
+
+export function deepCloseTo(actual: any, expected: any, options: Partial<Options> = {}): boolean {
+  const opts = Object.assign({}, { comp: closeTo }, options)
+  // 7.1. All identical values are equivalent, as determined by ===.
+  if (actual === expected) {
+    return true
+  } else if (actual instanceof Date && expected instanceof Date) {
+    return opts.comp!(actual, expected)
+
+    // 7.3. Other pairs that do not both pass typeof value == 'object',
+    // equivalence is determined by ==.
+  } else if (!actual || !expected || (typeof actual !== 'object' && typeof expected !== 'object')) {
+    if (opts.strict) {
+      if (!actual && !expected) {
+        return actual === expected
+      }
+
+      if (typeof actual !== typeof expected) {
+        return false
+      }
+    }
+    if (!actual && !expected) {
+      return actual === expected
+    }
+    return opts.comp!(actual, expected)
+
+    // 7.4. For all other Object pairs, including Array objects, equivalence is
+    // determined by having the same number of owned properties (as verified
+    // with Object.prototype.hasOwnProperty.call), the same set of keys
+    // (although not necessarily the same order), equivalent values for every
+    // corresponding key, and an identical 'prototype' property. Note: this
+    // accounts for both named and indexed properties on Arrays.
+  } else {
+    return objEquiv(actual, expected, opts as any)
+  }
+}
+
+function isUndefinedOrNull(value: any) {
+  return value === null || value === undefined
+}
+
+function isBuffer(x: any) {
+  if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false
+  if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {
+    return false
+  }
+  if (x.length > 0 && typeof x[0] !== 'number') return false
+  return true
+}
+
+function objEquiv(a: any, b: any, opts: Options) {
+  let i, key
+  if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) return false
+  // an identical 'prototype' property.
+  if (a.prototype !== b.prototype) return false
+  //~~~I've managed to break Object.keys through screwy arguments passing.
+  //   Converting to array solves the problem.
+  if (isArguments(a)) {
+    if (!isArguments(b)) {
+      return false
+    }
+    return deepCloseTo(pSlice.call(a), pSlice.call(b), opts)
+  }
+  if (isBuffer(a)) {
+    if (!isBuffer(b)) {
+      return false
+    }
+    if (a.length !== b.length) return false
+    for (i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false
+    }
+    return true
+  }
+
+  try {
+    const ka = Object.keys(a)
+    const kb = Object.keys(b)
+
+    // having the same number of owned properties (keys incorporates
+    // hasOwnProperty)
+    if (ka.length !== kb.length) return false
+    //the same set of keys (although not necessarily the same order),
+    ka.sort()
+    kb.sort()
+    //~~~cheap key test
+    for (i = ka.length - 1; i >= 0; i--) {
+      if (ka[i] !== kb[i]) return false
+    }
+    //equivalent values for every corresponding key, and
+    //~~~possibly expensive deep test
+    for (i = ka.length - 1; i >= 0; i--) {
+      key = ka[i]
+      if (!deepCloseTo(a[key], b[key], opts)) return false
+    }
+  } catch (e) {
+    //happens when one is a string literal and the other isn't
+    return false
+  }
+
+  return typeof a === typeof b
+}
+
+function isArguments(object: any) {
+  return Object.prototype.toString.call(object) === '[object Arguments]'
+}
+function closeTo(actual: any, expected: any, delta: number = floatEpsilon) {
+  return Math.abs(actual - expected) < delta
+}

package/src/testing/index.ts

@@ -0,0 +1,42 @@
+import { engine } from '@dcl/ecs'
+import { createTestRuntime } from './runtime'
+import { TestDefinitionFunction, TestingModule } from './types'
+
+declare let require: any
+
+/**
+ * In development builds, this function serves as test runner for automated test scenarios
+ * if the runtime accepts the `~system/Testing` module
+ * @public
+ */
+/* @__PURE__ */
+export const test: TestDefinitionFunction = DEBUG ? /* @__PURE__ */ createTestFunction() : /* @__PURE__ */ () => {}
+
+function createTestFunction() {
+  let testingModule: TestingModule
+  try {
+    testingModule = /* @__PURE__ */ require('~system/Testing')
+  } catch (err) {
+    console.error(err)
+
+    console.error(`🔴🚨‼️ WARNING: The test runner is not available. The test runner will be mocked. ‼️🚨🔴`)
+
+    testingModule = {
+      async logTestResult(data) {
+        console.log(`🧪 mocked '~system/Testing'.logResult`, data)
+        return {}
+      },
+      async plan(data) {
+        console.log(`🧪 mocked '~system/Testing'.plan`, data)
+        return {}
+      },
+      async setCameraTransform(transform) {
+        console.log(`🧪 mocked '~system/Testing'.setCameraTransform`, transform)
+        return {}
+      }
+    }
+  }
+
+  const runtime = createTestRuntime(testingModule, engine)
+  return runtime.test
+}

package/src/testing/runtime.ts

@@ -0,0 +1,223 @@
+/**
+ * This module provides a createTestRuntime function that returns an object with a test function that can be used to define tests.
+ */
+
+import { IEngine, Transform } from '@dcl/ecs'
+import { assertEquals } from './assert'
+import type { TestingModule, TestFunction, TestHelpers } from './types'
+
+// This function creates a test runtime that can be used to define and run tests.
+// It takes a `TestingModule` instance (loaded from require('~system/Testing')) and an `IEngine` instance (from Decentraland's SDK).
+// It returns an object with a `test` function that can be used to define tests.
+/* @__PURE__ */
+export function createTestRuntime(testingModule: TestingModule, engine: IEngine) {
+  type TestPlanEntry = { name: string; fn: TestFunction }
+  type RunnerEnvironment = {
+    resolve: () => void
+    reject: (error: any) => void
+    helpers: TestHelpers
+    generator: Generator
+  }
+
+  // this flag ensures no tests are added asynchronously
+  let runtimeFrozen = false
+
+  let currentFrameCounter = 0
+  let currentFrameTime = 0
+
+  // array to hold the scheduled tests
+  const scheduledTests: TestPlanEntry[] = []
+
+  // an array of promises that are resolved on the next frame (after the current frame is finished)
+  const nextTickFuture: Array<(dt: number) => void> = []
+
+  // this function returns a promise that resolves on the next frame
+  async function nextTick() {
+    return new Promise<number>((resolve) => {
+      nextTickFuture.push(resolve)
+    })
+  }
+
+  // add a system to the engine that resolves all promises in the `nextTickFuture` array
+  engine.addSystem(function TestingFrameworkCoroutineRunner(dt) {
+    currentFrameCounter++
+    currentFrameTime += dt
+    // resolve all nextTick futures.
+    nextTickFuture.splice(0, nextTickFuture.length).forEach((_) => _(dt))
+  })
+
+  // this function schedules a value to be processed on the next frame, the test runner will
+  // continue to run until it reaches a yield point
+  function scheduleValue(value: any, env: RunnerEnvironment) {
+    if (value && typeof value === 'object' && typeof value.then === 'function') {
+      console.log('⏱️ yield promise')
+      // if the value is a promise, schedule it to be awaited after the current frame is finished
+      nextTickFuture.push(async () => {
+        try {
+          scheduleValue(await value, env)
+        } catch (err) {
+          env.reject(err)
+        }
+      })
+    } else if (typeof value === 'function') {
+      console.log('⏱️ yield function')
+      // if the value is a function, schedule it to be called on the next frame
+      nextTickFuture.push(() => {
+        scheduleValue(value(), env)
+      })
+      return
+    } else if (typeof value === 'undefined' || value === null) {
+      console.log('⏱️ yield')
+      // if the value is undefined or null, continue processing the generator the next frame
+      nextTickFuture.push(() => {
+        consumeGenerator(env)
+      })
+    } else throw new Error(`Unexpected value from test generator: ${value}`)
+  }
+
+  // this function processes a generator function by scheduling its values to be processed on the next frame
+  function consumeGenerator(env: RunnerEnvironment) {
+    try {
+      const ret = env.generator.next()
+      if (!ret.done) {
+        scheduleValue(ret.value, env)
+      } else {
+        env.resolve()
+      }
+    } catch (err) {
+      env.reject(err)
+    }
+  }
+
+  // this function schedules a test run on the next frame
+  function scheduleNextRun() {
+    if (scheduledTests.length) {
+      nextTickFuture.push(runTests)
+    }
+  }
+
+  // this function runs the scheduled tests
+  function runTests() {
+    if (scheduledTests.length) {
+      const entry = scheduledTests.shift()!
+      const initialFrame = currentFrameCounter
+      const startTime = currentFrameTime
+
+      let resolved = false
+
+      // this function should be called only once. it makes the current test pass
+      const resolve = () => {
+        if (resolved) throw new Error('resolved twice')
+        resolved = true
+
+        console.log(`🟢 Test passed ${entry.name}`)
+
+        testingModule
+          .logTestResult({
+            name: entry.name,
+            ok: true,
+            totalFrames: currentFrameCounter - initialFrame,
+            totalTime: currentFrameTime - startTime
+          })
+          .finally(scheduleNextRun)
+      }
+
+      const reject = (err: any) => {
+        if (resolved) throw new Error('resolved twice')
+        resolved = true
+
+        console.log(`🔴 Test failed ${entry.name}`)
+        console.error(err)
+
+        testingModule
+          .logTestResult({
+            name: entry.name,
+            ok: false,
+            error: err.toString(),
+            stack: err && typeof err === 'object' && err.stack,
+            totalFrames: currentFrameCounter - initialFrame,
+            totalTime: currentFrameTime - startTime
+          })
+          .finally(scheduleNextRun)
+      }
+
+      try {
+        console.log(`🧪 Running test ${entry.name}`)
+
+        const testHelpers: TestHelpers = {
+          async setCameraTransform(transform) {
+            await testingModule.setCameraTransform(transform)
+            await nextTick()
+
+            const TransformComponent = engine.getComponent(Transform.componentId) as typeof Transform
+            const actualTransform = TransformComponent.get(engine.CameraEntity)
+
+            assertEquals(actualTransform.position, transform.position, "positions don't match")
+            assertEquals(actualTransform.rotation, transform.rotation, "rotations don't match")
+          }
+        }
+
+        const returnValue = entry.fn(testHelpers)
+
+        if (returnValue && typeof returnValue === 'object') {
+          if (isGenerator(returnValue)) {
+            const env: RunnerEnvironment = {
+              generator: returnValue,
+              helpers: testHelpers,
+              resolve,
+              reject
+            }
+            consumeGenerator(env)
+          } else if (isPromise(returnValue)) {
+            returnValue.then(resolve).catch(reject)
+          } else {
+            throw new Error(`Unknown test result type: ${returnValue}`)
+          }
+        } else {
+          resolve()
+        }
+      } catch (err: any) {
+        reject(err)
+      }
+    }
+  }
+
+  // schedule the test runner start for the next frame
+  nextTickFuture.push(() => {
+    // once we run the next tick, the test runtime becomes frozen. that means no new
+    // test definitions are accepted
+    runtimeFrozen = true
+
+    if (!scheduledTests.length) return
+
+    // inform the test runner about the plans for this test run
+    testingModule.plan({ tests: scheduledTests }).then(scheduleNextRun).catch(globalFail)
+  })
+
+  // this is the function that is used to plan a test functionn
+  /* @__PURE__ */
+  function test(name: string, fn: TestFunction) {
+    if (runtimeFrozen) throw new Error("New tests can't be added at this stage.")
+
+    if (scheduledTests.some(($) => $.name === name)) throw new Error(`Test with name ${name} already exists`)
+
+    scheduledTests.push({ fn, name })
+  }
+
+  return {
+    test
+  }
+}
+
+function isGenerator(t: any): t is Generator {
+  return t && typeof t === 'object' && typeof t[Symbol.iterator] === 'function'
+}
+
+function isPromise(t: any): t is Promise<unknown> {
+  return t && typeof t === 'object' && typeof t.then === 'function'
+}
+
+function globalFail(error: any) {
+  // for now, the failure is only writing to the console.error.
+  console.error(error)
+}

package/src/testing/types.ts

@@ -0,0 +1,21 @@
+import type { TransformType } from '@dcl/ecs'
+import type { logTestResult, plan, setCameraTransform } from '~system/Testing'
+
+export type TestHelpers = {
+  /**
+   * Instructs the renderer to set the camera transform to the provided argument.
+   * This function resolves the next frame and fails if the CameraTransform is not
+   * equal to the provided argument.
+   */
+  setCameraTransform(transform: Pick<TransformType, 'position' | 'rotation'>): Promise<void>
+}
+
+export type TestFunction = (helpers: TestHelpers) => Generator | Promise<any>
+
+export type TestDefinitionFunction = (name: string, fn: TestFunction) => void
+
+export type TestingModule = {
+  logTestResult: typeof logTestResult
+  plan: typeof plan
+  setCameraTransform: typeof setCameraTransform
+}

package/testing/assert.d.ts

@@ -0,0 +1,11 @@
+import type { Entity, LastWriteWinElementSetComponentDefinition } from '@dcl/ecs';
+type Options = {
+    strict: boolean;
+    comp: typeof closeTo;
+};
+export declare function assertEquals(a: any, b: any, message?: string): void;
+export declare function assert(a: any, message?: string): void;
+export declare function assertComponentValue<T>(entity: Entity, component: LastWriteWinElementSetComponentDefinition<T>, value: T): void;
+export declare function deepCloseTo(actual: any, expected: any, options?: Partial<Options>): boolean;
+declare function closeTo(actual: any, expected: any, delta?: number): boolean;
+export {};

package/testing/assert.js

@@ -0,0 +1,106 @@
+const pSlice = Array.prototype.slice;
+const floatEpsilon = 0.0000001;
+export function assertEquals(a, b, message = 'Values are not equal') {
+    if (!deepCloseTo(a, b))
+        throw new Error(`${message} - ${JSON.stringify(a)} != ${JSON.stringify(b)}`);
+}
+export function assert(a, message = 'assertion failed') {
+    if (!a)
+        throw new Error(message);
+}
+export function assertComponentValue(entity, component, value) {
+    assert(component.has(entity), `The entity doesn't have a ${component.componentName} component`);
+    assertEquals(component.get(entity), value, `Invalid ${component.componentName} values`);
+}
+export function deepCloseTo(actual, expected, options = {}) {
+    const opts = Object.assign({}, { comp: closeTo }, options);
+    if (actual === expected) {
+        return true;
+    }
+    else if (actual instanceof Date && expected instanceof Date) {
+        return opts.comp(actual, expected);
+    }
+    else if (!actual || !expected || (typeof actual !== 'object' && typeof expected !== 'object')) {
+        if (opts.strict) {
+            if (!actual && !expected) {
+                return actual === expected;
+            }
+            if (typeof actual !== typeof expected) {
+                return false;
+            }
+        }
+        if (!actual && !expected) {
+            return actual === expected;
+        }
+        return opts.comp(actual, expected);
+    }
+    else {
+        return objEquiv(actual, expected, opts);
+    }
+}
+function isUndefinedOrNull(value) {
+    return value === null || value === undefined;
+}
+function isBuffer(x) {
+    if (!x || typeof x !== 'object' || typeof x.length !== 'number')
+        return false;
+    if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {
+        return false;
+    }
+    if (x.length > 0 && typeof x[0] !== 'number')
+        return false;
+    return true;
+}
+function objEquiv(a, b, opts) {
+    let i, key;
+    if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
+        return false;
+    if (a.prototype !== b.prototype)
+        return false;
+    if (isArguments(a)) {
+        if (!isArguments(b)) {
+            return false;
+        }
+        return deepCloseTo(pSlice.call(a), pSlice.call(b), opts);
+    }
+    if (isBuffer(a)) {
+        if (!isBuffer(b)) {
+            return false;
+        }
+        if (a.length !== b.length)
+            return false;
+        for (i = 0; i < a.length; i++) {
+            if (a[i] !== b[i])
+                return false;
+        }
+        return true;
+    }
+    try {
+        const ka = Object.keys(a);
+        const kb = Object.keys(b);
+        if (ka.length !== kb.length)
+            return false;
+        ka.sort();
+        kb.sort();
+        for (i = ka.length - 1; i >= 0; i--) {
+            if (ka[i] !== kb[i])
+                return false;
+        }
+        for (i = ka.length - 1; i >= 0; i--) {
+            key = ka[i];
+            if (!deepCloseTo(a[key], b[key], opts))
+                return false;
+        }
+    }
+    catch (e) {
+        return false;
+    }
+    return typeof a === typeof b;
+}
+function isArguments(object) {
+    return Object.prototype.toString.call(object) === '[object Arguments]';
+}
+function closeTo(actual, expected, delta = floatEpsilon) {
+    return Math.abs(actual - expected) < delta;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assert.js","sourceRoot":"","sources":["../src/testing/assert.ts"],"names":[],"mappings":"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","sourcesContent":["// VERBATIM COPY OF https://github.com/LemonPi/deep-close-to\n\nimport type { Entity, LastWriteWinElementSetComponentDefinition } from '@dcl/ecs'\n\nconst pSlice = Array.prototype.slice\n\nconst floatEpsilon = 0.0000001\n\ntype Options = { strict: boolean; comp: typeof closeTo }\n\nexport function assertEquals(a: any, b: any, message: string = 'Values are not equal') {\n  if (!deepCloseTo(a, b)) throw new Error(`${message} - ${JSON.stringify(a)} != ${JSON.stringify(b)}`)\n}\n\nexport function assert(a: any, message: string = 'assertion failed') {\n  if (!a) throw new Error(message)\n}\n\nexport function assertComponentValue<T>(\n  entity: Entity,\n  component: LastWriteWinElementSetComponentDefinition<T>,\n  value: T\n) {\n  assert(component.has(entity), `The entity doesn't have a ${component.componentName} component`)\n  assertEquals(component.get(entity)!, value, `Invalid ${component.componentName} values`)\n}\n\nexport function deepCloseTo(actual: any, expected: any, options: Partial<Options> = {}): boolean {\n  const opts = Object.assign({}, { comp: closeTo }, options)\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true\n  } else if (actual instanceof Date && expected instanceof Date) {\n    return opts.comp!(actual, expected)\n\n    // 7.3. Other pairs that do not both pass typeof value == 'object',\n    // equivalence is determined by ==.\n  } else if (!actual || !expected || (typeof actual !== 'object' && typeof expected !== 'object')) {\n    if (opts.strict) {\n      if (!actual && !expected) {\n        return actual === expected\n      }\n\n      if (typeof actual !== typeof expected) {\n        return false\n      }\n    }\n    if (!actual && !expected) {\n      return actual === expected\n    }\n    return opts.comp!(actual, expected)\n\n    // 7.4. For all other Object pairs, including Array objects, equivalence is\n    // determined by having the same number of owned properties (as verified\n    // with Object.prototype.hasOwnProperty.call), the same set of keys\n    // (although not necessarily the same order), equivalent values for every\n    // corresponding key, and an identical 'prototype' property. Note: this\n    // accounts for both named and indexed properties on Arrays.\n  } else {\n    return objEquiv(actual, expected, opts as any)\n  }\n}\n\nfunction isUndefinedOrNull(value: any) {\n  return value === null || value === undefined\n}\n\nfunction isBuffer(x: any) {\n  if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false\n  if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {\n    return false\n  }\n  if (x.length > 0 && typeof x[0] !== 'number') return false\n  return true\n}\n\nfunction objEquiv(a: any, b: any, opts: Options) {\n  let i, key\n  if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) return false\n  // an identical 'prototype' property.\n  if (a.prototype !== b.prototype) return false\n  //~~~I've managed to break Object.keys through screwy arguments passing.\n  //   Converting to array solves the problem.\n  if (isArguments(a)) {\n    if (!isArguments(b)) {\n      return false\n    }\n    return deepCloseTo(pSlice.call(a), pSlice.call(b), opts)\n  }\n  if (isBuffer(a)) {\n    if (!isBuffer(b)) {\n      return false\n    }\n    if (a.length !== b.length) return false\n    for (i = 0; i < a.length; i++) {\n      if (a[i] !== b[i]) return false\n    }\n    return true\n  }\n\n  try {\n    const ka = Object.keys(a)\n    const kb = Object.keys(b)\n\n    // having the same number of owned properties (keys incorporates\n    // hasOwnProperty)\n    if (ka.length !== kb.length) return false\n    //the same set of keys (although not necessarily the same order),\n    ka.sort()\n    kb.sort()\n    //~~~cheap key test\n    for (i = ka.length - 1; i >= 0; i--) {\n      if (ka[i] !== kb[i]) return false\n    }\n    //equivalent values for every corresponding key, and\n    //~~~possibly expensive deep test\n    for (i = ka.length - 1; i >= 0; i--) {\n      key = ka[i]\n      if (!deepCloseTo(a[key], b[key], opts)) return false\n    }\n  } catch (e) {\n    //happens when one is a string literal and the other isn't\n    return false\n  }\n\n  return typeof a === typeof b\n}\n\nfunction isArguments(object: any) {\n  return Object.prototype.toString.call(object) === '[object Arguments]'\n}\nfunction closeTo(actual: any, expected: any, delta: number = floatEpsilon) {\n  return Math.abs(actual - expected) < delta\n}\n"]}

package/testing/index.d.ts

@@ -0,0 +1,2 @@
+import { TestDefinitionFunction } from './types';
+export declare const test: TestDefinitionFunction;

package/testing/index.js

@@ -0,0 +1,30 @@
+import { engine } from '@dcl/ecs';
+import { createTestRuntime } from './runtime';
+export const test = DEBUG ? createTestFunction() : () => { };
+function createTestFunction() {
+    let testingModule;
+    try {
+        testingModule = require('~system/Testing');
+    }
+    catch (err) {
+        console.error(err);
+        console.error(`🔴🚨‼️ WARNING: The test runner is not available. The test runner will be mocked. ‼️🚨🔴`);
+        testingModule = {
+            async logTestResult(data) {
+                console.log(`🧪 mocked '~system/Testing'.logResult`, data);
+                return {};
+            },
+            async plan(data) {
+                console.log(`🧪 mocked '~system/Testing'.plan`, data);
+                return {};
+            },
+            async setCameraTransform(transform) {
+                console.log(`🧪 mocked '~system/Testing'.setCameraTransform`, transform);
+                return {};
+            }
+        };
+    }
+    const runtime = createTestRuntime(testingModule, engine);
+    return runtime.test;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/testing/runtime.d.ts

@@ -0,0 +1,5 @@
+import { IEngine } from '@dcl/ecs';
+import type { TestingModule, TestFunction } from './types';
+export declare function createTestRuntime(testingModule: TestingModule, engine: IEngine): {
+    test: (name: string, fn: TestFunction) => void;
+};

package/testing/runtime.js

@@ -0,0 +1,168 @@
+import { Transform } from '@dcl/ecs';
+import { assertEquals } from './assert';
+export function createTestRuntime(testingModule, engine) {
+    let runtimeFrozen = false;
+    let currentFrameCounter = 0;
+    let currentFrameTime = 0;
+    const scheduledTests = [];
+    const nextTickFuture = [];
+    async function nextTick() {
+        return new Promise((resolve) => {
+            nextTickFuture.push(resolve);
+        });
+    }
+    engine.addSystem(function TestingFrameworkCoroutineRunner(dt) {
+        currentFrameCounter++;
+        currentFrameTime += dt;
+        nextTickFuture.splice(0, nextTickFuture.length).forEach((_) => _(dt));
+    });
+    function scheduleValue(value, env) {
+        if (value && typeof value === 'object' && typeof value.then === 'function') {
+            console.log('⏱️ yield promise');
+            nextTickFuture.push(async () => {
+                try {
+                    scheduleValue(await value, env);
+                }
+                catch (err) {
+                    env.reject(err);
+                }
+            });
+        }
+        else if (typeof value === 'function') {
+            console.log('⏱️ yield function');
+            nextTickFuture.push(() => {
+                scheduleValue(value(), env);
+            });
+            return;
+        }
+        else if (typeof value === 'undefined' || value === null) {
+            console.log('⏱️ yield');
+            nextTickFuture.push(() => {
+                consumeGenerator(env);
+            });
+        }
+        else
+            throw new Error(`Unexpected value from test generator: ${value}`);
+    }
+    function consumeGenerator(env) {
+        try {
+            const ret = env.generator.next();
+            if (!ret.done) {
+                scheduleValue(ret.value, env);
+            }
+            else {
+                env.resolve();
+            }
+        }
+        catch (err) {
+            env.reject(err);
+        }
+    }
+    function scheduleNextRun() {
+        if (scheduledTests.length) {
+            nextTickFuture.push(runTests);
+        }
+    }
+    function runTests() {
+        if (scheduledTests.length) {
+            const entry = scheduledTests.shift();
+            const initialFrame = currentFrameCounter;
+            const startTime = currentFrameTime;
+            let resolved = false;
+            const resolve = () => {
+                if (resolved)
+                    throw new Error('resolved twice');
+                resolved = true;
+                console.log(`🟢 Test passed ${entry.name}`);
+                testingModule
+                    .logTestResult({
+                    name: entry.name,
+                    ok: true,
+                    totalFrames: currentFrameCounter - initialFrame,
+                    totalTime: currentFrameTime - startTime
+                })
+                    .finally(scheduleNextRun);
+            };
+            const reject = (err) => {
+                if (resolved)
+                    throw new Error('resolved twice');
+                resolved = true;
+                console.log(`🔴 Test failed ${entry.name}`);
+                console.error(err);
+                testingModule
+                    .logTestResult({
+                    name: entry.name,
+                    ok: false,
+                    error: err.toString(),
+                    stack: err && typeof err === 'object' && err.stack,
+                    totalFrames: currentFrameCounter - initialFrame,
+                    totalTime: currentFrameTime - startTime
+                })
+                    .finally(scheduleNextRun);
+            };
+            try {
+                console.log(`🧪 Running test ${entry.name}`);
+                const testHelpers = {
+                    async setCameraTransform(transform) {
+                        await testingModule.setCameraTransform(transform);
+                        await nextTick();
+                        const TransformComponent = engine.getComponent(Transform.componentId);
+                        const actualTransform = TransformComponent.get(engine.CameraEntity);
+                        assertEquals(actualTransform.position, transform.position, "positions don't match");
+                        assertEquals(actualTransform.rotation, transform.rotation, "rotations don't match");
+                    }
+                };
+                const returnValue = entry.fn(testHelpers);
+                if (returnValue && typeof returnValue === 'object') {
+                    if (isGenerator(returnValue)) {
+                        const env = {
+                            generator: returnValue,
+                            helpers: testHelpers,
+                            resolve,
+                            reject
+                        };
+                        consumeGenerator(env);
+                    }
+                    else if (isPromise(returnValue)) {
+                        returnValue.then(resolve).catch(reject);
+                    }
+                    else {
+                        throw new Error(`Unknown test result type: ${returnValue}`);
+                    }
+                }
+                else {
+                    resolve();
+                }
+            }
+            catch (err) {
+                reject(err);
+            }
+        }
+    }
+    nextTickFuture.push(() => {
+        runtimeFrozen = true;
+        if (!scheduledTests.length)
+            return;
+        testingModule.plan({ tests: scheduledTests }).then(scheduleNextRun).catch(globalFail);
+    });
+    function test(name, fn) {
+        if (runtimeFrozen)
+            throw new Error("New tests can't be added at this stage.");
+        if (scheduledTests.some(($) => $.name === name))
+            throw new Error(`Test with name ${name} already exists`);
+        scheduledTests.push({ fn, name });
+    }
+    return {
+        test
+    };
+}
+function isGenerator(t) {
+    return t && typeof t === 'object' && typeof t[Symbol.iterator] === 'function';
+}
+function isPromise(t) {
+    return t && typeof t === 'object' && typeof t.then === 'function';
+}
+function globalFail(error) {
+    console.error(error);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../src/testing/runtime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This module provides a createTestRuntime function that returns an object with a test function that can be used to define tests.\n */\n\nimport { IEngine, Transform } from '@dcl/ecs'\nimport { assertEquals } from './assert'\nimport type { TestingModule, TestFunction, TestHelpers } from './types'\n\n// This function creates a test runtime that can be used to define and run tests.\n// It takes a `TestingModule` instance (loaded from require('~system/Testing')) and an `IEngine` instance (from Decentraland's SDK).\n// It returns an object with a `test` function that can be used to define tests.\n/* @__PURE__ */\nexport function createTestRuntime(testingModule: TestingModule, engine: IEngine) {\n  type TestPlanEntry = { name: string; fn: TestFunction }\n  type RunnerEnvironment = {\n    resolve: () => void\n    reject: (error: any) => void\n    helpers: TestHelpers\n    generator: Generator\n  }\n\n  // this flag ensures no tests are added asynchronously\n  let runtimeFrozen = false\n\n  let currentFrameCounter = 0\n  let currentFrameTime = 0\n\n  // array to hold the scheduled tests\n  const scheduledTests: TestPlanEntry[] = []\n\n  // an array of promises that are resolved on the next frame (after the current frame is finished)\n  const nextTickFuture: Array<(dt: number) => void> = []\n\n  // this function returns a promise that resolves on the next frame\n  async function nextTick() {\n    return new Promise<number>((resolve) => {\n      nextTickFuture.push(resolve)\n    })\n  }\n\n  // add a system to the engine that resolves all promises in the `nextTickFuture` array\n  engine.addSystem(function TestingFrameworkCoroutineRunner(dt) {\n    currentFrameCounter++\n    currentFrameTime += dt\n    // resolve all nextTick futures.\n    nextTickFuture.splice(0, nextTickFuture.length).forEach((_) => _(dt))\n  })\n\n  // this function schedules a value to be processed on the next frame, the test runner will\n  // continue to run until it reaches a yield point\n  function scheduleValue(value: any, env: RunnerEnvironment) {\n    if (value && typeof value === 'object' && typeof value.then === 'function') {\n      console.log('⏱️ yield promise')\n      // if the value is a promise, schedule it to be awaited after the current frame is finished\n      nextTickFuture.push(async () => {\n        try {\n          scheduleValue(await value, env)\n        } catch (err) {\n          env.reject(err)\n        }\n      })\n    } else if (typeof value === 'function') {\n      console.log('⏱️ yield function')\n      // if the value is a function, schedule it to be called on the next frame\n      nextTickFuture.push(() => {\n        scheduleValue(value(), env)\n      })\n      return\n    } else if (typeof value === 'undefined' || value === null) {\n      console.log('⏱️ yield')\n      // if the value is undefined or null, continue processing the generator the next frame\n      nextTickFuture.push(() => {\n        consumeGenerator(env)\n      })\n    } else throw new Error(`Unexpected value from test generator: ${value}`)\n  }\n\n  // this function processes a generator function by scheduling its values to be processed on the next frame\n  function consumeGenerator(env: RunnerEnvironment) {\n    try {\n      const ret = env.generator.next()\n      if (!ret.done) {\n        scheduleValue(ret.value, env)\n      } else {\n        env.resolve()\n      }\n    } catch (err) {\n      env.reject(err)\n    }\n  }\n\n  // this function schedules a test run on the next frame\n  function scheduleNextRun() {\n    if (scheduledTests.length) {\n      nextTickFuture.push(runTests)\n    }\n  }\n\n  // this function runs the scheduled tests\n  function runTests() {\n    if (scheduledTests.length) {\n      const entry = scheduledTests.shift()!\n      const initialFrame = currentFrameCounter\n      const startTime = currentFrameTime\n\n      let resolved = false\n\n      // this function should be called only once. it makes the current test pass\n      const resolve = () => {\n        if (resolved) throw new Error('resolved twice')\n        resolved = true\n\n        console.log(`🟢 Test passed ${entry.name}`)\n\n        testingModule\n          .logTestResult({\n            name: entry.name,\n            ok: true,\n            totalFrames: currentFrameCounter - initialFrame,\n            totalTime: currentFrameTime - startTime\n          })\n          .finally(scheduleNextRun)\n      }\n\n      const reject = (err: any) => {\n        if (resolved) throw new Error('resolved twice')\n        resolved = true\n\n        console.log(`🔴 Test failed ${entry.name}`)\n        console.error(err)\n\n        testingModule\n          .logTestResult({\n            name: entry.name,\n            ok: false,\n            error: err.toString(),\n            stack: err && typeof err === 'object' && err.stack,\n            totalFrames: currentFrameCounter - initialFrame,\n            totalTime: currentFrameTime - startTime\n          })\n          .finally(scheduleNextRun)\n      }\n\n      try {\n        console.log(`🧪 Running test ${entry.name}`)\n\n        const testHelpers: TestHelpers = {\n          async setCameraTransform(transform) {\n            await testingModule.setCameraTransform(transform)\n            await nextTick()\n\n            const TransformComponent = engine.getComponent(Transform.componentId) as typeof Transform\n            const actualTransform = TransformComponent.get(engine.CameraEntity)\n\n            assertEquals(actualTransform.position, transform.position, \"positions don't match\")\n            assertEquals(actualTransform.rotation, transform.rotation, \"rotations don't match\")\n          }\n        }\n\n        const returnValue = entry.fn(testHelpers)\n\n        if (returnValue && typeof returnValue === 'object') {\n          if (isGenerator(returnValue)) {\n            const env: RunnerEnvironment = {\n              generator: returnValue,\n              helpers: testHelpers,\n              resolve,\n              reject\n            }\n            consumeGenerator(env)\n          } else if (isPromise(returnValue)) {\n            returnValue.then(resolve).catch(reject)\n          } else {\n            throw new Error(`Unknown test result type: ${returnValue}`)\n          }\n        } else {\n          resolve()\n        }\n      } catch (err: any) {\n        reject(err)\n      }\n    }\n  }\n\n  // schedule the test runner start for the next frame\n  nextTickFuture.push(() => {\n    // once we run the next tick, the test runtime becomes frozen. that means no new\n    // test definitions are accepted\n    runtimeFrozen = true\n\n    if (!scheduledTests.length) return\n\n    // inform the test runner about the plans for this test run\n    testingModule.plan({ tests: scheduledTests }).then(scheduleNextRun).catch(globalFail)\n  })\n\n  // this is the function that is used to plan a test functionn\n  /* @__PURE__ */\n  function test(name: string, fn: TestFunction) {\n    if (runtimeFrozen) throw new Error(\"New tests can't be added at this stage.\")\n\n    if (scheduledTests.some(($) => $.name === name)) throw new Error(`Test with name ${name} already exists`)\n\n    scheduledTests.push({ fn, name })\n  }\n\n  return {\n    test\n  }\n}\n\nfunction isGenerator(t: any): t is Generator {\n  return t && typeof t === 'object' && typeof t[Symbol.iterator] === 'function'\n}\n\nfunction isPromise(t: any): t is Promise<unknown> {\n  return t && typeof t === 'object' && typeof t.then === 'function'\n}\n\nfunction globalFail(error: any) {\n  // for now, the failure is only writing to the console.error.\n  console.error(error)\n}\n"]}

package/testing/types.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="@dcl/js-runtime" />
+import type { TransformType } from '@dcl/ecs';
+import type { logTestResult, plan, setCameraTransform } from '~system/Testing';
+export type TestHelpers = {
+    setCameraTransform(transform: Pick<TransformType, 'position' | 'rotation'>): Promise<void>;
+};
+export type TestFunction = (helpers: TestHelpers) => Generator | Promise<any>;
+export type TestDefinitionFunction = (name: string, fn: TestFunction) => void;
+export type TestingModule = {
+    logTestResult: typeof logTestResult;
+    plan: typeof plan;
+    setCameraTransform: typeof setCameraTransform;
+};

package/testing/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdGVzdGluZy90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBUcmFuc2Zvcm1UeXBlIH0gZnJvbSAnQGRjbC9lY3MnXG5pbXBvcnQgdHlwZSB7IGxvZ1Rlc3RSZXN1bHQsIHBsYW4sIHNldENhbWVyYVRyYW5zZm9ybSB9IGZyb20gJ35zeXN0ZW0vVGVzdGluZydcblxuZXhwb3J0IHR5cGUgVGVzdEhlbHBlcnMgPSB7XG4gIC8qKlxuICAgKiBJbnN0cnVjdHMgdGhlIHJlbmRlcmVyIHRvIHNldCB0aGUgY2FtZXJhIHRyYW5zZm9ybSB0byB0aGUgcHJvdmlkZWQgYXJndW1lbnQuXG4gICAqIFRoaXMgZnVuY3Rpb24gcmVzb2x2ZXMgdGhlIG5leHQgZnJhbWUgYW5kIGZhaWxzIGlmIHRoZSBDYW1lcmFUcmFuc2Zvcm0gaXMgbm90XG4gICAqIGVxdWFsIHRvIHRoZSBwcm92aWRlZCBhcmd1bWVudC5cbiAgICovXG4gIHNldENhbWVyYVRyYW5zZm9ybSh0cmFuc2Zvcm06IFBpY2s8VHJhbnNmb3JtVHlwZSwgJ3Bvc2l0aW9uJyB8ICdyb3RhdGlvbic+KTogUHJvbWlzZTx2b2lkPlxufVxuXG5leHBvcnQgdHlwZSBUZXN0RnVuY3Rpb24gPSAoaGVscGVyczogVGVzdEhlbHBlcnMpID0+IEdlbmVyYXRvciB8IFByb21pc2U8YW55PlxuXG5leHBvcnQgdHlwZSBUZXN0RGVmaW5pdGlvbkZ1bmN0aW9uID0gKG5hbWU6IHN0cmluZywgZm46IFRlc3RGdW5jdGlvbikgPT4gdm9pZFxuXG5leHBvcnQgdHlwZSBUZXN0aW5nTW9kdWxlID0ge1xuICBsb2dUZXN0UmVzdWx0OiB0eXBlb2YgbG9nVGVzdFJlc3VsdFxuICBwbGFuOiB0eXBlb2YgcGxhblxuICBzZXRDYW1lcmFUcmFuc2Zvcm06IHR5cGVvZiBzZXRDYW1lcmFUcmFuc2Zvcm1cbn1cbiJdfQ==

package/types/tsconfig.ecs7.strict.json

@@ -1,6 +1,4 @@
 {
-  "compilerOptions": {
-    
-  },
+  "compilerOptions": {},
   "extends": "./tsconfig.ecs7.json"
 }

package/tsconfig.cli.json

@@ -1,24 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2017",
-    "module": "commonjs",
-    "esModuleInterop": true,
-    "declaration": true,
-    "noUnusedLocals": true,
-    "stripInternal": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "allowJs": true,
-    "strict": true,
-    "types": [
-      "node",
-    ],
-    "lib": [
-      "es2016"
-    ],
-    "outDir": "./cli"
-  },
-  "include": ["cli"],
-  "exclude": ["dist", "**/proto"],
-  "extends": "./types/tsconfig.ecs7.strict.json"
-}