Updated resolved variable assignment and testcases

packages/bruno-electron/src/ipc/network/index.js

@@ -329,16 +329,17 @@ const fetchGqlSchemaHandler = async (event, endpoint, environment, _request, col
     const globalEnvironmentVars = collection.globalEnvironmentVariables;
     const collectionRuntimeVars = collection.runtimeVariables;
     const folderVars = resolvedRequest.folderVariables;
-    const requestRuntimeVars = resolvedRequest.vars;
+    const requestVariables = resolvedRequest.requestVariables;
+    const collectionVariables = resolvedRequest.collectionVariables;
 
-    // Precedence: globalEnvironmentVars < envVars < collectionEnvVars < collectionRunTimeVars < folderVars < requestRunTimeVars
+    // Precedence: globalEnvironmentVars  < collectionVariables < envVars < folderVars < requestVariables
     const resolvedVars = merge(
       {},
       globalEnvironmentVars,
+      collectionVariables,
       envVars,
-      collectionRuntimeVars,
       folderVars,
-      requestRuntimeVars
+      requestVariables
     );
 
     const collectionRoot = get(collection, 'root', {});

packages/bruno-electron/tests/network/fetch-gql-schema-handler.spec.js

@@ -1,25 +1,7 @@
 const prepareGqlIntrospectionRequest = require('../../src/ipc/network/prepare-gql-introspection-request');
 const { fetchGqlSchemaHandler } = require('../../src/ipc/network');
 
-// Mock the modules first, before requiring them
-jest.mock('../../src/utils/collection', () => {
-  const original = jest.requireActual('../../src/utils/collection');
-  return {
-    ...original,
-    getTreePathFromCollectionToItem: jest.fn().mockReturnValue([]),
-    mergeVars: jest.fn(),
-    getEnvVars: jest.fn(env => {
-      if (!env || !env.variables) return {};
-      return env.variables.reduce((acc, variable) => {
-        if (variable.enabled) {
-          acc[variable.name] = variable.value;
-        }
-        return acc;
-      }, {});
-    })
-  };
-});
-
+// Mock only the prepare-gql-introspection-request to avoid network calls
 jest.mock('../../src/ipc/network/prepare-gql-introspection-request', () => {
   return jest.fn().mockImplementation((endpoint, vars, request, root) => {
     return {
@@ -42,54 +24,6 @@ describe('fetchGqlSchemaHandler', () => {
     jest.restoreAllMocks();
   });
 
-  it('should receive combined variables from fetchGqlSchemaHandler', async () => {
-    const endpoint = 'https://example.com/';
-    const environment = {
-      variables: [
-        { name: 'API_TOKEN', value: 'secret-token', enabled: true },
-        { name: 'ENV_VAR', value: 'env-value', enabled: true }
-      ]
-    };
-    const request = {
-      vars: {
-        requestVar: 'request-value'
-      },
-      headers: [
-        { name: 'Authorization', value: 'Bearer {{API_TOKEN}}', enabled: true }
-      ]
-    };
-    const collection = {
-      uid: 'test-collection',
-      pathname: '/test',
-      runtimeVariables: {
-        runtimeVar: 'runtime-value'
-      },
-      globalEnvironmentVariables: {
-        globalVar: 'global-value'
-      },
-      root: {
-        request: {
-          headers: []
-        }
-      }
-    };
-
-    await fetchGqlSchemaHandler(null, endpoint, environment, request, collection);
-
-    expect(prepareGqlIntrospectionRequest).toHaveBeenCalledWith(
-      endpoint,
-      expect.objectContaining({
-        API_TOKEN: 'secret-token',
-        ENV_VAR: 'env-value',
-        requestVar: 'request-value',
-        runtimeVar: 'runtime-value',
-        globalVar: 'global-value'
-      }),
-      request,
-      collection.root
-    );
-  });
-
   it('should override global environment variables with environment variables', async () => {
     const endpoint = 'https://example.com/';
     const environment = {
@@ -98,7 +32,10 @@ describe('fetchGqlSchemaHandler', () => {
       ]
     };
     const request = {
-      vars: {}
+      uid: 'test-request',
+      vars: {
+        req: [] // No request variables
+      }
     };
     const collection = {
       uid: 'test-collection',
@@ -107,9 +44,22 @@ describe('fetchGqlSchemaHandler', () => {
       globalEnvironmentVariables: {
         SHARED_VAR: 'global-value'
       },
+      items: [
+        {
+          uid: 'test-request',
+          request: {
+            vars: {
+              req: [] // No request variables
+            }
+          }
+        }
+      ],
       root: {
         request: {
-          headers: []
+          headers: [],
+          vars: {
+            req: [] // No collection variables
+          }
         }
       }
     };
@@ -126,150 +76,6 @@ describe('fetchGqlSchemaHandler', () => {
     );
   });
 
-  it('should override environment variables with collection runtime variables', async () => {
-    const endpoint = 'https://example.com/';
-    const environment = {
-      variables: [
-        { name: 'SHARED_VAR', value: 'env-value', enabled: true }
-      ]
-    };
-    const request = {
-      vars: {}
-    };
-    const collection = {
-      uid: 'test-collection',
-      pathname: '/test',
-      runtimeVariables: {
-        SHARED_VAR: 'runtime-value'
-      },
-      globalEnvironmentVariables: {},
-      root: {
-        request: {
-          headers: []
-        }
-      }
-    };
-
-    await fetchGqlSchemaHandler(null, endpoint, environment, request, collection);
-
-    expect(prepareGqlIntrospectionRequest).toHaveBeenCalledWith(
-      endpoint,
-      expect.objectContaining({
-        SHARED_VAR: 'runtime-value'
-      }),
-      request,
-      collection.root
-    );
-  });
-
-  it('should override collection runtime variables with request runtime variables', async () => {
-    const endpoint = 'https://example.com/';
-    const environment = {
-      variables: []
-    };
-    const request = {
-      vars: {
-        SHARED_VAR: 'request-value'
-      }
-    };
-    const collection = {
-      uid: 'test-collection',
-      pathname: '/test',
-      runtimeVariables: {
-        SHARED_VAR: 'runtime-value'
-      },
-      globalEnvironmentVariables: {},
-      root: {
-        request: {
-          headers: []
-        }
-      }
-    };
-
-    await fetchGqlSchemaHandler(null, endpoint, environment, request, collection);
-
-    expect(prepareGqlIntrospectionRequest).toHaveBeenCalledWith(
-      endpoint,
-      expect.objectContaining({
-        SHARED_VAR: 'request-value'
-      }),
-      request,
-      collection.root
-    );
-  });
-
-  it('should override global environment with request runtime variables', async () => {
-    const endpoint = 'https://example.com/';
-    const environment = {
-      variables: []
-    };
-    const request = {
-      vars: {
-        SHARED_VAR: 'request-value'
-      }
-    };
-    const collection = {
-      uid: 'test-collection',
-      pathname: '/test',
-      runtimeVariables: {},
-      globalEnvironmentVariables: {
-        SHARED_VAR: 'global-value'
-      },
-      root: {
-        request: {
-          headers: []
-        }
-      }
-    };
-
-    await fetchGqlSchemaHandler(null, endpoint, environment, request, collection);
-
-    expect(prepareGqlIntrospectionRequest).toHaveBeenCalledWith(
-      endpoint,
-      expect.objectContaining({
-        SHARED_VAR: 'request-value'
-      }),
-      request,
-      collection.root
-    );
-  });
-
-  it('should override global environment with collection runtime variables', async () => {
-    const endpoint = 'https://example.com/';
-    const environment = {
-      variables: []
-    };
-    const request = {
-      vars: {}
-    };
-    const collection = {
-      uid: 'test-collection',
-      pathname: '/test',
-      runtimeVariables: {
-        SHARED_VAR: 'runtime-value'
-      },
-      globalEnvironmentVariables: {
-        SHARED_VAR: 'global-value'
-      },
-      root: {
-        request: {
-          headers: []
-        }
-      }
-    };
-
-    await fetchGqlSchemaHandler(null, endpoint, environment, request, collection);
-
-    expect(prepareGqlIntrospectionRequest).toHaveBeenCalledWith(
-      endpoint,
-      expect.objectContaining({
-        SHARED_VAR: 'runtime-value'
-      }),
-      request,
-      collection.root
-    );
-  });
-
   it('should override environment variables with folder-level variables', async () => {
     const endpoint = 'https://example.com/';
     const environment = {
@@ -278,9 +84,9 @@ describe('fetchGqlSchemaHandler', () => {
       ]
     };
     const request = {
-      vars: {},
-      folderVariables: {
-        SHARED_VAR: 'folder-value'
+      uid: 'test-request',
+      vars: {
+        req: [] // No request variables
       }
     };
     const collection = {
@@ -288,9 +94,37 @@ describe('fetchGqlSchemaHandler', () => {
       pathname: '/test',
       runtimeVariables: {},
       globalEnvironmentVariables: {},
+      items: [
+        {
+          uid: 'test-folder',
+          type: 'folder',
+          root: {
+            request: {
+              vars: {
+                req: [
+                  { name: 'SHARED_VAR', value: 'folder-value', enabled: true }
+                ]
+              }
+            }
+          },
+          items: [
+            {
+              uid: 'test-request',
+              request: {
+                vars: {
+                  req: [] // No request variables
+                }
+              }
+            }
+          ]
+        }
+      ],
       root: {
         request: {
-          headers: []
+          headers: [],
+          vars: {
+            req: [] // No collection variables
+          }
         }
       }
     };
@@ -307,27 +141,57 @@ describe('fetchGqlSchemaHandler', () => {
     );
   });
 
-  it('should override collection runtime variables with folder-level variables', async () => {
+  it('should override folder-level variables with request variables', async () => {
     const endpoint = 'https://example.com/';
     const environment = {
       variables: []
     };
     const request = {
-      vars: {},
-      folderVariables: {
-        SHARED_VAR: 'folder-value'
+      uid: 'test-request',
+      vars: {
+        req: [
+          { name: 'SHARED_VAR', value: 'request-value', enabled: true }
+        ]
       }
     };
     const collection = {
       uid: 'test-collection',
       pathname: '/test',
-      runtimeVariables: {
-        SHARED_VAR: 'runtime-value'
-      },
+      runtimeVariables: {},
       globalEnvironmentVariables: {},
+      items: [
+        {
+          uid: 'test-folder',
+          type: 'folder',
+          root: {
+            request: {
+              vars: {
+                req: [
+                  { name: 'SHARED_VAR', value: 'folder-value', enabled: true }
+                ]
+              }
+            }
+          },
+          items: [
+            {
+              uid: 'test-request',
+              request: {
+                vars: {
+                  req: [
+                    { name: 'SHARED_VAR', value: 'request-value', enabled: true }
+                  ]
+                }
+              }
+            }
+          ]
+        }
+      ],
       root: {
         request: {
-          headers: []
+          headers: [],
+          vars: {
+            req: [] // No collection variables
+          }
         }
       }
     };
@@ -337,7 +201,111 @@ describe('fetchGqlSchemaHandler', () => {
     expect(prepareGqlIntrospectionRequest).toHaveBeenCalledWith(
       endpoint,
       expect.objectContaining({
-        SHARED_VAR: 'folder-value'
+        SHARED_VAR: 'request-value'
+      }),
+      request,
+      collection.root
+    );
+  });
+
+  it('should override global environment variables with collection variables', async () => {
+    const endpoint = 'https://example.com/';
+    const environment = {
+      variables: []
+    };
+    const request = {
+      uid: 'test-request',
+      vars: {
+        req: [] // No request variables
+      }
+    };
+    const collection = {
+      uid: 'test-collection',
+      pathname: '/test',
+      runtimeVariables: {},
+      globalEnvironmentVariables: {
+        SHARED_VAR: 'global-value'
+      },
+      items: [
+        {
+          uid: 'test-request',
+          request: {
+            vars: {
+              req: [] // No request variables
+            }
+          }
+        }
+      ],
+      root: {
+        request: {
+          headers: [],
+          vars: {
+            req: [
+              { name: 'SHARED_VAR', value: 'collection-value', enabled: true }
+            ]
+          }
+        }
+      }
+    };
+
+    await fetchGqlSchemaHandler(null, endpoint, environment, request, collection);
+
+    expect(prepareGqlIntrospectionRequest).toHaveBeenCalledWith(
+      endpoint,
+      expect.objectContaining({
+        SHARED_VAR: 'collection-value'
+      }),
+      request,
+      collection.root
+    );
+  });
+
+  it('should override collection variables with environment variables', async () => {
+    const endpoint = 'https://example.com/';
+    const environment = {
+      variables: [
+        { name: 'SHARED_VAR', value: 'env-value', enabled: true }
+      ]
+    };
+    const request = {
+      uid: 'test-request',
+      vars: {
+        req: [] // No request variables
+      }
+    };
+    const collection = {
+      uid: 'test-collection',
+      pathname: '/test',
+      runtimeVariables: {},
+      globalEnvironmentVariables: {},
+      items: [
+        {
+          uid: 'test-request',
+          request: {
+            vars: {
+              req: [] // No request variables
+            }
+          }
+        }
+      ],
+      root: {
+        request: {
+          headers: [],
+          vars: {
+            req: [
+              { name: 'SHARED_VAR', value: 'collection-value', enabled: true }
+            ]
+          }
+        }
+      }
+    };
+
+    await fetchGqlSchemaHandler(null, endpoint, environment, request, collection);
+
+    expect(prepareGqlIntrospectionRequest).toHaveBeenCalledWith(
+      endpoint,
+      expect.objectContaining({
+        SHARED_VAR: 'env-value'
       }),
       request,
       collection.root