Adding workload unit tests

packages/grid_client/src/zos/znet.ts

@@ -55,4 +55,4 @@ class Znet extends WorkloadData {
   }
 }
 
-export { Znet, Peer };
+export { Znet, Peer, Mycelium };

packages/grid_client/tests/modules/workload.test.ts

@@ -0,0 +1,251 @@
+import { plainToClass } from "class-transformer";
+
+import {
+  DeploymentResult,
+  Encryption,
+  Mycelium,
+  Peer,
+  QuantumCompression,
+  QuantumSafeConfig,
+  QuantumSafeFSConfig,
+  QuantumSafeMeta,
+  ResultStates,
+  Workload,
+  WorkloadTypes,
+  ZdbBackend,
+  ZdbGroup,
+  ZdbModes,
+} from "../../src";
+import {
+  ComputeCapacity,
+  GatewayFQDNProxy,
+  GatewayNameProxy,
+  Mount,
+  PublicIP,
+  QuantumSafeFS,
+  Volume,
+  Zdb,
+  Zlogs,
+  Zmachine,
+  ZmachineNetwork,
+  Zmount,
+  Znet,
+} from "../../src";
+import { PublicIPv4 } from "../../src/zos/ipv4";
+
+let workload: Workload;
+
+const createDataInstance = (type: WorkloadTypes) => {
+  let instance;
+  const network = new ZmachineNetwork();
+  const computeCapacity = new ComputeCapacity();
+  const disks = new Mount();
+  const peer = new Peer();
+  peer.subnet = "10.0.1.0/24";
+  peer.wireguard_public_key = "9I8H7G6F5E4D3C2B1A0J";
+  peer.allowed_ips = ["10.0.1.6"];
+  peer.endpoint = "185.206.122.31:5566";
+  const mycelium = new Mycelium();
+  mycelium.hex_key = "abc123";
+
+  const rootfs_size = 2;
+  const size = 100 * 1024 ** 2;
+  const qsfsConfig = new QuantumSafeFSConfig();
+  const encryption = new Encryption();
+  const meta = new QuantumSafeMeta();
+  const config = new QuantumSafeConfig();
+  const backends = new ZdbBackend();
+  const groups = new ZdbGroup();
+  const compression = new QuantumCompression();
+  const qsfsCache = 262144000;
+
+  switch (type) {
+    case WorkloadTypes.zmachine:
+      instance = new Zmachine();
+      computeCapacity.cpu = 1;
+      computeCapacity.memory = 256 * 1024 ** 2;
+      network.planetary = true;
+      network.public_ip = "10.249.0.0/16";
+      network.interfaces = [
+        {
+          network: "znetwork",
+          ip: "10.20.2.2",
+        },
+      ];
+      network.mycelium = {
+        network: "mycelium_net",
+        hex_seed: "abc123",
+      };
+
+      disks.name = "zdisk";
+      disks.mountpoint = "/mnt/data";
+
+      instance.flist = "https://hub.grid.tf/tf-official-vms/ubuntu-22.04.flist";
+      instance.network = network;
+      instance.size = rootfs_size * 1024 ** 3;
+      instance.mounts = [disks];
+      instance.entrypoint = "/sbin/zinit init";
+      instance.compute_capacity = computeCapacity;
+      instance.env = { key: "value" };
+      instance.corex = false;
+      instance.gpu = ["AMD", "NIVIDIA"];
+      break;
+
+    case WorkloadTypes.zmount:
+      instance = new Zmount();
+      instance.size = size;
+      break;
+
+    case WorkloadTypes.volume:
+      instance = new Volume();
+      instance.size = size;
+      break;
+
+    case WorkloadTypes.network:
+      instance = new Znet();
+      instance.subnet = "10.0.0.1/32";
+      instance.ip_range = "10.0.0.2/32";
+      instance.wireguard_private_key = "2BwI0a7lVYxeKsh7jklashakdfjasdf7jksdHf";
+      instance.wireguard_listen_port = 5566;
+      instance.peers = [peer];
+      instance.mycelium = mycelium;
+      break;
+
+    case WorkloadTypes.zdb:
+      instance = new Zdb();
+      instance.size = size;
+      instance.mode = ZdbModes.user;
+      instance.password = "123456";
+      instance.public = false;
+      break;
+
+    case WorkloadTypes.ip:
+      instance = new PublicIP();
+      instance.v4 = true;
+      instance.v6 = false;
+      break;
+
+    case WorkloadTypes.ipv4:
+      instance = new PublicIPv4();
+      break;
+
+    case WorkloadTypes.qsfs:
+      instance = new QuantumSafeFS();
+
+      qsfsConfig.minimal_shards = 2;
+      qsfsConfig.expected_shards = 3;
+      qsfsConfig.redundant_groups = 0;
+      qsfsConfig.redundant_nodes = 0;
+      qsfsConfig.max_zdb_data_dir_size = 2;
+      encryption.algorithm = "algorithm";
+      encryption.key = "EncryptionKey12345678";
+      qsfsConfig.encryption = encryption;
+      meta.type = "qsfs";
+      config.prefix = "qsfs";
+      config.encryption = encryption;
+      backends.address = "localhost";
+      backends.namespace = "http://localhost";
+      backends.password = "password";
+      groups.backends = [backends];
+      qsfsConfig.groups = [groups];
+      config.backends = [backends];
+      meta.config = config;
+      qsfsConfig.meta = meta;
+      compression.algorithm = "algorithm";
+      qsfsConfig.compression = compression;
+
+      instance.cache = qsfsCache;
+      instance.config = qsfsConfig;
+      break;
+
+    case WorkloadTypes.zlogs:
+      instance = new Zlogs();
+      instance.zmachine = "zmachine";
+      instance.output = "zlog";
+      break;
+
+    case WorkloadTypes.gatewayfqdnproxy:
+      instance = new GatewayFQDNProxy();
+      instance.fqdn = "dmftv9qfff.gent02.dev.grid.tf";
+      instance.tls_passthrough = false;
+      instance.backends = ["http://185.206.122.43:80"];
+      break;
+
+    case WorkloadTypes.gatewaynameproxy:
+      instance = new GatewayNameProxy();
+      instance.name = "GatewayNameProxy";
+      instance.tls_passthrough = false;
+      instance.backends = ["http://185.206.122.43:80"];
+      break;
+
+    default:
+      throw new Error(`Invalid WorkloadType: ${type}`);
+  }
+
+  return instance;
+};
+
+describe.each(Object.values(WorkloadTypes))("Workload Tests for %s", type => {
+  beforeEach(() => {
+    const dataInstance = createDataInstance(type);
+    workload = new Workload();
+    workload.version = 1;
+    workload.name = "Test Workload";
+    workload.type = type;
+    workload.metadata = "Metadata";
+    workload.description = "A test for workload";
+    workload.data = dataInstance;
+    workload.result = new DeploymentResult();
+    workload.result.created = Date.now();
+    workload.result.state = ResultStates.ok;
+    workload.result.message = "Deployment successful";
+    workload.result.data = workload.data;
+  });
+
+  test("should create a valid Workload instance", () => {
+    expect(workload).toBeInstanceOf(Workload);
+  });
+
+  test("should handle valid Workload properties", () => {
+    expect(workload.version).toBe(1);
+    expect(workload.name).toBe("Test Workload");
+    expect(workload.type).toBe(type);
+    expect(workload.metadata).toBe("Metadata");
+    expect(workload.description).toBe("A test for workload");
+    expect(workload.result.created).toBeGreaterThan(0);
+    expect(workload.result.state).toBe(ResultStates.ok);
+    expect(workload.result.message).toBe("Deployment successful");
+  });
+
+  test("should correctly serialize and deserialize Workload", () => {
+    const serialized = JSON.stringify(workload);
+    const deserialized = plainToClass(Workload, JSON.parse(serialized));
+    expect(deserialized).toBeInstanceOf(Workload);
+    expect(deserialized).toEqual(workload);
+  });
+
+  test("should correctly compute the challenge string", () => {
+    const expectedChallenge =
+      workload.version.toString() +
+      workload.name +
+      workload.type.toString() +
+      workload.metadata +
+      workload.description +
+      workload.data.challenge();
+    console.log("data", workload.data);
+
+    expect(workload.challenge()).toBe(expectedChallenge);
+  });
+
+  test("should handle invalid DeploymentResult", () => {
+    const invalidResult = new DeploymentResult();
+    invalidResult.created = Date.now();
+    invalidResult.state = "invalid-state" as any;
+    invalidResult.message = "Deployment successful";
+    invalidResult.data = workload.data;
+
+    workload.result = invalidResult;
+
+    expect(() => workload.challenge()).not.toThrow();
+  });
+});

packages/playground/src/views/minting_view.vue

@@ -6,20 +6,10 @@
     </v-card>
     <v-alert class="mb-4 text-subtitle-2 font-weight-regular" type="info" variant="tonal">
       For more information about minting check
-      <a
-        class="app-link font-weight-medium"
-        target="_blank"
-        :href="manual.minting_process"
-        >TFT minting process.
-      </a>
+      <a class="app-link font-weight-medium" target="_blank" :href="manual.minting_process">TFT minting process. </a>
       <br />
       The user can verify the 3Nodes' payments on Stellar Blockchain through the Threefold's
-      <a
-        class="app-link font-weight-medium"
-        target="_blank"
-        :href="manual.minting_reports"
-        >minting tool.
-      </a>
+      <a class="app-link font-weight-medium" target="_blank" :href="manual.minting_reports">minting tool. </a>
       <br />
       TFT minting address on Stellar Chain:
       <a