mirror of
https://github.com/lensapp/lens.git
synced 2025-05-20 05:10:56 +00:00
2789bcebcb
* Convert runMany and runManySync to use injectManyWithMeta Signed-off-by: Sebastian Malton <sebastian@malton.name> * Fixup type errors due to new Runnable requirements Signed-off-by: Sebastian Malton <sebastian@malton.name> * Add documentation for verifyRunnablesAreDAG Signed-off-by: Sebastian Malton <sebastian@malton.name> * Simplify convertToWithIdWith Signed-off-by: Sebastian Malton <sebastian@malton.name> * Move all utility functions to separate package Signed-off-by: Sebastian Malton <sebastian@malton.name> * Move testing utilities to separate package Signed-off-by: Sebastian Malton <sebastian@malton.name> * Move run-many and run-many-sync to separate package Signed-off-by: Sebastian Malton <sebastian@malton.name> * Replace all internal uses of utilities with new packages Signed-off-by: Sebastian Malton <sebastian@malton.name> * Use new @k8slens/run-many package in core Signed-off-by: Sebastian Malton <sebastian@malton.name> * Add dep to open-lens Signed-off-by: Sebastian Malton <sebastian@malton.name> * Fixup type errors Signed-off-by: Sebastian Malton <sebastian@malton.name> * Fixup uses of @k8slens/test-utils Signed-off-by: Sebastian Malton <sebastian@malton.name> * Fixup getGlobalOverride Signed-off-by: Sebastian Malton <sebastian@malton.name> * Move tests to new package too Signed-off-by: Sebastian Malton <sebastian@malton.name> * Fix type errors Signed-off-by: Sebastian Malton <sebastian@malton.name> * Fixup uses of AsyncResult and autoBind Signed-off-by: Sebastian Malton <sebastian@malton.name> * Fixup remaining import issues Signed-off-by: Sebastian Malton <sebastian@malton.name> * Finial fixups to fix build Signed-off-by: Sebastian Malton <sebastian@malton.name> * Fix lint Signed-off-by: Sebastian Malton <sebastian@malton.name> * Revert moving "testUsingFakeTime" to separate package - This fixes tests Signed-off-by: Sebastian Malton <sebastian@malton.name> * Fix integration tests Signed-off-by: Sebastian Malton <sebastian@malton.name> * Fix unit test failing due to spelling fix Signed-off-by: Sebastian Malton <sebastian@malton.name> --------- Signed-off-by: Sebastian Malton <sebastian@malton.name>
513 lines
11 KiB
TypeScript
513 lines
11 KiB
TypeScript
/**
|
|
* Copyright (c) OpenLens Authors. All rights reserved.
|
|
* Licensed under MIT License. See LICENSE in root directory for more information.
|
|
*/
|
|
|
|
import { HashSet, ObservableHashSet } from "./hash-set";
|
|
|
|
describe("ObservableHashSet<T>", () => {
|
|
it("should not throw on creation", () => {
|
|
expect(() => new ObservableHashSet<{ a: number }>([], item => item.a.toString())).not.toThrowError();
|
|
});
|
|
|
|
it("should be initialized", () => {
|
|
const res = new ObservableHashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.size).toBe(4);
|
|
});
|
|
|
|
it("has should work as expected", () => {
|
|
const res = new ObservableHashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.has({ a: 1 })).toBe(true);
|
|
expect(res.has({ a: 5 })).toBe(false);
|
|
});
|
|
|
|
it("forEach should work as expected", () => {
|
|
const res = new ObservableHashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
let a = 1;
|
|
|
|
res.forEach((item) => {
|
|
expect(item.a).toEqual(a++);
|
|
});
|
|
});
|
|
|
|
it("delete should work as expected", () => {
|
|
const res = new ObservableHashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.has({ a: 1 })).toBe(true);
|
|
expect(res.delete({ a: 1 })).toBe(true);
|
|
expect(res.has({ a: 1 })).toBe(false);
|
|
|
|
expect(res.has({ a: 5 })).toBe(false);
|
|
expect(res.delete({ a: 5 })).toBe(false);
|
|
expect(res.has({ a: 5 })).toBe(false);
|
|
});
|
|
|
|
it("toggle should work as expected", () => {
|
|
const res = new ObservableHashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.has({ a: 1 })).toBe(true);
|
|
res.toggle({ a: 1 });
|
|
expect(res.has({ a: 1 })).toBe(false);
|
|
|
|
expect(res.has({ a: 6 })).toBe(false);
|
|
res.toggle({ a: 6 });
|
|
expect(res.has({ a: 6 })).toBe(true);
|
|
});
|
|
|
|
it("add should work as expected", () => {
|
|
const res = new ObservableHashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.has({ a: 6 })).toBe(false);
|
|
res.add({ a: 6 });
|
|
expect(res.has({ a: 6 })).toBe(true);
|
|
});
|
|
|
|
it("add should treat the hash to be the same as equality", () => {
|
|
const res = new ObservableHashSet([
|
|
{ a: 1, foobar: "hello" },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.has({ a: 1 })).toBe(true);
|
|
res.add({ a: 1, foobar: "goodbye" });
|
|
expect(res.has({ a: 1 })).toBe(true);
|
|
});
|
|
|
|
it("clear should work as expected", () => {
|
|
const res = new ObservableHashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.size).toBe(4);
|
|
res.clear();
|
|
expect(res.size).toBe(0);
|
|
});
|
|
|
|
it("replace should work as expected", () => {
|
|
const res = new ObservableHashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.size).toBe(4);
|
|
res.replace([{ a: 13 }]);
|
|
expect(res.size).toBe(1);
|
|
expect(res.has({ a: 1 })).toBe(false);
|
|
expect(res.has({ a: 13 })).toBe(true);
|
|
});
|
|
|
|
it("toJSON should work as expected", () => {
|
|
const res = new ObservableHashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.toJSON()).toStrictEqual([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
]);
|
|
});
|
|
|
|
it("values should work as expected", () => {
|
|
const res = new ObservableHashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
const iter = res.values();
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 1 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 2 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 3 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 4 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: undefined,
|
|
done: true,
|
|
});
|
|
});
|
|
|
|
it("keys should work as expected", () => {
|
|
const res = new ObservableHashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
const iter = res.keys();
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 1 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 2 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 3 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 4 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: undefined,
|
|
done: true,
|
|
});
|
|
});
|
|
|
|
it("entries should work as expected", () => {
|
|
const res = new ObservableHashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
const iter = res.entries();
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: [{ a: 1 }, { a: 1 }],
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: [{ a: 2 }, { a: 2 }],
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: [{ a: 3 }, { a: 3 }],
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: [{ a: 4 }, { a: 4 }],
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: undefined,
|
|
done: true,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("HashSet<T>", () => {
|
|
it("should not throw on creation", () => {
|
|
expect(() => new HashSet<{ a: number }>([], item => item.a.toString())).not.toThrowError();
|
|
});
|
|
|
|
it("should be initialized", () => {
|
|
const res = new HashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.size).toBe(4);
|
|
});
|
|
|
|
it("has should work as expected", () => {
|
|
const res = new HashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.has({ a: 1 })).toBe(true);
|
|
expect(res.has({ a: 5 })).toBe(false);
|
|
});
|
|
|
|
it("forEach should work as expected", () => {
|
|
const res = new HashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
let a = 1;
|
|
|
|
res.forEach((item) => {
|
|
expect(item.a).toEqual(a++);
|
|
});
|
|
});
|
|
|
|
it("delete should work as expected", () => {
|
|
const res = new HashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.has({ a: 1 })).toBe(true);
|
|
expect(res.delete({ a: 1 })).toBe(true);
|
|
expect(res.has({ a: 1 })).toBe(false);
|
|
|
|
expect(res.has({ a: 5 })).toBe(false);
|
|
expect(res.delete({ a: 5 })).toBe(false);
|
|
expect(res.has({ a: 5 })).toBe(false);
|
|
});
|
|
|
|
it("toggle should work as expected", () => {
|
|
const res = new HashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.has({ a: 1 })).toBe(true);
|
|
res.toggle({ a: 1 });
|
|
expect(res.has({ a: 1 })).toBe(false);
|
|
|
|
expect(res.has({ a: 6 })).toBe(false);
|
|
res.toggle({ a: 6 });
|
|
expect(res.has({ a: 6 })).toBe(true);
|
|
});
|
|
|
|
it("add should work as expected", () => {
|
|
const res = new HashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.has({ a: 6 })).toBe(false);
|
|
res.add({ a: 6 });
|
|
expect(res.has({ a: 6 })).toBe(true);
|
|
});
|
|
|
|
it("add should treat the hash to be the same as equality", () => {
|
|
const res = new HashSet([
|
|
{ a: 1, foobar: "hello" },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.has({ a: 1 })).toBe(true);
|
|
res.add({ a: 1, foobar: "goodbye" });
|
|
expect(res.has({ a: 1 })).toBe(true);
|
|
});
|
|
|
|
it("clear should work as expected", () => {
|
|
const res = new HashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.size).toBe(4);
|
|
res.clear();
|
|
expect(res.size).toBe(0);
|
|
});
|
|
|
|
it("replace should work as expected", () => {
|
|
const res = new HashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.size).toBe(4);
|
|
res.replace([{ a: 13 }]);
|
|
expect(res.size).toBe(1);
|
|
expect(res.has({ a: 1 })).toBe(false);
|
|
expect(res.has({ a: 13 })).toBe(true);
|
|
});
|
|
|
|
it("toJSON should work as expected", () => {
|
|
const res = new HashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
|
|
expect(res.toJSON()).toStrictEqual([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
]);
|
|
});
|
|
|
|
it("values should work as expected", () => {
|
|
const res = new HashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
const iter = res.values();
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 1 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 2 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 3 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 4 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: undefined,
|
|
done: true,
|
|
});
|
|
});
|
|
|
|
it("keys should work as expected", () => {
|
|
const res = new HashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
const iter = res.keys();
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 1 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 2 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 3 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: { a: 4 },
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: undefined,
|
|
done: true,
|
|
});
|
|
});
|
|
|
|
it("entries should work as expected", () => {
|
|
const res = new HashSet([
|
|
{ a: 1 },
|
|
{ a: 2 },
|
|
{ a: 3 },
|
|
{ a: 4 },
|
|
], item => item.a.toString());
|
|
const iter = res.entries();
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: [{ a: 1 }, { a: 1 }],
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: [{ a: 2 }, { a: 2 }],
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: [{ a: 3 }, { a: 3 }],
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: [{ a: 4 }, { a: 4 }],
|
|
done: false,
|
|
});
|
|
|
|
expect(iter.next()).toStrictEqual({
|
|
value: undefined,
|
|
done: true,
|
|
});
|
|
});
|
|
});
|