datagrok-tools 6.1.9 → 6.1.11

package/bin/__tests__/node-dapi.connections.test.js

@@ -0,0 +1,120 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _nodeDapi = require("../utils/node-dapi");
+function makeMock(responder) {
+  const calls = [];
+  const client = {
+    async request(method, path, body) {
+      calls.push({
+        method,
+        path,
+        body
+      });
+      return responder(method, path, body);
+    },
+    get(path) {
+      return this.request('GET', path);
+    },
+    post(path, body) {
+      return this.request('POST', path, body);
+    },
+    del(path) {
+      return this.request('DELETE', path);
+    }
+  };
+  return {
+    client,
+    calls
+  };
+}
+const CONN = {
+  name: 'TestPg',
+  dataSource: 'PostgreSQL',
+  server: 'localhost',
+  port: 5432,
+  db: 'datagrok'
+};
+(0, _vitest.describe)('NodeConnectionsDataSource.save', () => {
+  (0, _vitest.it)('POSTs to /public/v1/connections without saveCredentials by default', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path, body) => {
+      if (method === 'POST' && path === '/public/v1/connections') return {
+        ...body,
+        id: 'new-id'
+      };
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeConnectionsDataSource(client);
+    const saved = await ds.save(CONN);
+    (0, _vitest.expect)(saved.id).toBe('new-id');
+    (0, _vitest.expect)(calls[0].path).toBe('/public/v1/connections');
+    (0, _vitest.expect)(calls[0].body).toEqual(CONN);
+  });
+  (0, _vitest.it)('appends saveCredentials=true when requested', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path, body) => {
+      if (method === 'POST' && path === '/public/v1/connections?saveCredentials=true') return {
+        ...body,
+        id: 'new-id'
+      };
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeConnectionsDataSource(client);
+    await ds.save(CONN, true);
+    (0, _vitest.expect)(calls[0].path).toBe('/public/v1/connections?saveCredentials=true');
+  });
+  (0, _vitest.it)('omits saveCredentials query param when false', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path) => {
+      if (method === 'POST' && path === '/public/v1/connections') return {
+        id: 'new-id'
+      };
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeConnectionsDataSource(client);
+    await ds.save(CONN, false);
+    (0, _vitest.expect)(calls[0].path).toBe('/public/v1/connections');
+  });
+});
+(0, _vitest.describe)('NodeConnectionsDataSource.test', () => {
+  (0, _vitest.it)('POSTs the connection body to /public/v1/connections/test and resolves on "ok"', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path) => {
+      if (method === 'POST' && path === '/public/v1/connections/test') return 'ok';
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeConnectionsDataSource(client);
+    await ds.test(CONN);
+    (0, _vitest.expect)(calls[0].body).toEqual(CONN);
+  });
+  (0, _vitest.it)('strips surrounding quotes on a JSON-encoded "ok"', async () => {
+    const {
+      client
+    } = makeMock(() => '"ok"');
+    const ds = new _nodeDapi.NodeConnectionsDataSource(client);
+    await (0, _vitest.expect)(ds.test(CONN)).resolves.toBeUndefined();
+  });
+  (0, _vitest.it)('throws the server error text when the response is not ok', async () => {
+    const {
+      client
+    } = makeMock(() => 'connection refused: tcp://localhost:5432');
+    const ds = new _nodeDapi.NodeConnectionsDataSource(client);
+    await (0, _vitest.expect)(ds.test(CONN)).rejects.toThrow(/connection refused/);
+  });
+  (0, _vitest.it)('throws a generic message on empty response', async () => {
+    const {
+      client
+    } = makeMock(() => '');
+    const ds = new _nodeDapi.NodeConnectionsDataSource(client);
+    await (0, _vitest.expect)(ds.test(CONN)).rejects.toThrow(/failed/i);
+  });
+});

package/bin/__tests__/node-dapi.connections.test.ts

@@ -0,0 +1,84 @@
+import {describe, it, expect} from 'vitest';
+import {NodeConnectionsDataSource} from '../utils/node-dapi';
+
+interface Call {method: string; path: string; body?: any}
+
+function makeMock(responder: (method: string, path: string, body?: any) => any) {
+  const calls: Call[] = [];
+  const client: any = {
+    async request(method: string, path: string, body?: any) {
+      calls.push({method, path, body});
+      return responder(method, path, body);
+    },
+    get(path: string) { return this.request('GET', path); },
+    post(path: string, body?: any) { return this.request('POST', path, body); },
+    del(path: string) { return this.request('DELETE', path); },
+  };
+  return {client, calls};
+}
+
+const CONN = {name: 'TestPg', dataSource: 'PostgreSQL', server: 'localhost', port: 5432, db: 'datagrok'};
+
+describe('NodeConnectionsDataSource.save', () => {
+  it('POSTs to /public/v1/connections without saveCredentials by default', async () => {
+    const {client, calls} = makeMock((method, path, body) => {
+      if (method === 'POST' && path === '/public/v1/connections') return {...body, id: 'new-id'};
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new NodeConnectionsDataSource(client);
+    const saved = await ds.save(CONN);
+    expect(saved.id).toBe('new-id');
+    expect(calls[0].path).toBe('/public/v1/connections');
+    expect(calls[0].body).toEqual(CONN);
+  });
+
+  it('appends saveCredentials=true when requested', async () => {
+    const {client, calls} = makeMock((method, path, body) => {
+      if (method === 'POST' && path === '/public/v1/connections?saveCredentials=true') return {...body, id: 'new-id'};
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new NodeConnectionsDataSource(client);
+    await ds.save(CONN, true);
+    expect(calls[0].path).toBe('/public/v1/connections?saveCredentials=true');
+  });
+
+  it('omits saveCredentials query param when false', async () => {
+    const {client, calls} = makeMock((method, path) => {
+      if (method === 'POST' && path === '/public/v1/connections') return {id: 'new-id'};
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new NodeConnectionsDataSource(client);
+    await ds.save(CONN, false);
+    expect(calls[0].path).toBe('/public/v1/connections');
+  });
+});
+
+describe('NodeConnectionsDataSource.test', () => {
+  it('POSTs the connection body to /public/v1/connections/test and resolves on "ok"', async () => {
+    const {client, calls} = makeMock((method, path) => {
+      if (method === 'POST' && path === '/public/v1/connections/test') return 'ok';
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new NodeConnectionsDataSource(client);
+    await ds.test(CONN);
+    expect(calls[0].body).toEqual(CONN);
+  });
+
+  it('strips surrounding quotes on a JSON-encoded "ok"', async () => {
+    const {client} = makeMock(() => '"ok"');
+    const ds = new NodeConnectionsDataSource(client);
+    await expect(ds.test(CONN)).resolves.toBeUndefined();
+  });
+
+  it('throws the server error text when the response is not ok', async () => {
+    const {client} = makeMock(() => 'connection refused: tcp://localhost:5432');
+    const ds = new NodeConnectionsDataSource(client);
+    await expect(ds.test(CONN)).rejects.toThrow(/connection refused/);
+  });
+
+  it('throws a generic message on empty response', async () => {
+    const {client} = makeMock(() => '');
+    const ds = new NodeConnectionsDataSource(client);
+    await expect(ds.test(CONN)).rejects.toThrow(/failed/i);
+  });
+});

package/bin/__tests__/node-dapi.groups.test.js

@@ -0,0 +1,467 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _nodeDapi = require("../utils/node-dapi");
+function makeMock(responder) {
+  const calls = [];
+  const client = {
+    async request(method, path, body) {
+      calls.push({
+        method,
+        path,
+        body
+      });
+      return responder(method, path, body);
+    },
+    get(path) {
+      return this.request('GET', path);
+    },
+    post(path, body) {
+      return this.request('POST', path, body);
+    },
+    del(path) {
+      return this.request('DELETE', path);
+    }
+  };
+  return {
+    client,
+    calls
+  };
+}
+const PARENT_ID = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa';
+const ALICE_ID = 'bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb';
+const BOB_ID = 'cccccccc-cccc-cccc-cccc-cccccccccccc';
+function makeParent(children = []) {
+  return {
+    id: PARENT_ID,
+    friendlyName: 'Admins',
+    children
+  };
+}
+(0, _vitest.describe)('NodeGroupsDataSource.resolve', () => {
+  (0, _vitest.it)('treats a UUID as a direct ID and calls find()', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((_m, path) => {
+      if (path.startsWith(`/public/v1/groups/${PARENT_ID}`)) return makeParent();
+      throw new Error(`unexpected ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    const g = await ds.resolve(PARENT_ID);
+    (0, _vitest.expect)(g.id).toBe(PARENT_ID);
+    (0, _vitest.expect)(calls[0].path).toBe(`/public/v1/groups/${PARENT_ID}`);
+  });
+  (0, _vitest.it)('uses /lookup for non-UUID names and returns the unique match', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((_m, path) => {
+      if (path.startsWith('/public/v1/groups/lookup')) return [{
+        id: ALICE_ID,
+        name: 'alice',
+        friendlyName: 'alice',
+        personal: true
+      }];
+      throw new Error(`unexpected ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    const g = await ds.resolve('alice');
+    (0, _vitest.expect)(g.id).toBe(ALICE_ID);
+    (0, _vitest.expect)(calls[0].path).toBe('/public/v1/groups/lookup?query=alice');
+  });
+  (0, _vitest.it)('errors with a list when lookup returns multiple matches', async () => {
+    const {
+      client
+    } = makeMock((_m, path) => {
+      if (path.startsWith('/public/v1/groups/lookup')) return [{
+        id: 'g1',
+        friendlyName: 'alice',
+        personal: false
+      }, {
+        id: 'g2',
+        friendlyName: 'alice',
+        personal: true
+      }];
+      throw new Error(`unexpected ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    await (0, _vitest.expect)(ds.resolve('alice')).rejects.toThrow(/Multiple groups match 'alice'/);
+  });
+  (0, _vitest.it)('personalOnly filters lookup results to personal groups', async () => {
+    const {
+      client
+    } = makeMock((_m, path) => {
+      if (path.startsWith('/public/v1/groups/lookup')) return [{
+        id: 'g1',
+        friendlyName: 'alice',
+        personal: false
+      }, {
+        id: ALICE_ID,
+        friendlyName: 'alice',
+        personal: true
+      }];
+      throw new Error(`unexpected ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    const g = await ds.resolve('alice', {
+      personalOnly: true
+    });
+    (0, _vitest.expect)(g.id).toBe(ALICE_ID);
+  });
+  (0, _vitest.it)('errors when personalOnly yields no matches', async () => {
+    const {
+      client
+    } = makeMock((_m, path) => {
+      if (path.startsWith('/public/v1/groups/lookup')) return [{
+        id: 'g1',
+        friendlyName: 'alice',
+        personal: false
+      }];
+      throw new Error(`unexpected ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    await (0, _vitest.expect)(ds.resolve('alice', {
+      personalOnly: true
+    })).rejects.toThrow(/No group matching 'alice' \(personal\)/);
+  });
+});
+(0, _vitest.describe)('NodeGroupsDataSource.save', () => {
+  (0, _vitest.it)('POSTs the group body to /public/v1/groups and auto-generates an id when missing', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path, body) => {
+      if (method === 'POST' && path === '/public/v1/groups') return {
+        ...body,
+        friendlyName: 'Chemists'
+      };
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    await ds.save({
+      friendlyName: 'Chemists'
+    });
+    (0, _vitest.expect)(calls[0].path).toBe('/public/v1/groups');
+    (0, _vitest.expect)(calls[0].body.id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+  });
+  (0, _vitest.it)('appends saveRelations=true when requested', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path) => {
+      if (method === 'POST' && path === '/public/v1/groups?saveRelations=true') return {
+        id: 'g'
+      };
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    await ds.save({
+      id: 'g',
+      friendlyName: 'Chemists'
+    }, true);
+    (0, _vitest.expect)(calls[0].path).toBe('/public/v1/groups?saveRelations=true');
+  });
+});
+(0, _vitest.describe)('NodeGroupsDataSource.addMembers', () => {
+  (0, _vitest.it)('appends new relations and POSTs with saveRelations=true', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path, _body) => {
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}`) return makeParent();
+      if (method === 'GET' && path.startsWith('/public/v1/groups/lookup')) return [{
+        id: ALICE_ID,
+        friendlyName: 'alice',
+        personal: true
+      }];
+      if (method === 'POST' && path === '/public/v1/groups?saveRelations=true') return {
+        id: PARENT_ID
+      };
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    const results = await ds.addMembers(PARENT_ID, ['alice']);
+    (0, _vitest.expect)(results).toEqual([{
+      member: 'alice',
+      status: 'added'
+    }]);
+    const post = calls.find(c => c.method === 'POST');
+    (0, _vitest.expect)(post.path).toBe('/public/v1/groups?saveRelations=true');
+    (0, _vitest.expect)(post.body.children).toEqual([{
+      parent: {
+        id: PARENT_ID
+      },
+      child: {
+        id: ALICE_ID
+      },
+      isAdmin: false
+    }]);
+  });
+  (0, _vitest.it)('supports --admin by setting isAdmin on the new relation', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path) => {
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}`) return makeParent();
+      if (method === 'GET' && path.startsWith('/public/v1/groups/lookup')) return [{
+        id: ALICE_ID,
+        friendlyName: 'alice',
+        personal: true
+      }];
+      if (method === 'POST') return {
+        id: PARENT_ID
+      };
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    await ds.addMembers(PARENT_ID, ['alice'], true);
+    const post = calls.find(c => c.method === 'POST');
+    (0, _vitest.expect)(post.body.children[0].isAdmin).toBe(true);
+  });
+  (0, _vitest.it)('is idempotent: re-adding with the same role reports noop and skips POST', async () => {
+    const existing = {
+      parent: {
+        id: PARENT_ID
+      },
+      child: {
+        id: ALICE_ID
+      },
+      isAdmin: false
+    };
+    const {
+      client,
+      calls
+    } = makeMock((method, path) => {
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}`) return makeParent([existing]);
+      if (method === 'GET' && path.startsWith('/public/v1/groups/lookup')) return [{
+        id: ALICE_ID,
+        friendlyName: 'alice',
+        personal: true
+      }];
+      if (method === 'POST') return {
+        id: PARENT_ID
+      };
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    const results = await ds.addMembers(PARENT_ID, ['alice']);
+    (0, _vitest.expect)(results).toEqual([{
+      member: 'alice',
+      status: 'noop'
+    }]);
+    (0, _vitest.expect)(calls.find(c => c.method === 'POST')).toBeUndefined();
+  });
+  (0, _vitest.it)('flips isAdmin when re-adding an existing member with a different role', async () => {
+    const existing = {
+      parent: {
+        id: PARENT_ID
+      },
+      child: {
+        id: ALICE_ID
+      },
+      isAdmin: false
+    };
+    const {
+      client,
+      calls
+    } = makeMock((method, path) => {
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}`) return makeParent([existing]);
+      if (method === 'GET' && path.startsWith('/public/v1/groups/lookup')) return [{
+        id: ALICE_ID,
+        friendlyName: 'alice',
+        personal: true
+      }];
+      if (method === 'POST') return {
+        id: PARENT_ID
+      };
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    const results = await ds.addMembers(PARENT_ID, ['alice'], true);
+    (0, _vitest.expect)(results).toEqual([{
+      member: 'alice',
+      status: 'updated'
+    }]);
+    const post = calls.find(c => c.method === 'POST');
+    (0, _vitest.expect)(post.body.children).toHaveLength(1);
+    (0, _vitest.expect)(post.body.children[0].isAdmin).toBe(true);
+  });
+  (0, _vitest.it)('processes a mixed batch: one valid, one unresolvable', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path) => {
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}`) return makeParent();
+      if (method === 'GET' && path === '/public/v1/groups/lookup?query=alice') return [{
+        id: ALICE_ID,
+        friendlyName: 'alice',
+        personal: true
+      }];
+      if (method === 'GET' && path === '/public/v1/groups/lookup?query=nobody') return [];
+      if (method === 'POST') return {
+        id: PARENT_ID
+      };
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    const results = await ds.addMembers(PARENT_ID, ['alice', 'nobody']);
+    (0, _vitest.expect)(results[0]).toEqual({
+      member: 'alice',
+      status: 'added'
+    });
+    (0, _vitest.expect)(results[1].member).toBe('nobody');
+    (0, _vitest.expect)(results[1].status).toBe('error');
+    (0, _vitest.expect)(results[1].error).toMatch(/No group matching 'nobody'/);
+    // POST should still happen for the valid member
+    const post = calls.find(c => c.method === 'POST');
+    (0, _vitest.expect)(post.body.children).toHaveLength(1);
+    (0, _vitest.expect)(post.body.children[0].child.id).toBe(ALICE_ID);
+  });
+  (0, _vitest.it)('handles multiple members in a single call', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path) => {
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}`) return makeParent();
+      if (method === 'GET' && path === '/public/v1/groups/lookup?query=alice') return [{
+        id: ALICE_ID,
+        friendlyName: 'alice',
+        personal: true
+      }];
+      if (method === 'GET' && path === '/public/v1/groups/lookup?query=bob') return [{
+        id: BOB_ID,
+        friendlyName: 'bob',
+        personal: true
+      }];
+      if (method === 'POST') return {
+        id: PARENT_ID
+      };
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    const results = await ds.addMembers(PARENT_ID, ['alice', 'bob']);
+    (0, _vitest.expect)(results.map(r => r.status)).toEqual(['added', 'added']);
+    const post = calls.find(c => c.method === 'POST');
+    (0, _vitest.expect)(post.body.children.map(c => c.child.id)).toEqual([ALICE_ID, BOB_ID]);
+    // exactly one POST regardless of batch size
+    (0, _vitest.expect)(calls.filter(c => c.method === 'POST')).toHaveLength(1);
+  });
+});
+(0, _vitest.describe)('NodeGroupsDataSource.removeMembers', () => {
+  (0, _vitest.it)('filters the relation out and POSTs with saveRelations=true', async () => {
+    const existing = {
+      parent: {
+        id: PARENT_ID
+      },
+      child: {
+        id: ALICE_ID
+      },
+      isAdmin: false
+    };
+    const {
+      client,
+      calls
+    } = makeMock((method, path) => {
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}`) return makeParent([existing]);
+      if (method === 'GET' && path.startsWith('/public/v1/groups/lookup')) return [{
+        id: ALICE_ID,
+        friendlyName: 'alice',
+        personal: true
+      }];
+      if (method === 'POST') return {
+        id: PARENT_ID
+      };
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    const results = await ds.removeMembers(PARENT_ID, ['alice']);
+    (0, _vitest.expect)(results).toEqual([{
+      member: 'alice',
+      status: 'removed'
+    }]);
+    const post = calls.find(c => c.method === 'POST');
+    (0, _vitest.expect)(post.path).toBe('/public/v1/groups?saveRelations=true');
+    (0, _vitest.expect)(post.body.children).toEqual([]);
+  });
+  (0, _vitest.it)('reports not-member and skips POST when the member isn\'t in the group', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path) => {
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}`) return makeParent();
+      if (method === 'GET' && path.startsWith('/public/v1/groups/lookup')) return [{
+        id: ALICE_ID,
+        friendlyName: 'alice',
+        personal: true
+      }];
+      if (method === 'POST') return {
+        id: PARENT_ID
+      };
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    const results = await ds.removeMembers(PARENT_ID, ['alice']);
+    (0, _vitest.expect)(results).toEqual([{
+      member: 'alice',
+      status: 'not-member'
+    }]);
+    (0, _vitest.expect)(calls.find(c => c.method === 'POST')).toBeUndefined();
+  });
+});
+(0, _vitest.describe)('NodeGroupsDataSource.getMembers', () => {
+  (0, _vitest.it)('calls /members without an admin query when admin is undefined', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path) => {
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}`) return makeParent();
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}/members`) return [];
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    await ds.getMembers(PARENT_ID);
+    (0, _vitest.expect)(calls.map(c => c.path)).toContain(`/public/v1/groups/${PARENT_ID}/members`);
+  });
+  (0, _vitest.it)('passes admin=true', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path) => {
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}`) return makeParent();
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}/members?admin=true`) return [];
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    await ds.getMembers(PARENT_ID, true);
+    (0, _vitest.expect)(calls.map(c => c.path)).toContain(`/public/v1/groups/${PARENT_ID}/members?admin=true`);
+  });
+  (0, _vitest.it)('passes admin=false', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path) => {
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}`) return makeParent();
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}/members?admin=false`) return [];
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    await ds.getMembers(PARENT_ID, false);
+    (0, _vitest.expect)(calls.map(c => c.path)).toContain(`/public/v1/groups/${PARENT_ID}/members?admin=false`);
+  });
+});
+(0, _vitest.describe)('NodeGroupsDataSource.getMemberships', () => {
+  (0, _vitest.it)('calls /memberships with admin flag when provided', async () => {
+    const {
+      client,
+      calls
+    } = makeMock((method, path) => {
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}`) return makeParent();
+      if (method === 'GET' && path === `/public/v1/groups/${PARENT_ID}/memberships?admin=true`) return [];
+      throw new Error(`unexpected ${method} ${path}`);
+    });
+    const ds = new _nodeDapi.NodeGroupsDataSource(client);
+    await ds.getMemberships(PARENT_ID, true);
+    (0, _vitest.expect)(calls.map(c => c.path)).toContain(`/public/v1/groups/${PARENT_ID}/memberships?admin=true`);
+  });
+});