feat(variables): persist scripted variable changes by default + re-enable disabled scripting APIs (#8315)

* feat(variables): add variable persistence with scripting

feat(collections): implement script-driven update for collection variables, ensuring direct root modification and draft synchronization

feat(collections): enhance script variable management with baseline tracking and draft preservation

* feat(variables): add runtime variable updates and optimize disk writes by implementing dirty flags

fix(collections): handle errors during environment persistence in script execution

feat(collections): implement baseline clearing for script execution and optimize variable update handling

feat(tests): add default persistence tests for environment variables and update runtime variable handling

refactor(collections): streamline variable update handling and improve draft management by removing redundant comments and optimizing code clarity

test(collection-vars): add verification for draft edits and script variable visibility in collection settings UI

refactor(collection-vars): update header value selection logic for improved clarity and accuracy in draft isolation tests

* feat(global-environments): enhance global environment updates to resolve stale active UIDs and improve persistence logic

- Updated the `updateGlobalEnvironments` reducer to handle stale active UIDs by matching against environment names.
- Improved the logic for setting global environments and active UIDs to ensure consistency after disk reloads.
- Removed outdated tests related to persisted values in favor of more relevant assertions for environment variable handling.

* feat(variables): enhance typed value handling and persistence in global and collection environments

- Added tests to infer data types (number, boolean, object) when setting environment and collection variables.
- Updated the logic to preserve existing data types when variables are not modified by scripts.
- Implemented dirty flags to track changes in typed variables, ensuring accurate persistence across sessions.
- Refactored related tests to verify the correct behavior of typed variables in various scenarios.

* refactor(variables): streamline data type inference and enhance deletion methods

- Removed redundant data type inference logic from global and collection variable updates to simplify the codebase.
- Updated deletion methods in the Bru class to use Object.keys for improved resilience against user-defined properties.
- Added tests to ensure deletion methods function correctly even when properties are shadowed.
- Enhanced clarity in draft merge tests by standardizing keyboard shortcuts for selecting all text.

* fix(tests): correct variable naming and improve environment panel interactions

- Updated test cases to reflect the correct variable name 'wasSaved' instead of 'was-saved'.
- Modified environment panel interaction to remove forced click, enhancing test reliability.
- Added a utility function to close the environment panel in safe mode tests for better readability and maintainability.

* feat(runtime): enhance variable management and cleanup logic

- Introduced a new method to clear script-driven variable baselines for collections, ensuring no stale data leaks into new requests.
- Updated the handling of runtime variables in the Bru class to track changes with a new dirty flag, improving state management.
- Refactored the application of script environment variables to prevent direct mutations, ensuring immutability and cleaner state updates.
- Enhanced the response handling in the script runtime to conditionally include runtime variables based on their dirty state.

* feat(variables): improve request handling and state management for collections and environments

- Enhanced event listeners to clear global environment baselines on both 'testrun-started' and 'request-queued' events, preventing stale data issues.
- Updated global environment and collection variable update events to ignore stale updates from superseded requests, ensuring accurate state management.
- Refactored the Bru class to optimize variable management, including checks for existing keys before updates and deletions, improving performance and reliability.
- Introduced request UID tracking to maintain consistency across variable updates during concurrent requests.

* refactor(collections): update action to clear script variable baselines

- Replaced the dispatch of `_clearScriptGlobalEnvBaseline` with `clearScriptVariableBaselines` to improve clarity and maintainability in the Redux action handling for collections.

* feat(environments): introduce getScriptModifiedKeys utility for improved variable management

- Added a new utility function, `getScriptModifiedKeys`, to identify keys modified by scripts relative to a baseline, enhancing the handling of data types during variable updates.
- Updated the application of script environment variables to prevent overwriting user-defined draft changes during no-op writes.
- Refactored related logic in collections and global environments to utilize the new utility, ensuring accurate state management and improved clarity in the Redux slices.

* refactor(global-environments): simplify active UID resolution logic in updateGlobalEnvironments reducer

- Streamlined the logic for resolving the active global environment UID by consolidating conditions into a more concise format.
- Removed outdated comments to enhance code clarity and maintainability.
- Updated tests to ensure accurate resolution of active UIDs based on incoming environment data.

* refactor(tests): remove outdated comments and streamline environment variable row expectations

- Eliminated comments related to state sync and inference issues to enhance code clarity.
- Adjusted expectations for environment variable row rendering in tests, focusing on relevant assertions.

* feat(tests): add comprehensive tests for secret variable persistence in environments

- Introduced new test cases to validate the preservation of secret variables when updated via scripts in both collection and global environments.
- Implemented tests to ensure that secret values are encrypted before storage and can be correctly decrypted for subsequent requests.
- Added fixtures and environment configurations for testing secret variable behavior in both bru and yml formats.
- Enhanced utility functions for managing environment configurations and interactions within the test suite.

* feat(tests): enhance environment variable tests and add global variable persistence

- Updated MultiLineEditor and SingleLineEditor components to include data-testid for secret reveal toggle buttons, improving testability.
- Introduced new tests for global environment variable persistence, ensuring non-secret variables survive app restarts and are correctly interpolated.
- Added fixtures for workspace and collections to support the new global variable tests, enhancing the overall test coverage for environment management.
- Refactored utility functions to streamline interactions with environment variables in tests.

* refactor(collections): optimize environment and collection saving logic

- Simplified the persistence logic for active environments by directly constructing the environment copy, reducing unnecessary cloning.
- Updated the collection saving process to utilize the fresh collection state, ensuring accurate data is saved without drafts.
- Enhanced error handling during the save operations to improve reliability and maintainability.

* feat(tests): implement collection variable persistence tests

- Added multiple test cases to validate the persistence of collection variables across app restarts, including typed values and multiple variable settings.
- Created new fixtures for collection variables to support the tests, ensuring accurate simulation of variable management scenarios.
- Enhanced the existing collection management logic to ensure that variables are correctly set and deleted as per the test requirements.

* feat(tests): add tests for typed global environment variable persistence

- Introduced a new test suite to validate the persistence of typed global environment variables across app restarts, ensuring correct data types are maintained.
- Created a fixture for the test collection to simulate setting global variables with various data types, including number, boolean, object, and string.
- Enhanced the test logic to verify that the environment file reflects the correct state before and after application restarts.

* fix(tests): update request tab close interaction in variable persistence tests

* fix(tests): improve hover interaction for collection actions in runner tests

- Updated the hover logic for revealing collection actions to handle sidebar re-renders more reliably.
- Replaced one-shot hover with a polling mechanism to ensure visibility of actions, enhancing test stability.

* refactor(environments): streamline environment variable handling and remove ephemeral metadata logic

- Simplified the comparison logic for environment variables by removing unnecessary ephemeral metadata handling.
- Updated the saving process to directly use the environment variables without stripping metadata, enhancing clarity and maintainability.
- Removed outdated comments and unused utility functions related to ephemeral variables, improving code cleanliness.

* fix(ipc): update persistActiveEnvironment to handle requestUid for stale updates

- Modified the persistActiveEnvironment function to accept a requestUid parameter, allowing for better management of stale updates.
- Enhanced the logic to prevent disk writes for superseded requests, improving data integrity during environment persistence.

* refactor(bru): remove unused envName variable in deleteAllEnvVars method

- Eliminated the envName variable from the deleteAllEnvVars method, simplifying the logic for deleting environment variables.
- Cleaned up the method by removing unnecessary checks related to the envName, enhancing code clarity and maintainability.

* fix(bru): prevent deletion of internal __name__ variable in deleteEnvVar method

- Added a check in the deleteEnvVar method to silently ignore attempts to delete the internal __name__ variable, preserving its integrity.
- Updated tests to verify that the __name__ variable remains unchanged when deleteEnvVar is called with this key.
- Enhanced runtime tests to ensure compatibility with QuickJS by confirming that environment variables set with persist options are handled correctly.

* feat(tests): add legacy support test for environment variable persistence

- Introduced a new test suite to validate that the legacy argument for setting environment variables with persistence is still functional in version 4.
- Created a fixture to simulate the legacy syntax, ensuring that the variable is correctly persisted on disk without errors.
- Enhanced integration testing to confirm that the legacy behavior aligns with the current implementation, maintaining backward compatibility.

* test(tests): enhance legacy environment variable persistence tests for safe and developer modes

- Updated the test suite for `bru.setEnvVar` to verify that the legacy persist flag is correctly handled in both safe and developer modes.
- Introduced a helper function to streamline the verification process and ensure consistent behavior across different execution contexts.
- Adjusted the test logic to reset the environment state between mode switches, maintaining test integrity.
- Improved hover interaction in multiple persistent variable tests to ensure reliable visibility of actions during execution.

* fix(EnvironmentVariablesTable): correct change detection logic for environment variables

- Updated the logic for determining changes in environment variables to compare active current and saved values instead of previously used variablesToSave and savedValues.
- This change ensures accurate detection of modifications before saving, improving user feedback when no changes are present.

* test(tests): enhance secret variable persistence tests for environment configurations

- Updated the test suites for `bru.setEnvVar` and `bru.setGlobalEnvVar` to include interactions with the secrets tab, ensuring visibility of secret variables during various states of the environment.
- Added checks to confirm that the eye toggle functionality correctly reveals the values of secret variables after setting and overwriting them.
- Improved test coverage for secret variable persistence, validating that the expected values are displayed in both collection and global environment contexts.
This commit is contained in:
sanish chirayath
2026-06-26 23:01:37 +05:30
committed by GitHub
parent 30b4512983
commit 87f74262bb
171 changed files with 7138 additions and 1018 deletions

View File

@@ -1,63 +1,48 @@
import { test, expect, closeElectronApp } from '../../../playwright';
import { sendRequest, waitForReadyPage } from '../../utils/page';
import fs from 'fs';
import path from 'path';
import { test, expect } from '../../../playwright';
import { sendRequest, setSandboxMode } from '../../utils/page';
import { buildCommonLocators } from '../../utils/page/locators';
test.describe.serial('bru.setEnvVar(name, value, { persist: true })', () => {
test('set env var with persist using script', async ({ pageWithUserData: page, restartApp }) => {
// Select the collection and request
await page.locator('#sidebar-collection-name').click();
await page.getByText('api-setEnvVar-with-persist', { exact: true }).click();
test.describe('bru.setEnvVar(name, value, { persist: true }) - legacy arg', () => {
test('legacy persist flag is silently ignored and the var persists in both safe and developer mode', async ({
pageWithUserData: page,
collectionFixturePath
}) => {
const stageBruPath = path.join(collectionFixturePath!, 'environments', 'Stage.bru');
const stageOriginal = fs.readFileSync(stageBruPath, 'utf8');
const locators = buildCommonLocators(page);
// open environment dropdown
await page.getByTestId('environment-selector-trigger').click();
const runAndVerify = async () => {
await locators.sidebar.collection('collection').click();
// Substring `hasText` would also match `api-setEnvVar-with-persist-typed`.
await locators.sidebar.collectionsContainer()
.getByText('api-setEnvVar-with-persist', { exact: true })
.click();
// select stage environment
await expect(page.locator('.environment-list .dropdown-item', { hasText: 'Stage' })).toBeVisible();
await page.locator('.environment-list .dropdown-item', { hasText: 'Stage' }).click();
await expect(page.locator('.current-environment', { hasText: 'Stage' })).toBeVisible();
await locators.environment.selector().click();
await expect(locators.environment.listOption('Stage')).toBeVisible();
await locators.environment.listOption('Stage').click();
await expect(locators.environment.currentEnvironment()).toContainText('Stage');
// Send the request
await sendRequest(page, 200);
await sendRequest(page, 200);
// confirm that the environment variable is set
await page.getByTestId('environment-selector-trigger').hover();
await page.getByTestId('environment-selector-trigger').click();
// open environment configuration
await expect
.poll(() => fs.readFileSync(stageBruPath, 'utf8'), { timeout: 5000 })
.toMatch(/legacy_persist_var:\s*from-legacy-flag/);
};
await page.locator('#configure-env').waitFor({ state: 'visible' });
await page.locator('#configure-env').dispatchEvent('click');
await test.step('safe mode (quickjs)', async () => {
await setSandboxMode(page, 'collection', 'safe');
await runAndVerify();
});
const envTab = page.locator('.request-tab').filter({ has: page.locator('.tab-label', { hasText: 'Environments' }) });
await expect(envTab).toBeVisible();
// Reset so the developer-mode pass can't trivially match the safe-mode write.
fs.writeFileSync(stageBruPath, stageOriginal, 'utf8');
await expect(page.getByRole('row', { name: 'token' }).getByRole('cell').nth(1)).toBeVisible();
await expect(page.getByRole('row', { name: 'secret' }).getByRole('cell').nth(2)).toBeVisible();
await envTab.hover();
await envTab.getByTestId('request-tab-close-icon').click({ force: true });
// we restart the app to confirm that the environment variable is persisted
const newApp = await restartApp();
const newPage = await waitForReadyPage(newApp);
// select the collection and request
await newPage.locator('#sidebar-collection-name').click();
await newPage.getByText('api-setEnvVar-with-persist', { exact: true }).click();
// open environment dropdown
await newPage.getByTestId('environment-selector-trigger').click();
await newPage.locator('#configure-env').waitFor({ state: 'visible' });
await newPage.locator('#configure-env').dispatchEvent('click');
const newEnvTab = newPage.locator('.request-tab').filter({ hasText: 'Environments' });
await expect(newEnvTab).toBeVisible();
await newPage.locator('.environment-item', { hasText: 'Stage' }).click();
await expect(newPage.getByRole('row', { name: 'token' }).getByRole('cell').nth(1)).toBeVisible();
await expect(newPage.getByRole('row', { name: 'secret' }).getByRole('cell').nth(2)).toBeVisible();
await newEnvTab.hover();
await newEnvTab.getByTestId('request-tab-close-icon').click({ force: true });
await closeElectronApp(newApp);
await test.step('developer mode (nodevm)', async () => {
await setSandboxMode(page, 'collection', 'developer');
await runAndVerify();
});
});
});

View File

@@ -1,60 +0,0 @@
import { test, expect, closeElectronApp } from '../../../playwright';
import { sendRequest, waitForReadyPage } from '../../utils/page';
test.describe.serial('bru.setEnvVar(name, value)', () => {
test('set env var using script', async ({ pageWithUserData: page, restartApp }) => {
// Select the collection and request
await page.locator('#sidebar-collection-name').click();
await page.getByText('api-setEnvVar-without-persist', { exact: true }).click();
// open environment dropdown
await page.getByTestId('environment-selector-trigger').click();
// select stage environment
await expect(page.locator('.environment-list .dropdown-item', { hasText: 'Stage' })).toBeVisible();
await page.locator('.environment-list .dropdown-item', { hasText: 'Stage' }).click();
await expect(page.locator('.current-environment', { hasText: 'Stage' })).toBeVisible();
// Send the request
await sendRequest(page, 200);
// confirm that the environment variable is set
await page.getByTestId('environment-selector-trigger').hover();
await page.getByTestId('environment-selector-trigger').click();
await page.locator('#configure-env').waitFor({ state: 'visible' });
await page.locator('#configure-env').dispatchEvent('click');
const envTab = page.locator('.request-tab').filter({ has: page.locator('.tab-label', { hasText: 'Environments' }) });
await expect(envTab).toBeVisible();
await expect(page.getByRole('row', { name: 'token' }).getByRole('cell').nth(1)).toBeVisible();
await expect(page.getByRole('row', { name: 'secret' }).getByRole('cell').nth(2)).toBeVisible();
await envTab.hover();
await envTab.getByTestId('request-tab-close-icon').click({ force: true });
// we restart the app to confirm that the environment variable is not persisted
const newApp = await restartApp();
const newPage = await waitForReadyPage(newApp);
// select the collection and request
await newPage.locator('#sidebar-collection-name').click();
await newPage.getByText('api-setEnvVar-without-persist', { exact: true }).click();
// open environment dropdown
await newPage.getByTestId('environment-selector-trigger').hover();
await newPage.getByTestId('environment-selector-trigger').click();
await newPage.locator('#configure-env').waitFor({ state: 'visible' });
await newPage.locator('#configure-env').dispatchEvent('click');
const newEnvTab = newPage.locator('.request-tab').filter({ has: newPage.locator('.tab-label', { hasText: 'Environments' }) });
await expect(newEnvTab).toBeVisible();
await newPage.locator('.environment-item', { hasText: 'Stage' }).click();
await expect(newPage.locator('.table-container tbody')).not.toContainText('token');
await newEnvTab.hover();
await newEnvTab.getByTestId('request-tab-close-icon').click({ force: true });
await closeElectronApp(newApp);
});
});

View File

@@ -0,0 +1,82 @@
import fs from 'fs';
import path from 'path';
import { test, expect, closeElectronApp } from '../../../playwright';
import { sendRequest, waitForReadyPage } from '../../utils/page';
import { buildCommonLocators } from '../../utils/page/locators';
test.describe('bru.setEnvVar(name, value)', () => {
test('set env var using script persists by default across restart', async ({ pageWithUserData: page, restartApp, collectionFixturePath }) => {
const stageBruPath = path.join(collectionFixturePath!, 'environments', 'Stage.bru');
const locators = buildCommonLocators(page);
const envTab = page.locator('.request-tab').filter({ hasText: 'Environments' });
const selectStage = async () => {
await locators.environment.selector().click();
await expect(locators.environment.listOption('Stage')).toBeVisible();
await locators.environment.listOption('Stage').click();
await expect(locators.environment.currentEnvironment()).toContainText('Stage');
};
const openEnvEditor = async () => {
await locators.environment.selector().hover();
await locators.environment.selector().click();
await locators.environment.configureButton().waitFor({ state: 'visible' });
await locators.environment.configureButton().dispatchEvent('click');
await expect(envTab).toBeVisible();
};
// Select the collection and request
await page.locator('#sidebar-collection-name').click();
await page.getByText('api-setEnvVar', { exact: true }).click();
await selectStage();
await sendRequest(page, 200);
// Verify the script-set var is visible in the env editor before restart.
await openEnvEditor();
const tokenRow = locators.environment.varRow('token');
await tokenRow.scrollIntoViewIfNeeded();
await expect(tokenRow).toBeVisible();
await expect(locators.environment.varRowLine('token')).toHaveText('secret');
// On-disk env file: setEnvVar persisted `token` to Stage.bru.
await expect.poll(() => fs.readFileSync(stageBruPath, 'utf8'), { timeout: 5000 })
.toMatch(/token:\s*secret/);
await envTab.hover();
await envTab.getByTestId('request-tab-close-icon').click({ force: true });
// Restart to confirm the var was persisted to disk (default behavior in v4).
const newApp = await restartApp();
const newPage = await waitForReadyPage(newApp);
const newLocators = buildCommonLocators(newPage);
const newEnvTab = newPage.locator('.request-tab').filter({ hasText: 'Environments' });
await newPage.locator('#sidebar-collection-name').click();
await newPage.getByText('api-setEnvVar', { exact: true }).click();
// Re-select Stage — active env isn't guaranteed to persist across restart.
await newLocators.environment.selector().click();
await expect(newLocators.environment.listOption('Stage')).toBeVisible();
await newLocators.environment.listOption('Stage').click();
await expect(newLocators.environment.currentEnvironment()).toContainText('Stage');
await newLocators.environment.selector().hover();
await newLocators.environment.selector().click();
await newLocators.environment.configureButton().waitFor({ state: 'visible' });
await newLocators.environment.configureButton().dispatchEvent('click');
await expect(newEnvTab).toBeVisible();
const newTokenRow = newLocators.environment.varRow('token');
await newTokenRow.scrollIntoViewIfNeeded();
await expect(newTokenRow).toBeVisible();
await expect(newLocators.environment.varRowLine('token')).toHaveText('secret');
// On-disk env file survived the restart unchanged.
expect(fs.readFileSync(stageBruPath, 'utf8')).toMatch(/token:\s*secret/);
await newEnvTab.hover();
await newEnvTab.getByTestId('request-tab-close-icon').click({ force: true });
await closeElectronApp(newApp);
});
});

View File

@@ -1,7 +1,7 @@
meta {
name: api-setEnvVar-with-persist
type: http
seq: 1
seq: 2
}
get {
@@ -11,5 +11,5 @@ get {
}
script:pre-request {
bru.setEnvVar("token", "secret", { persist: true });
}
bru.setEnvVar("legacy_persist_var", "from-legacy-flag", { persist: true });
}

View File

@@ -1,5 +1,5 @@
meta {
name: api-setEnvVar-without-persist
name: api-setEnvVar
type: http
seq: 1
}

View File

@@ -11,5 +11,5 @@ get {
}
script:pre-request {
bru.setEnvVar("multiple-persist-vars-key1", "value1", { persist: true });
bru.setEnvVar("multiple-persist-vars-key1", "value1");
}

View File

@@ -11,5 +11,5 @@ get {
}
script:pre-request {
bru.setEnvVar("multiple-persist-vars-key2", "value2", { persist: true });
bru.setEnvVar("multiple-persist-vars-key2", "value2");
}

View File

@@ -55,9 +55,15 @@ test.describe.serial('bru.setEnvVar multiple persistent variables', () => {
// Ensure we're in the correct collection context before selecting the folder
await expect(page.locator('#sidebar-collection-name', { hasText: 'collection' })).toBeVisible();
// Hover on the folder and open context menu
await page.getByText('multiple-persist-vars-folder', { exact: true }).hover();
await page.locator('.collection-item-name').filter({ hasText: 'multiple-persist-vars-folder' }).locator('.menu-icon').click();
// Re-hover on each poll: CSS `:hover` reveals `.menu-icon`, but the cursor
// move between hover() and click() can lose the reveal.
const folderRow = page.locator('.collection-item-name').filter({ hasText: 'multiple-persist-vars-folder' });
const menuIcon = folderRow.locator('.menu-icon');
await expect(async () => {
await folderRow.hover();
await expect(menuIcon).toBeVisible({ timeout: 1000 });
}).toPass({ timeout: 10000 });
await menuIcon.click();
// Click on Run option
await page.getByText('Run', { exact: true }).click();