689 lines
22 KiB
TypeScript
689 lines
22 KiB
TypeScript
/**
|
|
* Mixed Case Paths Sync Tests
|
|
*
|
|
* Tests sync pull/push operations with folder paths containing capital letters.
|
|
* This is critical for Windows compatibility testing since Windows has
|
|
* case-insensitive file systems which can cause issues with paths like:
|
|
* f/MyFolder/MyScript
|
|
*
|
|
* The test verifies that:
|
|
* 1. Resources with mixed-case paths can be pulled correctly
|
|
* 2. Modifications to those files can be pushed back
|
|
* 3. The modifications are correctly applied on the server
|
|
*/
|
|
|
|
import { expect, test } from "bun:test";
|
|
import * as path from "node:path";
|
|
import { writeFile, readFile, stat } from "node:fs/promises";
|
|
import { withTestBackend } from "./test_backend.ts";
|
|
import { addWorkspace } from "../workspace.ts";
|
|
import { parseJsonFromCLIOutput } from "./test_config_helpers.ts";
|
|
|
|
// =============================================================================
|
|
// HELPER FUNCTIONS
|
|
// =============================================================================
|
|
|
|
async function setupWorkspaceProfile(backend: any): Promise<void> {
|
|
const testWorkspace = {
|
|
remote: backend.baseUrl,
|
|
workspaceId: backend.workspace,
|
|
name: "localhost_test",
|
|
token: backend.token,
|
|
};
|
|
|
|
await addWorkspace(testWorkspace, { force: true, configDir: backend.testConfigDir });
|
|
}
|
|
|
|
async function createFolder(backend: any, name: string): Promise<void> {
|
|
const response = await backend.apiRequest!(`/api/w/${backend.workspace}/folders/create`, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({ name }),
|
|
});
|
|
if (!response.ok) {
|
|
const error = await response.text();
|
|
if (!error.includes("already exists")) {
|
|
throw new Error(`Failed to create folder ${name}: ${error}`);
|
|
}
|
|
} else {
|
|
await response.text();
|
|
}
|
|
}
|
|
|
|
async function createScript(
|
|
backend: any,
|
|
scriptPath: string,
|
|
content: string,
|
|
summary: string = "Test script"
|
|
): Promise<void> {
|
|
const script = {
|
|
path: scriptPath,
|
|
summary,
|
|
description: `Script at ${scriptPath}`,
|
|
content,
|
|
language: "bun",
|
|
is_template: false,
|
|
kind: "script",
|
|
// Provide a non-empty lock to prevent async lock generation by the backend
|
|
// worker, which causes flaky tests due to race conditions on Windows CI.
|
|
lock: "\n",
|
|
schema: {
|
|
$schema: "https://json-schema.org/draft/2020-12/schema",
|
|
type: "object",
|
|
properties: {},
|
|
required: [],
|
|
},
|
|
};
|
|
|
|
const response = await backend.apiRequest!(`/api/w/${backend.workspace}/scripts/create`, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify(script),
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const error = await response.text();
|
|
throw new Error(`Failed to create script ${scriptPath}: ${error}`);
|
|
}
|
|
await response.text();
|
|
}
|
|
|
|
async function createFlow(
|
|
backend: any,
|
|
flowPath: string,
|
|
inlineScriptContent: string,
|
|
summary: string = "Test flow"
|
|
): Promise<void> {
|
|
const flow = {
|
|
path: flowPath,
|
|
summary,
|
|
description: `Flow at ${flowPath}`,
|
|
value: {
|
|
modules: [
|
|
{
|
|
id: "a",
|
|
value: {
|
|
type: "rawscript",
|
|
content: inlineScriptContent,
|
|
language: "bun",
|
|
input_transforms: {},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
schema: {
|
|
$schema: "https://json-schema.org/draft/2020-12/schema",
|
|
type: "object",
|
|
properties: {},
|
|
required: [],
|
|
},
|
|
};
|
|
|
|
const response = await backend.apiRequest!(`/api/w/${backend.workspace}/flows/create`, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify(flow),
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const error = await response.text();
|
|
throw new Error(`Failed to create flow ${flowPath}: ${error}`);
|
|
}
|
|
await response.text();
|
|
}
|
|
|
|
async function createApp(
|
|
backend: any,
|
|
appPath: string,
|
|
summary: string = "Test app"
|
|
): Promise<void> {
|
|
const app = {
|
|
path: appPath,
|
|
summary,
|
|
policy: {
|
|
execution_mode: "viewer",
|
|
},
|
|
value: {
|
|
grid: [],
|
|
hiddenInlineScripts: [],
|
|
css: {},
|
|
norefreshbar: false,
|
|
},
|
|
};
|
|
|
|
const response = await backend.apiRequest!(`/api/w/${backend.workspace}/apps/create`, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify(app),
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const error = await response.text();
|
|
throw new Error(`Failed to create app ${appPath}: ${error}`);
|
|
}
|
|
await response.text();
|
|
}
|
|
|
|
async function createVariable(
|
|
backend: any,
|
|
varPath: string,
|
|
value: string,
|
|
description: string = "Test variable"
|
|
): Promise<void> {
|
|
const response = await backend.apiRequest!(`/api/w/${backend.workspace}/variables/create`, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({
|
|
path: varPath,
|
|
value,
|
|
is_secret: false,
|
|
description,
|
|
}),
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const error = await response.text();
|
|
throw new Error(`Failed to create variable ${varPath}: ${error}`);
|
|
}
|
|
await response.text();
|
|
}
|
|
|
|
async function createResource(
|
|
backend: any,
|
|
resourcePath: string,
|
|
resourceType: string,
|
|
value: Record<string, unknown>,
|
|
description: string = "Test resource"
|
|
): Promise<void> {
|
|
const response = await backend.apiRequest!(`/api/w/${backend.workspace}/resources/create`, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({
|
|
path: resourcePath,
|
|
resource_type: resourceType,
|
|
value,
|
|
description,
|
|
}),
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const error = await response.text();
|
|
throw new Error(`Failed to create resource ${resourcePath}: ${error}`);
|
|
}
|
|
await response.text();
|
|
}
|
|
|
|
async function getScript(backend: any, scriptPath: string): Promise<any> {
|
|
const response = await backend.apiRequest!(`/api/w/${backend.workspace}/scripts/get/p/${encodeURIComponent(scriptPath)}`);
|
|
if (!response.ok) {
|
|
throw new Error(`Failed to get script ${scriptPath}: ${response.status}`);
|
|
}
|
|
return response.json();
|
|
}
|
|
|
|
async function getFlow(backend: any, flowPath: string): Promise<any> {
|
|
const response = await backend.apiRequest!(`/api/w/${backend.workspace}/flows/get/${encodeURIComponent(flowPath)}`);
|
|
if (!response.ok) {
|
|
throw new Error(`Failed to get flow ${flowPath}: ${response.status}`);
|
|
}
|
|
return response.json();
|
|
}
|
|
|
|
async function getApp(backend: any, appPath: string): Promise<any> {
|
|
const response = await backend.apiRequest!(`/api/w/${backend.workspace}/apps/get/p/${encodeURIComponent(appPath)}`);
|
|
if (!response.ok) {
|
|
throw new Error(`Failed to get app ${appPath}: ${response.status}`);
|
|
}
|
|
return response.json();
|
|
}
|
|
|
|
async function getVariable(backend: any, varPath: string): Promise<any> {
|
|
const response = await backend.apiRequest!(`/api/w/${backend.workspace}/variables/get/${encodeURIComponent(varPath)}`);
|
|
if (!response.ok) {
|
|
throw new Error(`Failed to get variable ${varPath}: ${response.status}`);
|
|
}
|
|
return response.json();
|
|
}
|
|
|
|
/**
|
|
* Helper to verify that a subsequent pull detects no changes (idempotency check)
|
|
*/
|
|
async function verifyNoDiffOnPull(backend: any, tempDir: string): Promise<void> {
|
|
const pullResult = await backend.runCLICommand(
|
|
["sync", "pull", "--yes", "--dry-run", "--json-output"],
|
|
tempDir
|
|
);
|
|
expect(pullResult.code).toEqual(0);
|
|
|
|
const output = parseJsonFromCLIOutput(pullResult.stdout);
|
|
const changes = output.changes || [];
|
|
|
|
if (changes.length > 0) {
|
|
console.error(
|
|
`Unexpected changes on dry-run pull (expected 0, got ${changes.length}):`,
|
|
JSON.stringify(changes, null, 2)
|
|
);
|
|
}
|
|
expect(changes.length).toEqual(0);
|
|
}
|
|
|
|
// =============================================================================
|
|
// TESTS
|
|
// =============================================================================
|
|
|
|
test("Mixed Case Paths: pull and push script with capitalized folder", async () => {
|
|
await withTestBackend(async (backend, tempDir) => {
|
|
await setupWorkspaceProfile(backend);
|
|
|
|
// Create folder with mixed case
|
|
await createFolder(backend, "MyFolder");
|
|
|
|
// Create a script with mixed-case path
|
|
const scriptPath = "f/MyFolder/MyScript";
|
|
const originalContent = `export async function main() {
|
|
return "original content";
|
|
}`;
|
|
await createScript(backend, scriptPath, originalContent, "My Test Script");
|
|
|
|
// Create wmill.yaml
|
|
await writeFile(
|
|
path.join(tempDir, "wmill.yaml"),
|
|
`defaultTs: bun
|
|
includes:
|
|
- "**"
|
|
excludes: []
|
|
`,
|
|
"utf-8"
|
|
);
|
|
|
|
// Pull
|
|
const pullResult = await backend.runCLICommand(["sync", "pull", "--yes"], tempDir);
|
|
expect(pullResult.code).toEqual(0);
|
|
|
|
// Verify file exists with correct path (normalized for comparison)
|
|
const expectedScriptPath = path.join(tempDir, "f", "MyFolder", "MyScript.ts");
|
|
const scriptExists = await stat(expectedScriptPath).then(() => true).catch(() => false);
|
|
expect(scriptExists).toBeTruthy();
|
|
|
|
// Read and verify content
|
|
const pulledContent = await readFile(expectedScriptPath, "utf-8");
|
|
expect(pulledContent.includes("original content")).toBeTruthy();
|
|
|
|
// Modify the script
|
|
const modifiedContent = `export async function main() {
|
|
return "modified content from test";
|
|
}`;
|
|
await writeFile(expectedScriptPath, modifiedContent, "utf-8");
|
|
|
|
// Push
|
|
const pushResult = await backend.runCLICommand(["sync", "push", "--yes"], tempDir);
|
|
expect(pushResult.code).toEqual(0);
|
|
|
|
// Verify modification on server
|
|
const updatedScript = await getScript(backend, scriptPath);
|
|
expect(
|
|
updatedScript.content.includes("modified content from test")
|
|
).toBeTruthy();
|
|
|
|
// Verify no diff on subsequent pull (idempotency)
|
|
await verifyNoDiffOnPull(backend, tempDir);
|
|
});
|
|
});
|
|
|
|
test("Mixed Case Paths: pull and push flow with capitalized folder", async () => {
|
|
await withTestBackend(async (backend, tempDir) => {
|
|
await setupWorkspaceProfile(backend);
|
|
|
|
// Create folder with mixed case
|
|
await createFolder(backend, "MyFlows");
|
|
|
|
// Create a flow with mixed-case path
|
|
const flowPath = "f/MyFlows/DataProcessor";
|
|
const originalContent = `export async function main() {
|
|
return "original flow step";
|
|
}`;
|
|
await createFlow(backend, flowPath, originalContent, "Data Processor Flow");
|
|
|
|
// Create wmill.yaml
|
|
await writeFile(
|
|
path.join(tempDir, "wmill.yaml"),
|
|
`defaultTs: bun
|
|
includes:
|
|
- "**"
|
|
excludes: []
|
|
`,
|
|
"utf-8"
|
|
);
|
|
|
|
// Pull
|
|
const pullResult = await backend.runCLICommand(["sync", "pull", "--yes"], tempDir);
|
|
expect(pullResult.code).toEqual(0);
|
|
|
|
// Verify flow directory exists
|
|
const flowDir = path.join(tempDir, "f", "MyFlows", "DataProcessor.flow");
|
|
const flowDirExists = await stat(flowDir).then(s => s.isDirectory()).catch(() => false);
|
|
expect(flowDirExists).toBeTruthy();
|
|
|
|
// Modify the flow metadata (summary) instead of inline script
|
|
const flowMetadataPath = path.join(flowDir, "flow.yaml");
|
|
const flowMetadataExists = await stat(flowMetadataPath).then(() => true).catch(() => false);
|
|
expect(flowMetadataExists).toBeTruthy();
|
|
|
|
const flowMetadata = await readFile(flowMetadataPath, "utf-8");
|
|
const modifiedMetadata = flowMetadata.replace(
|
|
/summary:.*$/m,
|
|
'summary: "Modified Data Processor Flow from test"'
|
|
);
|
|
await writeFile(flowMetadataPath, modifiedMetadata, "utf-8");
|
|
|
|
// Push
|
|
const pushResult = await backend.runCLICommand(["sync", "push", "--yes"], tempDir);
|
|
expect(pushResult.code).toEqual(0);
|
|
|
|
// Verify modification on server
|
|
const updatedFlow = await getFlow(backend, flowPath);
|
|
expect(updatedFlow.summary).toEqual("Modified Data Processor Flow from test");
|
|
|
|
// Verify no diff on subsequent pull (idempotency)
|
|
await verifyNoDiffOnPull(backend, tempDir);
|
|
});
|
|
});
|
|
|
|
test("Mixed Case Paths: pull and push app with capitalized folder", async () => {
|
|
await withTestBackend(async (backend, tempDir) => {
|
|
await setupWorkspaceProfile(backend);
|
|
|
|
// Create folder with mixed case
|
|
await createFolder(backend, "MyApps");
|
|
|
|
// Create an app with mixed-case path
|
|
const appPath = "f/MyApps/Dashboard";
|
|
await createApp(backend, appPath, "My Dashboard App");
|
|
|
|
// Create wmill.yaml
|
|
await writeFile(
|
|
path.join(tempDir, "wmill.yaml"),
|
|
`defaultTs: bun
|
|
includes:
|
|
- "**"
|
|
excludes: []
|
|
`,
|
|
"utf-8"
|
|
);
|
|
|
|
// Pull
|
|
const pullResult = await backend.runCLICommand(["sync", "pull", "--yes"], tempDir);
|
|
expect(pullResult.code).toEqual(0);
|
|
|
|
// Verify app directory exists
|
|
const appDir = path.join(tempDir, "f", "MyApps", "Dashboard.app");
|
|
const appDirExists = await stat(appDir).then(s => s.isDirectory()).catch(() => false);
|
|
expect(appDirExists).toBeTruthy();
|
|
|
|
// Modify the app metadata
|
|
const appMetadataPath = path.join(appDir, "app.yaml");
|
|
const appMetadata = await readFile(appMetadataPath, "utf-8");
|
|
const modifiedMetadata = appMetadata.replace(
|
|
/summary:.*$/m,
|
|
'summary: "Modified Dashboard App from test"'
|
|
);
|
|
await writeFile(appMetadataPath, modifiedMetadata, "utf-8");
|
|
|
|
// Push
|
|
const pushResult = await backend.runCLICommand(["sync", "push", "--yes"], tempDir);
|
|
expect(pushResult.code).toEqual(0);
|
|
|
|
// Verify modification on server
|
|
const updatedApp = await getApp(backend, appPath);
|
|
expect(updatedApp.summary).toEqual("Modified Dashboard App from test");
|
|
|
|
// Verify no diff on subsequent pull (idempotency)
|
|
await verifyNoDiffOnPull(backend, tempDir);
|
|
});
|
|
});
|
|
|
|
test("Mixed Case Paths: pull and push variable with capitalized folder", async () => {
|
|
await withTestBackend(async (backend, tempDir) => {
|
|
await setupWorkspaceProfile(backend);
|
|
|
|
// Create folder with mixed case
|
|
await createFolder(backend, "MyVars");
|
|
|
|
// Create a variable with mixed-case path
|
|
const varPath = "f/MyVars/ApiKey";
|
|
await createVariable(backend, varPath, "original-api-key-value", "API Key Variable");
|
|
|
|
// Create wmill.yaml
|
|
await writeFile(
|
|
path.join(tempDir, "wmill.yaml"),
|
|
`defaultTs: bun
|
|
includes:
|
|
- "**"
|
|
excludes: []
|
|
`,
|
|
"utf-8"
|
|
);
|
|
|
|
// Pull
|
|
const pullResult = await backend.runCLICommand(["sync", "pull", "--yes"], tempDir);
|
|
expect(pullResult.code).toEqual(0);
|
|
|
|
// Verify variable file exists
|
|
const varFilePath = path.join(tempDir, "f", "MyVars", "ApiKey.variable.yaml");
|
|
const varExists = await stat(varFilePath).then(() => true).catch(() => false);
|
|
expect(varExists).toBeTruthy();
|
|
|
|
// Modify the variable
|
|
const varContent = await readFile(varFilePath, "utf-8");
|
|
const modifiedVarContent = varContent.replace(
|
|
/value:.*$/m,
|
|
'value: "modified-api-key-from-test"'
|
|
);
|
|
await writeFile(varFilePath, modifiedVarContent, "utf-8");
|
|
|
|
// Push
|
|
const pushResult = await backend.runCLICommand(["sync", "push", "--yes"], tempDir);
|
|
expect(pushResult.code).toEqual(0);
|
|
|
|
// Verify modification on server
|
|
const updatedVar = await getVariable(backend, varPath);
|
|
expect(updatedVar.value).toEqual("modified-api-key-from-test");
|
|
|
|
// Verify no diff on subsequent pull (idempotency)
|
|
await verifyNoDiffOnPull(backend, tempDir);
|
|
});
|
|
});
|
|
|
|
test("Mixed Case Paths: deeply nested capitalized folders", async () => {
|
|
await withTestBackend(async (backend, tempDir) => {
|
|
await setupWorkspaceProfile(backend);
|
|
|
|
// Create nested folders with mixed case
|
|
// Note: Windmill folders are flat, so we create a folder with slashes in the name
|
|
// The actual nesting is in the path structure
|
|
await createFolder(backend, "MyProject");
|
|
|
|
// Create a script with deeply nested mixed-case path
|
|
const scriptPath = "f/MyProject/SubFolder_A";
|
|
const originalContent = `export async function main() {
|
|
return "deeply nested original";
|
|
}`;
|
|
await createScript(backend, scriptPath, originalContent, "Nested Script");
|
|
|
|
// Create wmill.yaml
|
|
await writeFile(
|
|
path.join(tempDir, "wmill.yaml"),
|
|
`defaultTs: bun
|
|
includes:
|
|
- "**"
|
|
excludes: []
|
|
`,
|
|
"utf-8"
|
|
);
|
|
|
|
// Pull
|
|
const pullResult = await backend.runCLICommand(["sync", "pull", "--yes"], tempDir);
|
|
expect(pullResult.code).toEqual(0);
|
|
|
|
// Verify file exists
|
|
const scriptFilePath = path.join(tempDir, "f", "MyProject", "SubFolder_A.ts");
|
|
const scriptExists = await stat(scriptFilePath).then(() => true).catch(() => false);
|
|
expect(scriptExists).toBeTruthy();
|
|
|
|
// Modify
|
|
const modifiedContent = `export async function main() {
|
|
return "deeply nested modified from test";
|
|
}`;
|
|
await writeFile(scriptFilePath, modifiedContent, "utf-8");
|
|
|
|
// Push
|
|
const pushResult = await backend.runCLICommand(["sync", "push", "--yes"], tempDir);
|
|
expect(pushResult.code).toEqual(0);
|
|
|
|
// Verify on server
|
|
const updatedScript = await getScript(backend, scriptPath);
|
|
expect(
|
|
updatedScript.content.includes("deeply nested modified from test")
|
|
).toBeTruthy();
|
|
|
|
// Verify no diff on subsequent pull (idempotency)
|
|
await verifyNoDiffOnPull(backend, tempDir);
|
|
});
|
|
});
|
|
|
|
test("Mixed Case Paths: multiple resources in same capitalized folder", async () => {
|
|
await withTestBackend(async (backend, tempDir) => {
|
|
await setupWorkspaceProfile(backend);
|
|
|
|
// Create folder with mixed case
|
|
await createFolder(backend, "SharedFolder");
|
|
|
|
// Create multiple resources in the same folder
|
|
await createScript(
|
|
backend,
|
|
"f/SharedFolder/ScriptOne",
|
|
'export async function main() { return "script one original"; }',
|
|
"Script One"
|
|
);
|
|
await createScript(
|
|
backend,
|
|
"f/SharedFolder/ScriptTwo",
|
|
'export async function main() { return "script two original"; }',
|
|
"Script Two"
|
|
);
|
|
await createVariable(backend, "f/SharedFolder/VarOne", "var-one-original");
|
|
await createResource(backend, "f/SharedFolder/ResourceOne", "any", { key: "original" });
|
|
|
|
// Create wmill.yaml
|
|
await writeFile(
|
|
path.join(tempDir, "wmill.yaml"),
|
|
`defaultTs: bun
|
|
includes:
|
|
- "**"
|
|
excludes: []
|
|
`,
|
|
"utf-8"
|
|
);
|
|
|
|
// Pull
|
|
const pullResult = await backend.runCLICommand(["sync", "pull", "--yes"], tempDir);
|
|
expect(pullResult.code).toEqual(0);
|
|
|
|
// Verify all files exist
|
|
const folderPath = path.join(tempDir, "f", "SharedFolder");
|
|
const script1Exists = await stat(path.join(folderPath, "ScriptOne.ts")).then(() => true).catch(() => false);
|
|
const script2Exists = await stat(path.join(folderPath, "ScriptTwo.ts")).then(() => true).catch(() => false);
|
|
const var1Exists = await stat(path.join(folderPath, "VarOne.variable.yaml")).then(() => true).catch(() => false);
|
|
const res1Exists = await stat(path.join(folderPath, "ResourceOne.resource.yaml")).then(() => true).catch(() => false);
|
|
|
|
expect(script1Exists).toBeTruthy();
|
|
expect(script2Exists).toBeTruthy();
|
|
expect(var1Exists).toBeTruthy();
|
|
expect(res1Exists).toBeTruthy();
|
|
|
|
// Modify script one
|
|
await writeFile(
|
|
path.join(folderPath, "ScriptOne.ts"),
|
|
'export async function main() { return "script one MODIFIED"; }',
|
|
"utf-8"
|
|
);
|
|
|
|
// Modify script two
|
|
await writeFile(
|
|
path.join(folderPath, "ScriptTwo.ts"),
|
|
'export async function main() { return "script two MODIFIED"; }',
|
|
"utf-8"
|
|
);
|
|
|
|
// Push
|
|
const pushResult = await backend.runCLICommand(["sync", "push", "--yes"], tempDir);
|
|
expect(pushResult.code).toEqual(0);
|
|
|
|
// Verify modifications on server
|
|
const script1 = await getScript(backend, "f/SharedFolder/ScriptOne");
|
|
const script2 = await getScript(backend, "f/SharedFolder/ScriptTwo");
|
|
|
|
expect(script1.content.includes("script one MODIFIED")).toBeTruthy();
|
|
expect(script2.content.includes("script two MODIFIED")).toBeTruthy();
|
|
|
|
// Verify no diff on subsequent pull (idempotency)
|
|
await verifyNoDiffOnPull(backend, tempDir);
|
|
});
|
|
});
|
|
|
|
test("Mixed Case Paths: CamelCase folder names with numbers", async () => {
|
|
await withTestBackend(async (backend, tempDir) => {
|
|
await setupWorkspaceProfile(backend);
|
|
|
|
// Create folder with CamelCase and numbers
|
|
await createFolder(backend, "Project2024");
|
|
|
|
// Create script
|
|
const scriptPath = "f/Project2024/DataHandler_V2";
|
|
await createScript(
|
|
backend,
|
|
scriptPath,
|
|
'export async function main() { return "handler v2 original"; }',
|
|
"Data Handler V2"
|
|
);
|
|
|
|
// Create wmill.yaml
|
|
await writeFile(
|
|
path.join(tempDir, "wmill.yaml"),
|
|
`defaultTs: bun
|
|
includes:
|
|
- "**"
|
|
excludes: []
|
|
`,
|
|
"utf-8"
|
|
);
|
|
|
|
// Pull
|
|
const pullResult = await backend.runCLICommand(["sync", "pull", "--yes"], tempDir);
|
|
expect(pullResult.code).toEqual(0);
|
|
|
|
// Verify file exists
|
|
const scriptFilePath = path.join(tempDir, "f", "Project2024", "DataHandler_V2.ts");
|
|
const scriptExists = await stat(scriptFilePath).then(() => true).catch(() => false);
|
|
expect(scriptExists).toBeTruthy();
|
|
|
|
// Modify
|
|
await writeFile(
|
|
scriptFilePath,
|
|
'export async function main() { return "handler v2 MODIFIED"; }',
|
|
"utf-8"
|
|
);
|
|
|
|
// Push
|
|
const pushResult = await backend.runCLICommand(["sync", "push", "--yes"], tempDir);
|
|
expect(pushResult.code).toEqual(0);
|
|
|
|
// Verify on server
|
|
const updatedScript = await getScript(backend, scriptPath);
|
|
expect(updatedScript.content.includes("handler v2 MODIFIED")).toBeTruthy();
|
|
|
|
// Verify no diff on subsequent pull (idempotency)
|
|
await verifyNoDiffOnPull(backend, tempDir);
|
|
});
|
|
});
|