From 874984cac1e114c979731aece2d8d4d0e191dd83 Mon Sep 17 00:00:00 2001 From: Pedro Gallardo Date: Tue, 8 Aug 2023 16:39:10 -0300 Subject: [PATCH] feat: agrega testes a todas ls utils --- src/Emulator.ts | 6 ++--- src/lib/methods/entries.ts | 2 +- src/lib/methods/entriesAfter.ts | 2 +- src/lib/methods/entriesBefore.ts | 2 +- src/types/Exotic.ts | 10 ++++---- src/utils/createProxy.spec.ts | 34 ++++++++++++++++++++++--- src/utils/createProxy.ts | 10 ++++---- src/utils/findProxy.spec.ts | 29 +++++++++++++++++++-- src/utils/getPayload.spec.ts | 19 ++++++++++++-- src/utils/isiTraceable.spec.ts | 28 +++++++++++++++++++-- src/utils/proxyGenerator.spec.ts | 43 ++++++++++++++++++++++++++++++-- src/utils/proxyGenerator.ts | 14 +++++++---- src/utils/revokeProxy.spec.ts | 29 +++++++++++++++++++-- 13 files changed, 193 insertions(+), 35 deletions(-) diff --git a/src/Emulator.ts b/src/Emulator.ts index baf0f20..cb08363 100755 --- a/src/Emulator.ts +++ b/src/Emulator.ts @@ -59,15 +59,15 @@ export default class Emulator extends EventTarget implements Exotic.Emulator { return lib.methods.isRevoked(this, value); } - entries(): Iterable { + entries(): IterableIterator { return lib.methods.entries(this); } - entriesBefore(value: Exotic.traceable): Iterable { + entriesBefore(value: Exotic.traceable): IterableIterator { return lib.methods.entriesBefore(this, value); } - entriesAfter(value: Exotic.traceable): Iterable { + entriesAfter(value: Exotic.traceable): IterableIterator { return lib.methods.entriesAfter(this, value); } diff --git a/src/lib/methods/entries.ts b/src/lib/methods/entries.ts index 76ab51e..f22bc6d 100644 --- a/src/lib/methods/entries.ts +++ b/src/lib/methods/entries.ts @@ -3,7 +3,7 @@ import { proxyGenerator } from "../../utils"; export default function* entries( scope: Exotic.Emulator, -): Iterable { +): IterableIterator { for (const proxy of proxyGenerator(scope)) { yield proxy; } diff --git a/src/lib/methods/entriesAfter.ts b/src/lib/methods/entriesAfter.ts index b45ff9d..73ef8c2 100644 --- a/src/lib/methods/entriesAfter.ts +++ b/src/lib/methods/entriesAfter.ts @@ -4,7 +4,7 @@ import { findProxy, proxyGenerator } from "../../utils"; export default function* entriesAfter( scope: Exotic.Emulator, value: Exotic.traceable, -): Iterable { +): IterableIterator { const currentProxy = findProxy(value); for (const proxy of proxyGenerator(scope, value, false)) { if (proxy !== currentProxy) { diff --git a/src/lib/methods/entriesBefore.ts b/src/lib/methods/entriesBefore.ts index aa3efda..4206e80 100644 --- a/src/lib/methods/entriesBefore.ts +++ b/src/lib/methods/entriesBefore.ts @@ -4,7 +4,7 @@ import { findProxy, proxyGenerator } from "../../utils"; export default function* entriesBefore( scope: Exotic.Emulator, value: Exotic.traceable, -): Iterable { +): IterableIterator { const currentProxy = findProxy(value); for (const proxy of proxyGenerator(scope, value, true)) { if (proxy !== currentProxy) { diff --git a/src/types/Exotic.ts b/src/types/Exotic.ts index cea2557..301d637 100644 --- a/src/types/Exotic.ts +++ b/src/types/Exotic.ts @@ -18,9 +18,9 @@ declare namespace Exotic { ownKeys(value?: traceable): key[]; revoke(value: traceable): boolean; isRevoked(value: traceable): boolean; - entries(): Iterable; - entriesBefore(value: traceable): Iterable; - entriesAfter(value: traceable): Iterable; + entries(): IterableIterator; + entriesBefore(value: traceable): IterableIterator; + entriesAfter(value: traceable): IterableIterator; encode(value: any): Exotic.payload; refs: key[]; active: number; @@ -47,11 +47,11 @@ declare namespace Exotic { interface Mock { (...args: any[]): void; [x: key]: any; - [Symbol.iterator](): Iterator; + [Symbol.iterator](): IterableIterator; } interface Proxy extends Mock { - [Symbol.iterator](): Iterator; + [Symbol.iterator](): IterableIterator; } // eslint-disable-next-line @typescript-eslint/no-namespace diff --git a/src/utils/createProxy.spec.ts b/src/utils/createProxy.spec.ts index f8bb8fe..2af87f4 100644 --- a/src/utils/createProxy.spec.ts +++ b/src/utils/createProxy.spec.ts @@ -1,11 +1,37 @@ import Emulator from "../Emulator"; import createProxy from "./createProxy"; -const scope = new Emulator(); +const $ = new Emulator(); describe("(function) createProxy", () => { - it("Requires a scope parameter that represents the emulator instance", () => { - const proxy = createProxy(scope); - expect(typeof proxy).toBe("function"); + it("Returns an existing proxy", () => { + const proxy = $.use(); + const sameProxy = createProxy($, proxy); + expect(proxy).toBe(sameProxy); + }); + + it("Returns an existing proxy by reference key", () => { + const refKey = "test"; + const proxy = $.useRef(refKey); + const sameProxy = createProxy($, proxy, undefined, refKey); + + expect(proxy).toBe(sameProxy); + }); + + it("Adds a new reference key", () => { + const refKey = "new"; + const refKeyExisted = $.refs.includes(refKey); + + createProxy($, undefined, undefined, refKey); + + expect(refKeyExisted).toBe(false); + expect($.refs.includes(refKey)).toBe(true); + }); + + it("Adds any target value to a proxy", () => { + const target = "target"; + const proxy = createProxy($, target); + + expect($.target(proxy)).toBe(target); }); }); diff --git a/src/utils/createProxy.ts b/src/utils/createProxy.ts index 5946efc..ab0746f 100644 --- a/src/utils/createProxy.ts +++ b/src/utils/createProxy.ts @@ -34,14 +34,14 @@ const createProxy = ( // create new proxy const id = ++data.totalProxies; - const mock = function mock() {} as Exotic.Mock; + const mock = Object.setPrototypeOf( + function mock() {}, + mockPrototype, + ) as Exotic.Mock; const sandbox = Object.create(null); const traceable = isTraceable(target); - const { proxy, revoke } = Proxy.revocable( - Object.setPrototypeOf(mock, mockPrototype), - traps, - ); + const { proxy, revoke } = Proxy.revocable(mock, traps); if (validRefKey) { // create unique reference diff --git a/src/utils/findProxy.spec.ts b/src/utils/findProxy.spec.ts index a6cc948..1931690 100644 --- a/src/utils/findProxy.spec.ts +++ b/src/utils/findProxy.spec.ts @@ -1,5 +1,30 @@ +import Emulator from "../Emulator"; +import findProxy from "./findProxy"; + +const $ = new Emulator(); + describe("(function) findProxy", () => { - it("Runs an exotic proxy emulator", () => { - expect(true).toBeTruthy(); + it("Returns undefined when a proxy is not found", () => { + const param = "notProxy_notTarget"; + const proxy = findProxy(param); + + expect(proxy).toBeUndefined(); + }); + + it("Returns the same proxy if the search parameter is a proxy", () => { + const param = $.use(); + const proxy = findProxy(param); + + expect(proxy).not.toBeUndefined(); + expect(typeof proxy).toBe("function"); + expect(proxy).toBe(param); + }); + + it("Finds a proxy by target reference", () => { + const target = []; + const proxy = $.use(target); + const search = findProxy(target); + + expect(search).toBe(proxy); }); }); diff --git a/src/utils/getPayload.spec.ts b/src/utils/getPayload.spec.ts index f6b89cf..e7239e1 100644 --- a/src/utils/getPayload.spec.ts +++ b/src/utils/getPayload.spec.ts @@ -1,5 +1,20 @@ +import Emulator from "../Emulator"; +import getPayload from "./getPayload"; + +const $ = new Emulator(); + describe("(function) getPayload", () => { - it("Runs an exotic proxy emulator", () => { - expect(true).toBeTruthy(); + it("Returns a payload object from a proxy", () => { + const proxy = $.use(); + const payload = getPayload($, proxy); + + expect(payload).toEqual({ encoded: true, value: 1 }); + }); + + it("Returns a payload object from a non proxy value", () => { + const value = null; + const payload = getPayload($, value); + + expect(payload).toEqual({ encoded: false, value }); }); }); diff --git a/src/utils/isiTraceable.spec.ts b/src/utils/isiTraceable.spec.ts index 8e678ad..bfc09a7 100644 --- a/src/utils/isiTraceable.spec.ts +++ b/src/utils/isiTraceable.spec.ts @@ -1,5 +1,29 @@ +import Emulator from "../Emulator"; +import isTraceable from "./isTraceable"; + +const $ = new Emulator(); + describe("(function) isTraceable", () => { - it("Runs an exotic proxy emulator", () => { - expect(true).toBeTruthy(); + it("Returns true when the parameter is a non-null object or a function that is not a proxy", () => { + // define prossible targets + const trueTargets = [[], {}, function () {}, () => {}, function* () {}]; + const falseTargets = [ + null, + undefined, + "string", + $.use(), + 10, + NaN, + Infinity, + true, + false, + Symbol(), + ]; + + const traceable = trueTargets.every(isTraceable); + const untraceable = falseTargets.some(isTraceable); + + expect(traceable).toBe(true); + expect(untraceable).toBe(false); }); }); diff --git a/src/utils/proxyGenerator.spec.ts b/src/utils/proxyGenerator.spec.ts index fb27af7..5d8e529 100644 --- a/src/utils/proxyGenerator.spec.ts +++ b/src/utils/proxyGenerator.spec.ts @@ -1,5 +1,44 @@ +import Emulator from "../Emulator"; +import proxyGenerator from "./proxyGenerator"; + +const $ = new Emulator(); + +const proxyA = $.use(); +const proxyB = $.use(); +const proxyC = $.use(); + describe("(function*) proxyGenerator", () => { - it("Runs an exotic proxy emulator", () => { - expect(true).toBeTruthy(); + it("Returns an IterableIterator of all non-revoked proxies in the emulator instance", () => { + const iterator = proxyGenerator($); + + expect(iterator.next().value).toBe(proxyA); + expect(iterator.next().value).toBe(proxyB); + expect(iterator.next().value).toBe(proxyC); + expect(iterator.next().done).toBe(true); + }); + + it("Returns an IterableIterator of all non-revoked proxies in the emulator instance in reverse order", () => { + const iterator = proxyGenerator($, undefined, true); + + expect(iterator.next().value).toBe(proxyC); + expect(iterator.next().value).toBe(proxyB); + expect(iterator.next().value).toBe(proxyA); + expect(iterator.next().done).toBe(true); + }); + + it("Returns an IterableIterator of all non-revoked proxies in the emulator instance starting from an specific proxy in time", () => { + const iterator = proxyGenerator($, proxyB); + + expect(iterator.next().value).toBe(proxyB); + expect(iterator.next().value).toBe(proxyC); + expect(iterator.next().done).toBe(true); + }); + + it("Returns an IterableIterator of all non-revoked proxies in the emulator instance starting from an specific proxy in time backwards", () => { + const iterator = proxyGenerator($, proxyB, true); + + expect(iterator.next().value).toBe(proxyB); + expect(iterator.next().value).toBe(proxyA); + expect(iterator.next().done).toBe(true); }); }); diff --git a/src/utils/proxyGenerator.ts b/src/utils/proxyGenerator.ts index 7cad6b3..13a9abb 100644 --- a/src/utils/proxyGenerator.ts +++ b/src/utils/proxyGenerator.ts @@ -6,13 +6,14 @@ const proxyGenerator = function* ( scope: Exotic.Emulator, value?: Exotic.traceable, reverse: boolean = false, -): Iterable { +): IterableIterator { if (value === undefined) { - const { firstProxy } = map.emulators.get(scope); + const { firstProxy, lastProxy } = map.emulators.get(scope); + const item = reverse ? lastProxy : firstProxy; - if (!firstProxy) return; + if (!item) return; - for (const proxy of proxyGenerator(scope, firstProxy, false)) { + for (const proxy of proxyGenerator(scope, item, reverse)) { if (!scope.isRevoked(proxy)) { yield proxy; } @@ -21,7 +22,10 @@ const proxyGenerator = function* ( } const proxy = findProxy(value); - if (!proxy) return; + + if (!proxy) { + return; + } if (!scope.isRevoked(proxy)) { yield proxy; diff --git a/src/utils/revokeProxy.spec.ts b/src/utils/revokeProxy.spec.ts index e0b6031..55144b9 100644 --- a/src/utils/revokeProxy.spec.ts +++ b/src/utils/revokeProxy.spec.ts @@ -1,5 +1,30 @@ +import Emulator from "../Emulator"; +import revokeProxy from "./revokeProxy"; + +const $ = new Emulator(); + describe("(function) revokeProxy", () => { - it("Runs an exotic proxy emulator", () => { - expect(true).toBeTruthy(); + it("Returns false when the parameter is not a proxy", () => { + const param = [100]; + const isrevoked = revokeProxy($, param); + + expect(isrevoked).toBe(false); + }); + + it("Returns true when the parameter is a proxy", () => { + const proxy = $.use(); + const isrevoked = revokeProxy($, proxy); + + expect(isrevoked).toBe(true); + expect(proxy).toThrow(); + }); + + it("Returns true when the parameter is a proxy's target", () => { + const target = {}; + const proxy = $.use(target); + const isrevoked = revokeProxy($, target); + + expect(isrevoked).toBe(true); + expect(proxy).toThrow(); }); });