sap-ai-dev-toolkit 0.3.4 → 0.3.7

package/test/copilot-content.test.mjs

@@ -10,6 +10,7 @@ const skillsRoot = join(root, '.github', 'skills');
 const expectedAgents = [
   'abap-developer.agent.md',
   'abap-runtime-debugger.agent.md',
+  'hana-cloud-hdi-specialist.agent.md',
   'rap-service-developer.agent.md',
   'sap-solution-architect.agent.md'
 ];
@@ -20,6 +21,9 @@ const expectedSkills = [
   'abap-testing-quality',
   'cds-development',
   'clean-core-extensibility',
+  'hana-cloud-inspection',
+  'hana-cloud-native-development',
+  'hana-cloud-validation',
   'rap-development',
   'rap-service-delivery',
   'sap-sdlc-orchestration',
@@ -136,6 +140,7 @@ test('SAP Solution Architect agent has valid metadata and planning/handoff polic
   assert.match(markdown, /ABAP Developer/i);
   assert.match(markdown, /RAP Service Developer/i);
   assert.match(markdown, /ABAP Runtime Debugger/i);
+  assert.match(markdown, /HANA Cloud\/HDI Specialist/i);
   assert.match(markdown, /SDLC|lifecycle/i);
   assertPlanFirstPolicy(markdown, path);
   assertLocalFirstPolicy(markdown, path);
@@ -158,6 +163,27 @@ test('RAP Service Developer agent has valid metadata and plan-first local-first
   assertNoUnsafeTransportClaims(markdown, path);
 });
 
+test('HANA Cloud/HDI Specialist agent has a read-only target-bound workflow', async () => {
+  const path = join(agentsRoot, 'hana-cloud-hdi-specialist.agent.md');
+  const markdown = await readMarkdown(path);
+  const metadata = parseFrontmatter(markdown, path);
+  assert.deepEqual(Object.keys(metadata).sort(), ['description', 'name', 'target', 'user-invocable']);
+  assert.equal(metadata.name, 'HANA Cloud/HDI Specialist');
+  assert.equal(metadata.target, 'vscode');
+  assert.equal(metadata['user-invocable'], 'true');
+  assert.match(metadata.description, /HANA Cloud/i);
+  assertDirectMcpUsage(markdown, path);
+  assertMentionsLiveToolDiscovery(markdown, path);
+  for (const tool of ['hana_connection_info', 'hana_list_objects', 'hana_describe_object', 'hana_read_rows']) {
+    assert.match(markdown, new RegExp(tool));
+  }
+  assert.match(markdown, /read-only/i);
+  assert.match(markdown, /HANA_RO_\*/);
+  assert.match(markdown, /cds build --for hana/);
+  assert.match(markdown, /user-run deployment|deployment is performed by the user/i);
+  assert.match(markdown, /never execute HANA DDL\/DML|Never execute HANA DDL\/DML/i);
+});
+
 test('each skill has valid metadata, matching name, and enforceable live-tool validation policy', async () => {
   for (const skill of expectedSkills) {
     const path = join(skillsRoot, skill, 'SKILL.md');
@@ -199,3 +225,25 @@ test('debugging skill requires evidence before fixes and bounded debugger use',
   assert.match(markdown, /Avoid attaching to another user's session|do not.*another user's session/i);
   assert.match(markdown, /before changing code|before proposing a cause/i);
 });
+
+test('HANA skills describe the read-only tool surface and safe CAP/HDI generation', async () => {
+  const inspection = await readMarkdown(join(skillsRoot, 'hana-cloud-inspection', 'SKILL.md'));
+  for (const tool of ['hana_connection_info', 'hana_list_objects', 'hana_describe_object', 'hana_read_rows']) {
+    assert.match(inspection, new RegExp(tool));
+  }
+  assert.match(inspection, /200-row limit/);
+  assert.match(inspection, /Do not launch `sap-ai-dev` or `sap-ai-hana` for MCP operations/);
+  assert.match(inspection, /schema-bound/);
+  assert.match(inspection, /credential-like columns/);
+
+  const development = await readMarkdown(join(skillsRoot, 'hana-cloud-native-development', 'SKILL.md'));
+  assert.match(development, /cds build --for hana/);
+  assert.match(development, /CAP-owned database models/);
+  assert.match(development, /Never execute `cds deploy` against HANA/);
+  assert.match(development, /HANA DDL\/DML/);
+
+  const validation = await readMarkdown(join(skillsRoot, 'hana-cloud-validation', 'SKILL.md'));
+  assert.match(validation, /deployment handoff/);
+  assert.match(validation, /HANA tools are metadata and bounded read-only inspection only/);
+  assert.match(validation, /Never claim HANA activation\/deployment/);
+});

package/test/hana-config.test.mjs

@@ -0,0 +1,168 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { quoteHanaIdentifier, resolveHanaReadOnlyConfig } from '../src/hana-config.mjs';
+import { hanaConnectionOptions, HanaDatabase } from '../src/hana-database.mjs';
+
+const explicitEnv = {
+  HANA_RO_HOST: 'hana.example.test',
+  HANA_RO_PORT: '443',
+  HANA_RO_USER: 'INSPECTOR',
+  HANA_RO_PASSWORD: 'do-not-print-this',
+  HANA_RO_SCHEMA: 'HDI_CONTAINER_SCHEMA'
+};
+
+function vcapBinding(name, user = 'INSPECTOR') {
+  return {
+    name,
+    binding_name: name,
+    credentials: {
+      host: 'hana.example.test',
+      port: 443,
+      user,
+      password: 'vcap-secret-not-for-output',
+      schema: 'HDI_CONTAINER_SCHEMA',
+      hdi_user: 'HDI_DEPLOYER',
+      hdi_password: 'never-use-this'
+    }
+  };
+}
+
+test('resolves explicit read-only configuration and never disables TLS verification', () => {
+  const config = resolveHanaReadOnlyConfig(explicitEnv);
+  assert.equal(config.source, 'environment');
+  assert.equal(config.user, 'INSPECTOR');
+  assert.equal(config.password, 'do-not-print-this');
+  assert.equal(config.schema, 'HDI_CONTAINER_SCHEMA');
+  assert.equal(Object.isFrozen(config), true);
+  const options = hanaConnectionOptions(config);
+  assert.equal(options.encrypt, true);
+  assert.equal(options.sslValidateCertificate, true);
+  assert.equal(options.currentSchema, 'HDI_CONTAINER_SCHEMA');
+  assert.equal(options.pwd, 'do-not-print-this');
+});
+
+test('rejects incomplete explicit credentials instead of falling back to VCAP', () => {
+  assert.throws(() => resolveHanaReadOnlyConfig({
+    ...explicitEnv,
+    HANA_RO_PASSWORD: '',
+    VCAP_SERVICES: JSON.stringify({ hana: [vcapBinding('fallback')] })
+  }), /Explicit HANA read-only configuration is incomplete/);
+});
+
+test('resolves one selected HANA VCAP binding without using HDI deployment credentials', () => {
+  const config = resolveHanaReadOnlyConfig({
+    VCAP_SERVICES: JSON.stringify({ hana: [vcapBinding('inspection-binding')] }),
+    HANA_RO_BINDING: 'inspection-binding'
+  });
+  assert.equal(config.source, 'vcap-services');
+  assert.equal(config.bindingName, 'inspection-binding');
+  assert.equal(config.serviceName, 'hana');
+  assert.equal(config.user, 'INSPECTOR');
+  assert.equal(config.schema, 'HDI_CONTAINER_SCHEMA');
+  assert.equal(config.password, 'vcap-secret-not-for-output');
+});
+
+test('fails closed when VCAP contains multiple HANA bindings', () => {
+  const env = {
+    VCAP_SERVICES: JSON.stringify({ hana: [vcapBinding('first'), vcapBinding('second')] })
+  };
+  assert.throws(() => resolveHanaReadOnlyConfig(env), /Multiple HANA VCAP bindings/);
+  assert.equal(resolveHanaReadOnlyConfig({ ...env, HANA_RO_BINDING: 'second' }).bindingName, 'second');
+});
+
+test('rejects an HDI-deployer-only binding and does not disclose its credentials', () => {
+  const deployerOnly = {
+    name: 'deployer-only',
+    credentials: {
+      host: 'hana.example.test',
+      port: 443,
+      schema: 'HDI_CONTAINER_SCHEMA',
+      hdi_user: 'HDI_DEPLOYER',
+      hdi_password: 'never-use-this'
+    }
+  };
+  assert.throws(() => resolveHanaReadOnlyConfig({
+    VCAP_SERVICES: JSON.stringify({ hana: [deployerOnly] })
+  }), error => {
+    assert.match(error.message, /separate read-only binding/);
+    assert.doesNotMatch(error.message, /never-use-this/);
+    return true;
+  });
+});
+
+test('rejects a VCAP binding that aliases its read-only and deployment usernames', () => {
+  const binding = vcapBinding('aliased-binding', 'HDI_DEPLOYER');
+  assert.throws(() => resolveHanaReadOnlyConfig({
+    VCAP_SERVICES: JSON.stringify({ hana: [binding] })
+  }), /aliases its read-only and HDI deployment users/);
+});
+
+test('rejects bad host, port, missing schema, and missing VCAP configuration', () => {
+  assert.throws(() => resolveHanaReadOnlyConfig({ ...explicitEnv, HANA_RO_HOST: 'https://hana.example.test' }), /hostname/);
+  assert.throws(() => resolveHanaReadOnlyConfig({ ...explicitEnv, HANA_RO_PORT: '70000' }), /between 1 and 65535/);
+  assert.throws(() => resolveHanaReadOnlyConfig({ ...explicitEnv, HANA_RO_SCHEMA: '' }), /incomplete/);
+  assert.throws(() => resolveHanaReadOnlyConfig({}), /Set HANA_RO_\*/);
+});
+
+test('quotes identifiers by doubling embedded quotes and rejects control characters', () => {
+  assert.equal(quoteHanaIdentifier('A"B'), '"A""B"');
+  assert.throws(() => quoteHanaIdentifier('bad\nname'), /identifier is invalid/);
+});
+
+test('serializes database calls, passes bind values, and redacts native driver errors', async () => {
+  const calls = [];
+  let disconnects = 0;
+  const connection = {
+    connect(options, callback) {
+      calls.push({ type: 'connect', options });
+      callback(null);
+    },
+    exec(sql, params, options, callback) {
+      calls.push({ type: 'exec', sql, params, options });
+      if (sql === 'FAIL') callback(Object.assign(new Error('password=do-not-print-this'), { code: 'HY000' }));
+      else callback(null, [{ OK: true }]);
+    },
+    disconnect(callback) {
+      disconnects += 1;
+      callback(null);
+    }
+  };
+  const db = new HanaDatabase(connection, resolveHanaReadOnlyConfig(explicitEnv));
+  await db.connect();
+  assert.deepEqual(await db.query('SELECT ? FROM DUMMY', ['value']), [{ OK: true }]);
+  await assert.rejects(db.query('FAIL'), error => {
+    assert.equal(error.name, 'HanaDatabaseError');
+    assert.match(error.message, /HANA error HY000/);
+    assert.doesNotMatch(error.message, /do-not-print-this/);
+    return true;
+  });
+  assert.equal(calls[0].options.sslValidateCertificate, true);
+  assert.equal(calls[1].params[0], 'value');
+  assert.deepEqual(calls[1].options, {});
+  await db.close();
+  await db.close();
+  assert.equal(disconnects, 1);
+});
+
+test('times out a hung read, requests cancellation, and retires its connection', async () => {
+  let cancels = 0;
+  let disconnects = 0;
+  const connection = {
+    connect(_options, callback) { callback(null); },
+    exec() {},
+    cancel() { cancels += 1; },
+    disconnect(callback) { disconnects += 1; callback(null); }
+  };
+  const db = new HanaDatabase(connection, resolveHanaReadOnlyConfig(explicitEnv), { queryTimeoutMs: 5 });
+  await db.connect();
+  await assert.rejects(db.query('SELECT HANG FROM DUMMY'), error => {
+    assert.equal(error.name, 'HanaQueryTimeoutError');
+    assert.match(error.message, /time limit/);
+    assert.doesNotMatch(error.message, /do-not-print-this/);
+    return true;
+  });
+  assert.equal(cancels, 1);
+  assert.equal(disconnects, 1);
+  assert.equal(db.unusable, true);
+  await assert.rejects(db.query('SELECT 1 FROM DUMMY'), /not available/);
+});

package/test/hana-inspector-stdio.test.mjs

@@ -0,0 +1,44 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+
+const serverScript = fileURLToPath(new URL('../src/hana-inspector.mjs', import.meta.url));
+
+test('standalone HANA MCP process lists tools through stdio without emitting secrets or diagnostics on stdout', async t => {
+  const transport = new StdioClientTransport({
+    command: process.execPath,
+    args: [serverScript],
+    cwd: process.cwd(),
+    env: {
+      PATH: process.env.PATH || '',
+      HANA_RO_HOST: 'hana.example.test',
+      HANA_RO_PORT: '443',
+      HANA_RO_USER: 'INSPECTOR',
+      HANA_RO_PASSWORD: 'never-emit-this-secret',
+      HANA_RO_SCHEMA: 'HDI_SCHEMA'
+    },
+    stderr: 'pipe'
+  });
+  const client = new Client({ name: 'hana-stdio-smoke', version: '1.0.0' });
+  const stderr = transport.stderr;
+  let stderrText = '';
+  stderr?.setEncoding('utf8');
+  stderr?.on('data', chunk => { stderrText += chunk; });
+  t.after(async () => {
+    await client.close().catch(() => {});
+    await transport.close().catch(() => {});
+  });
+
+  await client.connect(transport);
+  const listed = await client.listTools();
+  assert.deepEqual(listed.tools.map(tool => tool.name).sort(), [
+    'hana_connection_info',
+    'hana_describe_object',
+    'hana_list_objects',
+    'hana_read_rows'
+  ]);
+  assert.equal(stderrText.includes('never-emit-this-secret'), false);
+  assert.equal(stderrText.includes('HANA_RO_PASSWORD='), false);
+});

package/test/hana-tools.test.mjs

@@ -0,0 +1,206 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { createHanaInspector } from '../src/hana-inspector.mjs';
+
+const env = {
+  HANA_RO_HOST: 'hana.example.test',
+  HANA_RO_PORT: '443',
+  HANA_RO_USER: 'INSPECTOR',
+  HANA_RO_PASSWORD: 'test-secret',
+  HANA_RO_SCHEMA: 'HDI_SCHEMA'
+};
+
+function fakeDatabase({ rowResult = [{ ID: 7, TITLE: 'Catalog item' }], columns: columnOverride } = {}) {
+  const calls = [];
+  let closed = false;
+  const columns = columnOverride || [
+    { COLUMN_NAME: 'ID', POSITION: 1, DATA_TYPE_NAME: 'INTEGER', LENGTH: 10, SCALE: 0, IS_NULLABLE: 'FALSE' },
+    { COLUMN_NAME: 'TITLE', POSITION: 2, DATA_TYPE_NAME: 'NVARCHAR', LENGTH: 80, SCALE: 0, IS_NULLABLE: 'TRUE' }
+  ];
+  return {
+    calls,
+    get closed() { return closed; },
+    async query(sql, values = []) {
+      calls.push({ sql, values });
+      if (sql.includes('CURRENT_SCHEMA')) return [{ CURRENT_SCHEMA: 'HDI_SCHEMA', CURRENT_USER: 'INSPECTOR' }];
+      if (sql.includes('FROM SYS.TABLES') && sql.includes('TABLE_NAME = ?')) {
+        return values[1] === 'BOOKS' ? [{ OBJECT_NAME: 'BOOKS' }] : [];
+      }
+      if (sql.includes('FROM SYS.VIEWS') && sql.includes('VIEW_NAME = ?')) {
+        return values[1] === 'BOOKS_VIEW' ? [{ OBJECT_NAME: 'BOOKS_VIEW' }] : [];
+      }
+      if (sql.includes('FROM SYS.TABLES') && sql.includes('ORDER BY TABLE_NAME')) return [{ OBJECT_NAME: 'BOOKS' }];
+      if (sql.includes('FROM SYS.VIEWS') && sql.includes('ORDER BY VIEW_NAME')) return [{ OBJECT_NAME: 'BOOKS_VIEW' }];
+      if (sql.includes('FROM SYS.TABLE_COLUMNS')) return columns;
+      if (sql.includes('FROM SYS.VIEW_COLUMNS')) return columns;
+      if (sql.startsWith('SELECT "')) return rowResult;
+      throw new Error(`Unexpected test SQL: ${sql}`);
+    },
+    async close() { closed = true; }
+  };
+}
+
+async function connectTestClient(t, database) {
+  const runtime = createHanaInspector({ env, databaseFactory: async () => database });
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+  const client = new Client({ name: 'hana-test-client', version: '1.0.0' });
+  await runtime.server.connect(serverTransport);
+  await client.connect(clientTransport);
+  t.after(async () => {
+    await client.close().catch(() => {});
+    await runtime.close();
+  });
+  return { client, runtime };
+}
+
+function parseResult(response) {
+  assert.equal(response.isError, undefined, response.content?.[0]?.text);
+  return JSON.parse(response.content[0].text);
+}
+
+test('advertises only bounded, read-only HANA tools with no arbitrary SQL input', async t => {
+  const database = fakeDatabase();
+  const { client } = await connectTestClient(t, database);
+  const result = await client.listTools();
+  const tools = new Map(result.tools.map(tool => [tool.name, tool]));
+  assert.deepEqual([...tools.keys()].sort(), [
+    'hana_connection_info',
+    'hana_describe_object',
+    'hana_list_objects',
+    'hana_read_rows'
+  ]);
+  for (const tool of tools.values()) {
+    assert.equal(tool.annotations?.readOnlyHint, true);
+    assert.equal(tool.annotations?.destructiveHint, false);
+  }
+  const readRowsSchema = tools.get('hana_read_rows').inputSchema;
+  assert.ok(readRowsSchema.properties.objectName);
+  assert.ok(readRowsSchema.properties.columns);
+  assert.equal(readRowsSchema.properties.sql, undefined);
+  assert.equal(readRowsSchema.properties.schema, undefined);
+});
+
+test('returns connection identity and schema-scoped object/column metadata', async t => {
+  const database = fakeDatabase();
+  const { client } = await connectTestClient(t, database);
+
+  const identity = parseResult(await client.callTool({ name: 'hana_connection_info', arguments: {} }));
+  assert.equal(identity.currentSchema, 'HDI_SCHEMA');
+  assert.equal(identity.databaseUser, 'INSPECTOR');
+  assert.equal(identity.tls, 'enabled; certificate verification required');
+  assert.equal(JSON.stringify(identity).includes('test-secret'), false);
+
+  const objects = parseResult(await client.callTool({ name: 'hana_list_objects', arguments: { objectType: 'ALL', maxResults: 10 } }));
+  assert.deepEqual(objects.objects, [
+    { objectName: 'BOOKS', objectType: 'TABLE' },
+    { objectName: 'BOOKS_VIEW', objectType: 'VIEW' }
+  ]);
+  assert.ok(database.calls.every(call => call.values.every(value => value !== 'OTHER_SCHEMA')));
+
+  const description = parseResult(await client.callTool({ name: 'hana_describe_object', arguments: { objectName: 'BOOKS' } }));
+  assert.equal(description.schema, 'HDI_SCHEMA');
+  assert.deepEqual(description.columns.map(column => column.COLUMN_NAME), ['ID', 'TITLE']);
+});
+
+test('reads only catalog-verified columns with bound filters and a fixed HDI schema', async t => {
+  const database = fakeDatabase();
+  const { client } = await connectTestClient(t, database);
+  const response = parseResult(await client.callTool({
+    name: 'hana_read_rows',
+    arguments: {
+      objectName: 'BOOKS',
+      schema: 'OTHER_SCHEMA',
+      columns: ['ID', 'TITLE'],
+      filters: [{ column: 'ID', operator: 'gt', value: 4 }],
+      orderBy: { column: 'ID', direction: 'ASC' },
+      limit: 10
+    }
+  }));
+  assert.deepEqual(response.rows, [{ ID: 7, TITLE: 'Catalog item' }]);
+  const dataQuery = database.calls.find(call => call.sql.startsWith('SELECT "ID"'));
+  assert.ok(dataQuery);
+  assert.match(dataQuery.sql, /FROM "HDI_SCHEMA"\."BOOKS"/);
+  assert.doesNotMatch(dataQuery.sql, /OTHER_SCHEMA/);
+  assert.deepEqual(dataQuery.values, [4]);
+  assert.match(dataQuery.sql, /LIMIT 10$/);
+});
+
+test('binds hostile object names and rejects unknown columns without executing a data query', async t => {
+  const database = fakeDatabase();
+  const { client } = await connectTestClient(t, database);
+  const maliciousName = 'BOOKS"; DROP TABLE X;--';
+  const response = await client.callTool({
+    name: 'hana_read_rows',
+    arguments: { objectName: maliciousName, columns: ['ID'], limit: 1 }
+  });
+  assert.equal(response.isError, true);
+  assert.equal(database.calls.some(call => call.sql.includes('DROP TABLE')), false);
+  const lookup = database.calls.find(call => call.sql.includes('TABLE_NAME = ?'));
+  assert.deepEqual(lookup.values, ['HDI_SCHEMA', maliciousName]);
+
+  const invalidColumn = await client.callTool({
+    name: 'hana_read_rows',
+    arguments: { objectName: 'BOOKS', columns: ['SECRET'], limit: 1 }
+  });
+  assert.equal(invalidColumn.isError, true);
+  assert.equal(database.calls.some(call => call.sql.startsWith('SELECT "SECRET"')), false);
+});
+
+test('bounds object and row limits and refuses oversized results', async t => {
+  const largeDatabase = fakeDatabase({ rowResult: [{ ID: 1, TITLE: 'x'.repeat(100_000) }] });
+  const { client } = await connectTestClient(t, largeDatabase);
+  const tooManyObjects = await client.callTool({
+    name: 'hana_list_objects',
+    arguments: { objectType: 'TABLE', maxResults: 201 }
+  });
+  assert.equal(tooManyObjects.isError, true);
+
+  const tooLarge = await client.callTool({
+    name: 'hana_read_rows',
+    arguments: { objectName: 'BOOKS', columns: ['ID', 'TITLE'], limit: 1 }
+  });
+  assert.equal(tooLarge.isError, true);
+  assert.match(tooLarge.content[0].text, /too large to return safely/);
+  assert.ok(Buffer.byteLength(tooLarge.content[0].text) < 1000);
+});
+
+test('rejects unbounded or oversized column selections before fetching row data', async t => {
+  const database = fakeDatabase({ columns: [
+    { COLUMN_NAME: 'ID', POSITION: 1, DATA_TYPE_NAME: 'INTEGER', LENGTH: 10, SCALE: 0, IS_NULLABLE: 'FALSE' },
+    { COLUMN_NAME: 'BODY', POSITION: 2, DATA_TYPE_NAME: 'NCLOB', LENGTH: 0, SCALE: 0, IS_NULLABLE: 'TRUE' },
+    { COLUMN_NAME: 'WIDE', POSITION: 3, DATA_TYPE_NAME: 'NVARCHAR', LENGTH: 9000, SCALE: 0, IS_NULLABLE: 'TRUE' },
+    { COLUMN_NAME: 'API_KEY', POSITION: 4, DATA_TYPE_NAME: 'NVARCHAR', LENGTH: 128, SCALE: 0, IS_NULLABLE: 'TRUE' }
+  ] });
+  const { client } = await connectTestClient(t, database);
+
+  const lob = await client.callTool({
+    name: 'hana_read_rows',
+    arguments: { objectName: 'BOOKS', columns: ['BODY'], limit: 1 }
+  });
+  assert.equal(lob.isError, true);
+  assert.match(lob.content[0].text, /LOB and binary columns are not supported/);
+
+  const oversized = await client.callTool({
+    name: 'hana_read_rows',
+    arguments: { objectName: 'BOOKS', columns: ['WIDE'], limit: 1 }
+  });
+  assert.equal(oversized.isError, true);
+  assert.match(oversized.content[0].text, /safe row-width limit/);
+  const credential = await client.callTool({
+    name: 'hana_read_rows',
+    arguments: { objectName: 'BOOKS', columns: ['API_KEY'], limit: 1 }
+  });
+  assert.equal(credential.isError, true);
+  assert.match(credential.content[0].text, /Credential-like columns/);
+  assert.equal(database.calls.some(call => ['BODY', 'WIDE', 'API_KEY'].some(name => call.sql.startsWith(`SELECT "${name}"`))), false);
+});
+
+test('closes the connected database when the server runtime closes', async t => {
+  const database = fakeDatabase();
+  const { client, runtime } = await connectTestClient(t, database);
+  await client.callTool({ name: 'hana_connection_info', arguments: {} });
+  await runtime.close();
+  assert.equal(database.closed, true);
+});