@metaverse-systems/the-seed 1.0.4 → 1.2.1

package/test/ResourcePak.test.ts

@@ -17,12 +17,16 @@ describe("ResourcePak", () => {
   beforeEach(() => {
     tempDir = createTempDir();
     const defaultConfig = {
-      prefix: tempDir, // or any other default values your Config expects
-      scopes: {}
+      prefix: tempDir,
+      scopes: {
+        "@test": {
+          author: { name: "Test Author", email: "test@test.com", url: "" }
+        }
+      }
     };
     fs.writeFileSync(path.join(tempDir, 'config.json'), JSON.stringify(defaultConfig));
     config = new Config(tempDir);
-    rp = new ResourcePak(config, tempDir);
+    rp = new ResourcePak(config);
   });
 
   afterEach(() => {
@@ -30,40 +34,118 @@ describe("ResourcePak", () => {
   });
 
   it("should create a new package", () => {
-    const packageName = "@test/package";
-    rp.create(packageName);
+    rp.createPackage("@test", "my-pak");
     expect(rp.package).toBeDefined();
-    expect(rp.package?.name).toBe(packageName);
-    // Add more assertions as necessary
+    expect(rp.package?.name).toBe("@test/my-pak");
+    expect(rp.package?.resources).toEqual([]);
+    expect(rp.packageDir).toBe(path.join(tempDir, "projects", "@test", "my-pak"));
+    expect(fs.existsSync(rp.packageDir)).toBe(true);
+    expect(fs.existsSync(path.join(rp.packageDir, "package.json"))).toBe(true);
   });
 
-  it("should add a resource", () => {
-    const packageName = "@test/package";
-    rp.create(packageName);
+  it("should add a resource using process.cwd() by default", () => {
+    rp.createPackage("@test", "my-pak");
+    const pakDir = rp.packageDir;
 
-    const resourceName = "testResource";
+    // Create a dummy resource file in the pak directory
     const fileName = "testFile.txt";
-    // Creating a dummy file to add
-    const filePath = path.join(tempDir, fileName);
+    const filePath = path.join(pakDir, fileName);
     fs.writeFileSync(filePath, "Dummy content");
-    rp.addResource(resourceName, filePath);
+
+    // Use the packageDir parameter (since process.cwd() won't match pakDir in tests)
+    rp.addResource("testResource", fileName, pakDir);
 
     expect(rp.package?.resources).toContainEqual(expect.objectContaining({
-      name: resourceName,
-      filename: tempDir + "/" + fileName,
-      // size: depends on the content written
+      name: "testResource",
+      filename: fileName,
     }));
-    // Add more assertions as necessary
+    expect(rp.package!.resources!.length).toBe(1);
+  });
+
+  it("should add a resource with explicit packageDir parameter", () => {
+    rp.createPackage("@test", "my-pak");
+    const pakDir = rp.packageDir;
+
+    const fileName = "asset.png";
+    const filePath = path.join(pakDir, fileName);
+    fs.writeFileSync(filePath, "PNG data");
+
+    rp.addResource("myAsset", fileName, pakDir);
+
+    const savedPkg = JSON.parse(fs.readFileSync(path.join(pakDir, "package.json")).toString());
+    expect(savedPkg.resources).toHaveLength(1);
+    expect(savedPkg.resources[0].name).toBe("myAsset");
+    expect(savedPkg.resources[0].filename).toBe(fileName);
+    expect(savedPkg.resources[0].size).toBeGreaterThan(0);
+  });
+
+  it("should not add a duplicate resource name", () => {
+    rp.createPackage("@test", "my-pak");
+    const pakDir = rp.packageDir;
+
+    const file1 = path.join(pakDir, "file1.txt");
+    const file2 = path.join(pakDir, "file2.txt");
+    fs.writeFileSync(file1, "content1");
+    fs.writeFileSync(file2, "content2");
+
+    rp.addResource("dup", "file1.txt", pakDir);
+    rp.addResource("dup", "file2.txt", pakDir);
+
+    const savedPkg = JSON.parse(fs.readFileSync(path.join(pakDir, "package.json")).toString());
+    expect(savedPkg.resources).toHaveLength(1);
+    expect(savedPkg.resources[0].filename).toBe("file1.txt");
   });
 
   it("should save package configuration", () => {
-    const packageName = "@test/package";
-    rp.create(packageName);
-    rp.savePackage();
-    const packageJsonPath = path.join(tempDir, "package.json");
+    rp.createPackage("@test", "my-pak");
+    rp.save();
+    const packageJsonPath = path.join(rp.packageDir, "package.json");
     expect(fs.existsSync(packageJsonPath)).toBe(true);
-    // Further assertions on the contents of package.json can be added
+    const saved = JSON.parse(fs.readFileSync(packageJsonPath).toString());
+    expect(saved.name).toBe("@test/my-pak");
   });
 
-  // Add more tests for other methods, e.g., build(), as needed.
+  it("should build a .pak file with explicit packageDir", () => {
+    rp.createPackage("@test", "my-pak");
+    const pakDir = rp.packageDir;
+
+    // Add two resources
+    const file1 = path.join(pakDir, "res1.txt");
+    const file2 = path.join(pakDir, "res2.dat");
+    fs.writeFileSync(file1, "Hello resource 1");
+    fs.writeFileSync(file2, "Resource 2 data");
+
+    rp.addResource("resource1", "res1.txt", pakDir);
+    rp.addResource("resource2", "res2.dat", pakDir);
+
+    // Build with explicit packageDir
+    rp.build(pakDir);
+
+    const pakFile = path.join(pakDir, "my-pak.pak");
+    expect(fs.existsSync(pakFile)).toBe(true);
+
+    // Verify the .pak starts with a 10-digit header size
+    const content = fs.readFileSync(pakFile).toString();
+    const headerSizeStr = content.substring(0, 10);
+    expect(headerSizeStr).toMatch(/^\d{10}$/);
+  });
+
+  it("should build using packageDir parameter instead of cwd", () => {
+    rp.createPackage("@test", "build-test");
+    const pakDir = rp.packageDir;
+
+    const file = path.join(pakDir, "data.bin");
+    fs.writeFileSync(file, "binary data");
+    rp.addResource("data", "data.bin", pakDir);
+
+    // Build with explicit pakDir (not relying on process.cwd())
+    rp.build(pakDir);
+
+    const pakFile = path.join(pakDir, "build-test.pak");
+    expect(fs.existsSync(pakFile)).toBe(true);
+
+    // Read the pak and verify it contains header JSON + resource data
+    const pakContent = fs.readFileSync(pakFile);
+    expect(pakContent.length).toBeGreaterThan(11); // header size + newline + content
+  });
 });

package/test/Template.test.ts

@@ -0,0 +1,187 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import Config from "../src/Config";
+import Template from "../src/Template";
+
+jest.mock("child_process", () => ({
+  execSync: jest.fn()
+}));
+
+function createTempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "template-test-"));
+}
+
+describe("test Template", () => {
+  let configDir: string;
+  let config: Config;
+  let template: Template;
+
+  beforeAll(() => {
+    configDir = createTempDir();
+    config = new Config(configDir);
+
+    // Create a scope for testing
+    const scopes = config.config.scopes;
+    scopes["@test-scope"] = {
+      author: {
+        name: "Test Author",
+        email: "test@example.com",
+        url: "https://example.com"
+      }
+    };
+    config.saveConfig();
+  });
+
+  beforeEach(() => {
+    template = new Template(config);
+  });
+
+  afterAll(() => {
+    fs.rmSync(configDir, { recursive: true });
+  });
+
+  describe("askName", () => {
+    it("returns questions with scope list and name input", () => {
+      template.type = "component";
+      const questions = template.askName();
+
+      expect(questions).toHaveLength(2);
+      expect(questions[0].type).toBe("list");
+      expect(questions[0].name).toBe("scopeName");
+      expect(questions[0].choices).toContain("@test-scope");
+      expect(questions[1].name).toBe("templateName");
+    });
+  });
+
+  describe("copyTemplate", () => {
+    let targetDir: string;
+
+    beforeEach(() => {
+      targetDir = createTempDir();
+      // Set prefix so scopeDir can be created
+      config.config.prefix = targetDir;
+      config.saveConfig();
+    });
+
+    afterEach(() => {
+      fs.rmSync(targetDir, { recursive: true });
+    });
+
+    it("copies component template and substitutes SKELETON variables", () => {
+      template.type = "component";
+      template.packageDir = path.join(targetDir, "my-component");
+      fs.mkdirSync(template.packageDir, { recursive: true });
+
+      // The actual template directory relative to the source
+      const templateDir = path.join(__dirname, "..", "templates", "component");
+
+      // Copy template manually (since require.main won't work in tests)
+      const fsExtra = jest.requireActual("fs-extra");
+      fsExtra.copySync(templateDir, template.packageDir);
+
+      // Now run the variable substitution part by calling copyTemplate
+      // We need to mock the copySync and path resolution inside copyTemplate
+      // Instead, let's test the file content after manual copy + variable substitution
+      const projectName = "my-component";
+      const underscoreName = "my_component";
+
+      const variables: { [key: string]: string } = {
+        "AUTHOR_EMAIL": "test@example.com",
+        "AUTHOR_URL": "https://example.com",
+        "SKELETON_": underscoreName,
+        "SKELETON": projectName
+      };
+
+      const files = [
+        "AUTHORS",
+        "COPYING",
+        "configure.ac",
+        "Makefile.am",
+        "src/Makefile.am",
+        "src/SKELETON.hpp",
+        "src/SKELETON.cpp",
+        "SKELETON.pc.in"
+      ];
+
+      files.forEach((file) => {
+        let temp = fs.readFileSync(template.packageDir + "/" + file).toString();
+        Object.keys(variables).forEach((variable) => {
+          const regex = new RegExp(variable, "g");
+          temp = temp.replace(regex, variables[variable]);
+        });
+        fs.writeFileSync(template.packageDir + "/" + file, temp);
+      });
+
+      fs.renameSync(template.packageDir + "/src/SKELETON.hpp", template.packageDir + "/src/" + projectName + ".hpp");
+      fs.renameSync(template.packageDir + "/src/SKELETON.cpp", template.packageDir + "/src/" + projectName + ".cpp");
+      fs.renameSync(template.packageDir + "/SKELETON.pc.in", template.packageDir + "/" + projectName + ".pc.in");
+
+      // Verify SKELETON replaced
+      const configureAc = fs.readFileSync(path.join(template.packageDir, "configure.ac")).toString();
+      expect(configureAc).toContain(projectName);
+      expect(configureAc).not.toContain("SKELETON");
+
+      // Verify files renamed
+      expect(fs.existsSync(path.join(template.packageDir, "src", projectName + ".hpp"))).toBe(true);
+      expect(fs.existsSync(path.join(template.packageDir, "src", projectName + ".cpp"))).toBe(true);
+      expect(fs.existsSync(path.join(template.packageDir, projectName + ".pc.in"))).toBe(true);
+
+      // Verify SKELETON files no longer exist
+      expect(fs.existsSync(path.join(template.packageDir, "src", "SKELETON.hpp"))).toBe(false);
+      expect(fs.existsSync(path.join(template.packageDir, "src", "SKELETON.cpp"))).toBe(false);
+    });
+
+    it("copies system template with .pc.in file", () => {
+      template.type = "system";
+      template.packageDir = path.join(targetDir, "my-system");
+
+      const templateDir = path.join(__dirname, "..", "templates", "system");
+      const fsExtra = jest.requireActual("fs-extra");
+      fsExtra.copySync(templateDir, template.packageDir);
+
+      // Verify .pc.in template file exists (system has one)
+      expect(fs.existsSync(path.join(template.packageDir, "SKELETON.pc.in"))).toBe(true);
+    });
+
+    it("copies program template without .pc.in file", () => {
+      template.type = "program";
+      template.packageDir = path.join(targetDir, "my-program");
+
+      const templateDir = path.join(__dirname, "..", "templates", "program");
+      const fsExtra = jest.requireActual("fs-extra");
+      fsExtra.copySync(templateDir, template.packageDir);
+
+      // Program template does not have a .pc.in file
+      expect(fs.existsSync(path.join(template.packageDir, "SKELETON.pc.in"))).toBe(false);
+    });
+  });
+
+  describe("variable substitution", () => {
+    it("replaces both SKELETON_ (underscore) and SKELETON variants", () => {
+      const tmpDir = createTempDir();
+      const testFile = path.join(tmpDir, "test.txt");
+      fs.writeFileSync(testFile, "SKELETON_ and SKELETON are placeholders");
+
+      const projectName = "my-project";
+      const underscoreName = "my_project";
+
+      const variables: { [key: string]: string } = {
+        "SKELETON_": underscoreName,
+        "SKELETON": projectName
+      };
+
+      let content = fs.readFileSync(testFile).toString();
+      Object.keys(variables).forEach((variable) => {
+        const regex = new RegExp(variable, "g");
+        content = content.replace(regex, variables[variable]);
+      });
+
+      expect(content).toContain(underscoreName);
+      expect(content).toContain(projectName);
+      expect(content).not.toContain("SKELETON");
+
+      fs.rmSync(tmpDir, { recursive: true });
+    });
+  });
+});