dsh-ris-yds 0.0.0-stage → 1.1.0

package/test/ide-proxy.test.mjs

@@ -0,0 +1,256 @@
+// Tests for the borrowed proxy engine: rule generation, discovery order, and the
+// fallback decision when dsh-ris-ide is not installed.
+import assert from 'node:assert/strict'
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import test from 'node:test'
+
+import {
+  YDS_RULE_SOURCE, applyGitProxy, ensureBorrowedProxy, gitHostOf, ideProxyCandidates,
+  isIpv4Literal, isPrivateIpv4, loadIdeProxy, privateSegmentsOf, proxyRulesFromTargets,
+  shadowTargetsFromTargets,
+  toProcessPattern, yoncodeRules, programKeyOf, ydsRulesFor,
+} from '../lib/ide-proxy.js'
+import { mergeYdsRules } from '../lib/rules.js'
+
+test('only a dotted-quad IPv4 literal counts as bindable', () => {
+  assert.equal(isIpv4Literal('172.20.235.80'), true)
+  assert.equal(isIpv4Literal('172.20.235.*'), false, 'a wildcard cannot be pre-bound')
+  assert.equal(isIpv4Literal('srmdev.hanslaser.com'), false)
+  assert.equal(isIpv4Literal(''), false)
+})
+
+test('rules name real programs on both sides: java/git and their WSL-side twins', () => {
+  const targets = [
+    { host: '172.20.235.80', port: 1521 },
+    { host: '172.20.235.81', port: 6890, isRedis: true },
+    { host: '172.20.235.81', port: 6880 },
+    // a second internal /24 must fold into the SAME java row
+    { host: '172.20.63.131', port: 31010 },
+    // duplicates collapse, garbage is dropped
+    { host: '172.20.235.81', port: 6880 },
+    { host: 'srmdev.hanslaser.com', port: 443 },
+    { host: '', port: 1 },
+    { host: '10.0.0.1', port: 0 },
+    { host: '10.0.0.1', port: 70000 },
+  ]
+  // On a WSL/Linux host the WSL side is the one that matters: `java.exe` is the Windows
+  // image, `java` is the process name ProxyBridge matches on the Linux side, and the
+  // missing local rows were why a WSL JVM was never intercepted.
+  const rules = proxyRulesFromTargets(targets, { gitHost: 'gitlab.hanslaser.com', java: true, platform: 'linux' })
+  assert.deepEqual(rules.map((rule) => `${rule.id}|${rule.side}|${rule.program}|${rule.hosts}|${rule.ports}`), [
+    'yds-java|windows|java.exe|172.20.235.*,172.20.63.*|*',
+    'yds-git|windows|git.exe|gitlab.hanslaser.com|*',
+    'yds-java-local|local|java|172.20.235.*,172.20.63.*|*',
+    'yds-git-local|local|git|gitlab.hanslaser.com|*',
+  ])
+  assert.equal(rules.every((rule) => rule.source === YDS_RULE_SOURCE), true)
+  assert.equal(rules.every((rule) => rule.program !== 'jdbc'), true, 'jdbc is not a process name')
+  assert.equal(programKeyOf(rules[0].program), 'java')
+  assert.equal(programKeyOf(rules[2].program), 'java', 'the local row names the same program on its side')
+  assert.equal(rules.every((rule) => rule.shadow === false), true, 'the table holds intent only; no mapping rows')
+  assert.equal(rules.every((rule) => rule.workspace === undefined), true, 'the table is global: workspace is not part of a row')
+  // Windows has no Linux side: only the `.exe` rows are generated there.
+  const windows = proxyRulesFromTargets(targets, { gitHost: 'gitlab.hanslaser.com', java: true, platform: 'win32' })
+  assert.deepEqual(windows.map((rule) => rule.id), ['yds-java', 'yds-git'])
+  // Without a git URL there is no git rule to write (on either side).
+  const noGit = proxyRulesFromTargets([{ host: '172.20.235.80', port: 1521 }], { gitHost: '', java: true, platform: 'linux' })
+  assert.equal(noGit.some((rule) => rule.program === 'git'), false)
+})
+
+test('the no-root fallback is a separate listener list, not rules', () => {
+  const targets = [
+    { host: '172.20.235.80', port: 1521 },
+    { host: '172.20.235.81', port: 6890 },
+    { host: '172.20.235.81', port: 6890 },
+    { host: 'srmdev.hanslaser.com', port: 443 },
+    { host: '10.0.0.1', port: 70000 },
+  ]
+  assert.deepEqual(shadowTargetsFromTargets(targets), [
+    { host: '172.20.235.80', port: 1521 },
+    { host: '172.20.235.81', port: 6890 },
+  ], 'one listener per literal IPv4 endpoint, duplicates collapsed, hostnames skipped')
+  assert.deepEqual(shadowTargetsFromTargets([null, undefined, {}]), [])
+})
+
+
+test('the git host comes from the clone URL, never from a guess', () => {
+  assert.equal(gitHostOf({ git: { url: 'https://gitlab.hanslaser.com/hans-dev/hans-asset/yonasset.git' } }), 'gitlab.hanslaser.com')
+  assert.equal(gitHostOf({ git: { url: 'not a url' } }), '')
+  assert.equal(gitHostOf({ git: null }), '')
+})
+
+test('candidate locations cover the profile link, a workspace install and a sibling checkout', () => {
+  const list = ideProxyCandidates({ workspace: '/w' })
+  assert.ok(list.some((path) => path === '/w/node_modules/dsh-ris-ide/lib/proxy.js'))
+  assert.ok(list.some((path) => path === '/w/work/dsh-ris-ide/lib/proxy.js'))
+  // join() normalizes, so the sibling checkout resolves next to the workspace.
+  assert.ok(list.some((path) => path === '/dsh-ris-ide/lib/proxy.js'))
+  assert.ok(list.some((path) => path.endsWith('.dsh/profiles/web/node_modules/dsh-ris-ide/lib/proxy.js')))
+})
+
+test('a machine without dsh-ris-ide reports unavailable instead of throwing', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'yds-proxy-'))
+  const previous = process.env.YDS_IDE_PROXY
+  try {
+    // The documented off switch: no search at all, so the machine's real install
+    // cannot leak into the test.
+    process.env.YDS_IDE_PROXY = 'none'
+    const loaded = await loadIdeProxy({ workspace: dir })
+    assert.equal(loaded.available, false)
+    assert.match(loaded.error, /YDS_IDE_PROXY=none/)
+  } finally {
+    if (previous === undefined) delete process.env.YDS_IDE_PROXY
+    else process.env.YDS_IDE_PROXY = previous
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+test('direct mode never touches the proxy engine', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'yds-proxy-'))
+  try {
+    const result = await ensureBorrowedProxy({ workspace: dir, socks: null, proxyEngine: 'auto' }, [{ host: '10.0.0.1', port: 1521 }])
+    assert.equal(result.mode, 'none')
+    // …and the git helper refuses politely instead of writing a broken entry.
+    const git = await applyGitProxy({ workspace: dir, socks: null }, { enabled: true })
+    assert.equal(git.ok, false)
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+test('proxy.engine=self disables the borrow even when the engine is present', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'yds-proxy-'))
+  try {
+    const result = await ensureBorrowedProxy(
+      { workspace: dir, socks: { host: '10.3.91.121', port: 1080 }, proxyEngine: 'self' },
+      [{ host: '172.20.235.80', port: 1521 }],
+    )
+    assert.equal(result.mode, 'unavailable')
+    assert.match(result.error, /proxy\.engine=self/)
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+test('a broken engine module is reported, not fatal', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'yds-proxy-'))
+  const previous = process.env.YDS_IDE_PROXY
+  try {
+    mkdirSync(join(dir, 'lib'), { recursive: true })
+    writeFileSync(join(dir, 'lib', 'proxy.js'), 'export default {}\n')
+    process.env.YDS_IDE_PROXY = join(dir, 'lib', 'proxy.js')
+    const loaded = await loadIdeProxy({ workspace: dir })
+    assert.equal(loaded.available, false)
+    assert.match(loaded.error, /不完整/)
+  } finally {
+    if (previous === undefined) delete process.env.YDS_IDE_PROXY
+    else process.env.YDS_IDE_PROXY = previous
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+test('YonCode own executables get their own labelled rules', async () => {
+  const { mkdtempSync, mkdirSync, writeFileSync } = await import('node:fs')
+  const { tmpdir } = await import('node:os')
+  const home = mkdtempSync(join(tmpdir(), 'yds-yoncode-'))
+  mkdirSync(join(home, 'devkit', 'jdk21.0.7', 'bin'), { recursive: true })
+  writeFileSync(join(home, 'devkit', 'jdk21.0.7', 'bin', 'java.exe'), '')
+  const gitDir = mkdtempSync(join(tmpdir(), 'yds-git-'))
+  const gitExe = join(gitDir, 'git.exe')
+  writeFileSync(gitExe, '')
+  // A POSIX home keeps the pattern POSIX; /mnt/<drive>/ paths are rewritten to a
+  // drive letter, which is what ProxyBridge on Windows compares against.
+  const rules = yoncodeRules({ workspace: '/w' }, {
+    homes: [home],
+    gitPaths: [gitExe],
+    gitHost: 'gitlab.example.com',
+    hosts: ['172.20.235.*', '172.20.63.*'],
+  })
+  assert.deepEqual(rules.map((rule) => rule.id), ['yds-yoncode-java', 'yds-yoncode-git'])
+  assert.deepEqual(rules.map((rule) => rule.label), ['YonCode java', 'YonCode git'])
+  // The image name, not a file under the devkit: a JDK upgrade keeps working and
+  // every java.exe on the machine is covered.
+  assert.equal(rules[0].program, 'java.exe')
+  // The range comes from the endpoints we resolved, never from a hardcoded vendor range.
+  assert.equal(rules[0].hosts, '172.20.235.*,172.20.63.*')
+  assert.equal(rules[0].ports, '*')
+  assert.equal(rules[0].shadow, false)
+  assert.equal(rules[1].program, 'git.exe')
+  assert.equal(rules[1].hosts, 'gitlab.example.com')
+  assert.equal(rules.every((rule) => rule.source === 'yds'), true)
+  // No YonCode install and no git: no rows invented.
+  assert.deepEqual(yoncodeRules({}, { homes: [home], gitPaths: [], gitHost: 'x', hosts: ['10.0.0.*'] }).map((r) => r.id), ['yds-yoncode-java'])
+  // No resolved endpoint range = no java row invented (a row with an empty host list
+  // would match nothing, and a guessed range would redirect the wrong traffic).
+  assert.deepEqual(yoncodeRules({}, { homes: [home], gitPaths: [], gitHost: 'x' }), [])
+  assert.deepEqual(yoncodeRules({}, { homes: [], gitPaths: [], gitHost: 'x' }), [])
+})
+
+test('executable rows inherit the private ranges of the resolved endpoints', () => {
+  const segments = privateSegmentsOf(
+    [{ host: '172.20.235.80', port: 1521 }, { host: '172.20.235.81', port: 6890 }, { host: 'gitlab.example.com', port: 443 }],
+    ['172.20.63.131'],
+  )
+  assert.deepEqual(segments, ['172.20.235.*', '172.20.63.*'])
+  assert.deepEqual(privateSegmentsOf([], []), [])
+})
+
+test('the yds rows are a whole-table write: the global set replaces the old yds rows', () => {
+  // The table is one global list. A save carries the complete table: the user's rows
+  // pass through, the previous yds rows are replaced by this run's set (never unioned
+  // with another project's, because there is no other project's share any more).
+  const merged = mergeYdsRules(
+    [
+      { id: 'user-1', program: 'navicat.exe', hosts: '10.9.9.*', source: 'user' },
+      { id: 'yds-java-old', program: 'java.exe', hosts: '172.20.235.*', ports: '*', enabled: true, source: 'yds', workspace: '/ws-a' },
+      { id: 'yds-git-old', program: 'git.exe', hosts: 'gitlab.example.com', ports: '*', enabled: true, source: 'yds', workspace: '/ws-a' },
+    ],
+    [
+      { id: 'yds-java', program: 'java.exe', side: 'windows', hosts: '172.20.235.*,172.20.63.*', ports: '*', enabled: true, source: 'yds' },
+      { id: 'yds-java-local', program: 'java', side: 'local', hosts: '172.20.235.*,172.20.63.*', ports: '*', enabled: true, source: 'yds' },
+    ],
+  )
+  assert.deepEqual(merged.map((row) => row.id), ['user-1', 'yds-java', 'yds-java-local'])
+  assert.equal(merged.filter((row) => row.source === 'yds').length, 2, 'one row per side, not per workspace')
+  assert.equal(merged[1].hosts, '172.20.235.*,172.20.63.*')
+  assert.equal(merged.every((row) => row.workspace === undefined || row.source !== 'yds'), true, 'no workspace column on global rows')
+})
+
+test('the rules this project writes are the full side-aware set', () => {
+  const rows = ydsRulesFor(
+    { workspace: '/w', proxyJavaRules: true, git: { url: 'https://gitlab.hanslaser.com/x/y.git' } },
+    [{ host: '172.20.235.80', port: 1521 }],
+    { platform: 'linux' },
+  )
+  assert.deepEqual(rows.map((row) => row.id), ['yds-java', 'yds-git', 'yds-java-local', 'yds-git-local'])
+  assert.deepEqual(rows.map((row) => row.side), ['windows', 'windows', 'local', 'local'])
+  // A second start from another workspace produces the same shape: the last save wins.
+  const again = ydsRulesFor(
+    { workspace: '/other', proxyJavaRules: true, git: { url: 'https://gitlab.hanslaser.com/x/y.git' } },
+    [{ host: '172.20.63.131', port: 1521 }],
+    { platform: 'linux' },
+  )
+  assert.equal(again.find((row) => row.id === 'yds-java').hosts, '172.20.63.*', 'the fresh run owns the row')
+})
+
+test('a mounted YonCode path becomes a drive-letter pattern', () => {
+  assert.equal(toProcessPattern('/mnt/d/Program Files/YonCode/devkit/x/bin/java.exe'), 'D:\\Program Files\\YonCode\\devkit\\x\\bin\\java.exe')
+  assert.equal(toProcessPattern('C:\\Program Files\\YonCode\\x\\java.exe'), 'C:\\Program Files\\YonCode\\x\\java.exe')
+  assert.equal(toProcessPattern('/opt/YonCode/devkit/x/bin/java'), '/opt/YonCode/devkit/x/bin/java')
+})
+
+test('duplicates collapse only within one side+program, never across programs', () => {
+  const rows = mergeYdsRules([], [
+    { id: 'a', program: 'java.exe', side: 'windows', hosts: '10.0.0.*' },
+    { id: 'b', program: 'C:\\Program Files\\YonCode\\devkit\\jdk21\\bin\\java.exe', side: 'windows', hosts: '10.0.0.*' },
+    { id: 'c', program: 'git.exe', side: 'windows', hosts: 'gitlab.example.com' },
+    { id: 'd', program: 'git', side: 'local', hosts: 'gitlab.example.com' },
+    { id: 'e', program: '' },
+  ])
+  assert.deepEqual(rows.map((row) => row.id), ['a', 'c', 'd'])
+  assert.equal(rows[0].hosts, '10.0.0.*', 'the duplicate spelling contributes no new host')
+  assert.equal(programKeyOf('C:\\Program Files\\Git\\bin\\git.exe'), 'git')
+  assert.equal(programKeyOf('java'), 'java')
+})

package/test/ide-watch.test.mjs

@@ -0,0 +1,79 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync } from 'node:fs'
+import { readFileSync as readFile } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { listWatched, reconcileOnce, registerWorkspace, unregisterWorkspace, watchWorkspace } from '../lib/ide-watch.js'
+
+function sandbox() {
+  return mkdtempSync(join(tmpdir(), 'yds-watch-'))
+}
+
+test('registration survives in the state file and remove takes it out', () => {
+  const home = sandbox()
+  const ws = sandbox()
+  assert.deepEqual(listWatched(home), [])
+  const added = registerWorkspace(ws, home)
+  assert.equal(added.ok, true)
+  assert.deepEqual(added.workspaces, [ws])
+  assert.deepEqual(listWatched(home), [ws])
+  registerWorkspace(ws, home)
+  assert.equal(listWatched(home).length, 1, 'registering twice keeps one entry')
+  const removed = unregisterWorkspace(ws, home)
+  assert.deepEqual(removed.workspaces, [])
+  assert.equal(existsSync(join(home, '.dsh-ris-yds', 'ide-watch.json')), false, 'last removal drops the file')
+  rmSync(home, { recursive: true, force: true })
+  rmSync(ws, { recursive: true, force: true })
+})
+
+test('nothing happens without a config file or without a repair step', async () => {
+  const ws = sandbox()
+  let calls = 0
+  const repair = async () => { calls += 1; return { changed: true } }
+  assert.deepEqual(await reconcileOnce(ws, { repair }), { changed: false, reason: 'no-config' })
+  mkdirSync(join(ws, '.dsh-ris-ide'), { recursive: true })
+  writeFileSync(join(ws, '.dsh-ris-ide', 'config.json'), '{"programs":[]}')
+  assert.deepEqual(await reconcileOnce(ws, {}), { changed: false, reason: 'no-repair' })
+  assert.equal(calls, 0)
+  rmSync(ws, { recursive: true, force: true })
+})
+
+test('a restore that writes nothing is reported as a no-op', async () => {
+  const ws = sandbox()
+  mkdirSync(join(ws, '.dsh-ris-ide'), { recursive: true })
+  writeFileSync(join(ws, '.dsh-ris-ide', 'config.json'), '{"programs":[]}')
+  const result = await reconcileOnce(ws, { repair: async () => ({ changed: true, reason: 'unchanged' }) })
+  assert.deepEqual(result, { changed: false, reason: 'no-op' })
+  rmSync(ws, { recursive: true, force: true })
+})
+
+test('a rewrite by ris-ide triggers the repair and the row comes back', async () => {
+  const ws = sandbox()
+  mkdirSync(join(ws, '.dsh-ris-ide'), { recursive: true })
+  const configPath = join(ws, '.dsh-ris-ide', 'config.json')
+  writeFileSync(configPath, '{"programs":[]}')
+  // minimal stand-in for applyIdeConfig: put our row back
+  const repair = async () => {
+    const doc = JSON.parse(readFileSync(configPath, 'utf8'))
+    doc.programs = [{ id: 'yds:demo', name: 'demo', kind: 'spring' }]
+    writeFileSync(configPath, JSON.stringify(doc))
+    return { changed: true, reason: 'added' }
+  }
+  const stop = watchWorkspace(ws, { repair })
+  try {
+    await new Promise((resolve) => setTimeout(resolve, 200))
+    // ris-ide regenerates the file without our row
+    writeFileSync(configPath, '{"programs":[{"id":"frontend:x#start","name":"x","kind":"frontend"}]}')
+    for (let i = 0; i < 60; i += 1) {
+      await new Promise((resolve) => setTimeout(resolve, 100))
+      const rows = JSON.parse(readFileSync(configPath, 'utf8')).programs
+      if (rows.some((row) => row.id === 'yds:demo')) break
+    }
+    const rows = JSON.parse(readFile(configPath, 'utf8')).programs
+    assert.ok(rows.some((row) => row.id === 'yds:demo'), 'the launcher row is back')
+  } finally {
+    stop()
+    rmSync(ws, { recursive: true, force: true })
+  }
+})

package/test/launch-proxy.test.mjs

@@ -0,0 +1,83 @@
+/**
+ * The tunnel flags we add to .vscode/launch.json: written only while a tunnel
+ * exists, and taken back out when the proxy stops.
+ */
+import assert from 'node:assert/strict'
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+
+import { LAUNCH_CONFIG, LAUNCH_ENTRY_NAME, applyLaunchConfig, ourLaunchEntry, proxyVmArgs, readLaunchConfig, stripLaunchProxy } from '../lib/ide.js'
+
+/** A project dir with a user-owned launch.json that must survive untouched. */
+function project(withEntry = false) {
+  const dir = mkdtempSync(join(tmpdir(), 'yds-launch-'))
+  mkdirSync(join(dir, '.vscode'), { recursive: true })
+  const doc = {
+    version: '0.2.0',
+    configurations: [{ type: 'java', name: 'MDFApplication', mainClass: 'x.Y', vmArgs: ['-Xmx512m'] }],
+  }
+  if (withEntry) {
+    doc.configurations.push({ type: 'java', name: LAUNCH_ENTRY_NAME, vmArgs: ['-Dyms.dev=true'] })
+  }
+  writeFileSync(join(dir, LAUNCH_CONFIG), `${JSON.stringify(doc, null, 2)}\n`)
+  return dir
+}
+
+const cfg = (dir, socks) => ({ projectDir: dir, workspace: dir, socks })
+
+test('proxy flags are derived from .env SOCKS and absent without one', () => {
+  assert.deepEqual(proxyVmArgs({ socks: { host: '10.3.91.121', port: 1080 } }), [
+    '-DsocksProxyHost=10.3.91.121',
+    '-DsocksProxyPort=1080',
+    '-Djava.net.useSystemProxies=false',
+  ])
+  assert.deepEqual(proxyVmArgs({ socks: null }), [], 'no tunnel, no flags')
+  assert.deepEqual(proxyVmArgs({}), [])
+})
+
+test('apply writes the flags for our entry and leaves other configurations alone', () => {
+  const dir = project()
+  try {
+    const result = applyLaunchConfig(cfg(dir, { host: '10.3.91.121', port: 1080 }))
+    assert.equal(result.changed, true)
+    const doc = readLaunchConfig(dir).parsed
+    const ours = doc.configurations.find((entry) => entry.name === LAUNCH_ENTRY_NAME)
+    assert.ok(ours.vmArgs.includes('-DsocksProxyHost=10.3.91.121'))
+    const user = doc.configurations.find((entry) => entry.name === 'MDFApplication')
+    assert.deepEqual(user.vmArgs, ['-Xmx512m'], 'the user configuration must be byte-identical')
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+test('stripping removes exactly the proxy flags and is a no-op afterwards', () => {
+  const dir = project()
+  try {
+    applyLaunchConfig(cfg(dir, { host: '10.3.91.121', port: 1080 }))
+    const first = stripLaunchProxy(cfg(dir, null))
+    assert.equal(first.changed, true)
+    assert.equal(first.action, 'stripped')
+    const ours = readLaunchConfig(dir).parsed.configurations.find((entry) => entry.name === LAUNCH_ENTRY_NAME)
+    assert.equal(ours.vmArgs.filter((value) => /socksProxy|useSystemProxies/.test(value)).length, 0)
+    assert.deepEqual(ours.vmArgs, ourLaunchEntry({}).vmArgs, 'the entry is back to its canonical (proxy-free) form')
+    assert.equal(stripLaunchProxy(cfg(dir, null)).changed, false, 'nothing left to strip')
+    // The user's configuration is still untouched by either side of the cycle.
+    assert.deepEqual(readLaunchConfig(dir).parsed.configurations.find((entry) => entry.name === 'MDFApplication').vmArgs, ['-Xmx512m'])
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+test('stripping a file without our entry does nothing', () => {
+  const dir = project()
+  try {
+    const result = stripLaunchProxy(cfg(dir, null))
+    assert.equal(result.changed, false)
+    assert.equal(result.action, 'not-present')
+    assert.equal(readFileSync(join(dir, LAUNCH_CONFIG), 'utf8').includes(LAUNCH_ENTRY_NAME), false)
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})

package/test/lease-release.test.mjs

@@ -0,0 +1,76 @@
+// A failed lease release must keep the local record: forgetting it turned a
+// transient daemon failure into "nobody owns the engine", resolved only by the
+// daemon's pid sweep (review D-P2-6).
+import assert from 'node:assert/strict'
+import { createServer } from 'node:http'
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import test from 'node:test'
+
+const home = mkdtempSync(join(tmpdir(), 'yds-lease-'))
+const WS = mkdtempSync(join(tmpdir(), 'yds-lease-ws-'))
+let mode = 'ok'
+let server = null
+let port = 0
+
+test.before(async () => {
+  server = createServer((req, res) => {
+    const send = (status, payload) => {
+      res.writeHead(status, { 'content-type': 'application/json' })
+      res.end(`${JSON.stringify(payload)}\n`)
+    }
+    if (req.method === 'GET' && req.url === '/v1/health') {
+      return send(200, { ok: true, apiVersion: 1, version: 'test' })
+    }
+    if (req.method === 'POST' && req.url === '/v1/leases') {
+      return send(200, { ok: true, lease: { id: 'lease-1' } })
+    }
+    if (req.method === 'DELETE' && req.url.startsWith('/v1/leases/')) {
+      if (mode === 'fail') return send(500, { ok: false, error: 'daemon broke' })
+      return send(200, { ok: true, released: true })
+    }
+    return send(404, { ok: false })
+  })
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve))
+  port = server.address().port
+  writeFileSync(join(home, 'risd.json'), `${JSON.stringify({
+    apiVersion: 1, version: 'test', pid: process.pid, port, token: 'test-token',
+  })}\n`, { mode: 0o600 })
+  process.env.DSH_RIS_IDE_PROXY_HOME = home
+  process.env.YDS_IDE_PROXY = 'none'
+})
+
+test.after(() => {
+  server?.close()
+  rmSync(home, { recursive: true, force: true })
+  rmSync(join(home, '..', '.dsh-ris-yds'), { recursive: true, force: true })
+  rmSync(WS, { recursive: true, force: true })
+})
+
+function cfg() {
+  return { workspace: WS, socks: { host: '1.2.3.4', port: 1080 }, git: null, proxyJavaRules: true }
+}
+
+test('a failed release keeps the lease record so a retry can finish the job', async () => {
+  const { holdBorrowedLease, releaseBorrowedLease } = await import('../lib/ide-proxy.js')
+  const { readLease } = await import('../lib/risd-peer.js')
+  const held = await holdBorrowedLease(cfg(), { ownerPid: process.pid })
+  assert.equal(held.ok, true)
+  assert.equal(readLease(WS)?.id, 'lease-1')
+
+  mode = 'fail'
+  const failed = await releaseBorrowedLease(cfg())
+  assert.equal(failed.ok, false)
+  assert.match(failed.reason, /daemon broke|释放租约失败/)
+  assert.equal(readLease(WS)?.id, 'lease-1', 'the record survives a failed release')
+
+  mode = 'ok'
+  const retried = await releaseBorrowedLease(cfg())
+  assert.equal(retried.ok, true)
+  assert.equal(retried.released, true)
+  assert.equal(readLease(WS), null, 'a successful release forgets the record')
+
+  const leases = JSON.parse(readFileSync(join(home, '..', '.dsh-ris-yds', 'risd-leases.json'), 'utf8'))
+  assert.equal(leases[WS], undefined)
+})

package/test/mode-separation.test.mjs

@@ -0,0 +1,147 @@
+/**
+ * The two launch modes must never be mixed:
+ *   - proxy  : YonCode's JVM carries -DsocksProxyHost/Port and reads
+ *              yms-home/config (rewritten to 127.0.0.1).
+ *   - direct : no proxy flag at all; when dsh still tunnels, YonCode reads the
+ *              untouched copy in yms-home/config-direct.
+ * These tests pin the boundaries: flags, config dirs, mode switching, and the
+ * default derived from .env `ide.launch`.
+ */
+import assert from 'node:assert/strict'
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+
+import { adaptAndWriteConfig } from '../lib/confcenter.js'
+import { resolveConfig } from '../lib/config.js'
+import { LAUNCH_ENTRY_NAME, applyLaunchConfig, launchModeVmArgs, ourLaunchEntry, readLaunchConfig } from '../lib/ide.js'
+
+const SOCKS = { host: '10.3.91.121', port: 1080 }
+
+function workspace(env = '') {
+  const dir = mkdtempSync(join(tmpdir(), 'yds-modes-'))
+  if (env !== '') writeFileSync(join(dir, '.env'), env, 'utf8')
+  return dir
+}
+
+function launchProject() {
+  const dir = mkdtempSync(join(tmpdir(), 'yds-launch-mode-'))
+  mkdirSync(join(dir, '.vscode'), { recursive: true })
+  writeFileSync(join(dir, '.vscode', 'launch.json'), `${JSON.stringify({ version: '0.2.0', configurations: [] }, null, 2)}\n`)
+  return dir
+}
+
+const entryVmArgs = (dir) => readLaunchConfig(dir).parsed.configurations.find((c) => c.name === LAUNCH_ENTRY_NAME).vmArgs
+
+test('proxy mode: socks flags, no local_conf_path', () => {
+  const flags = launchModeVmArgs({ launchMode: 'proxy', socks: SOCKS })
+  assert.deepEqual(flags, [
+    '-DsocksProxyHost=10.3.91.121',
+    '-DsocksProxyPort=1080',
+    '-Djava.net.useSystemProxies=false',
+  ])
+  const entry = ourLaunchEntry({ launchMode: 'proxy', socks: SOCKS })
+  assert.ok(entry.vmArgs.includes('-DsocksProxyHost=10.3.91.121'))
+  assert.ok(!entry.vmArgs.some((v) => String(v).startsWith('-Dlocal_conf_path=')), 'proxy mode must not read config-direct')
+})
+
+test('direct mode on a tunneled machine: local_conf_path only, never socks flags', () => {
+  const flags = launchModeVmArgs({ launchMode: 'direct', socks: SOCKS })
+  assert.equal(flags.length, 2)
+  assert.ok(flags[0].startsWith('-Dlocal_conf_path=') && flags[0].endsWith('/config-direct/'), `unexpected: ${flags[0]}`)
+  assert.equal(flags[1], '-Dyms_use_local_conf=true')
+  const entry = ourLaunchEntry({ launchMode: 'direct', socks: SOCKS })
+  assert.ok(!entry.vmArgs.some((v) => /^-DsocksProxy/.test(String(v))), 'direct mode must never carry proxy flags')
+  assert.ok(!entry.vmArgs.includes('-Djava.net.useSystemProxies=false'))
+})
+
+test('direct mode without SOCKS needs no override at all', () => {
+  assert.deepEqual(launchModeVmArgs({ launchMode: 'direct', socks: null }), [])
+  assert.deepEqual(launchModeVmArgs({ launchMode: 'proxy', socks: null }), [])
+})
+
+test('switching modes rewrites the entry with no residue from the other mode', () => {
+  const dir = launchProject()
+  try {
+    const proxyCfg = { projectDir: dir, workspace: dir, launchMode: 'proxy', socks: SOCKS }
+    applyLaunchConfig(proxyCfg)
+    assert.ok(entryVmArgs(dir).includes('-DsocksProxyHost=10.3.91.121'))
+
+    const directCfg = { ...proxyCfg, launchMode: 'direct' }
+    applyLaunchConfig(directCfg)
+    const direct = entryVmArgs(dir)
+    assert.ok(!direct.some((v) => /^-DsocksProxy/.test(String(v))))
+    assert.ok(direct.some((v) => String(v).startsWith('-Dlocal_conf_path=')))
+
+    applyLaunchConfig(proxyCfg)
+    const back = entryVmArgs(dir)
+    assert.ok(back.includes('-DsocksProxyHost=10.3.91.121'))
+    assert.ok(!back.some((v) => String(v).startsWith('-Dlocal_conf_path=')), 'stale direct override after switching back')
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+test('config-direct keeps the real endpoints while config/ stays adapted', () => {
+  const dir = workspace()
+  try {
+    const cfg = {
+      workspace: dir,
+      stateDir: join(dir, '.dsh-ris-yds'),
+      ymsHome: join(dir, 'yms-home'),
+      configDir: join(dir, 'yms-home', 'config'),
+      configDirectDir: join(dir, 'yms-home', 'config-direct'),
+      ymsPort: 8080,
+      socks: SOCKS,
+      dbForwardPort: 1521,
+      redisForwardPort: 6890,
+      module: 'c-ass-kk-hans',
+      context: '/',
+      serverBindAddress: '172.20.63.131',
+      serverPort: 31010,
+    }
+    mkdirSync(cfg.stateDir, { recursive: true })
+    const files = {
+      'yms_middleware.json': JSON.stringify({
+        connectionPools: { pool1: { url: 'jdbc:oracle:thin:@//10.3.91.100:31000/ris' } },
+        'redis.pools': { redis1: { host: '172.20.235.81', port: 6890 } },
+      }),
+      'module_config.json': '{"module":true}',
+      'yonbip_config.json': '{"platform":true}',
+    }
+
+    adaptAndWriteConfig(cfg, files)
+    adaptAndWriteConfig(cfg, files, { rewrite: false, dir: cfg.configDirectDir })
+
+    const adapted = readFileSync(join(cfg.configDir, 'yms_middleware.json'), 'utf8')
+    const untouched = readFileSync(join(cfg.configDirectDir, 'yms_middleware.json'), 'utf8')
+    assert.ok(adapted.includes('127.0.0.1:1521'), 'proxy config must point at the local forwarder')
+    assert.ok(adapted.includes('127.0.0.1'), 'proxy config must not keep the real DB host')
+    assert.ok(!adapted.includes('10.3.91.100:31000'))
+    assert.ok(untouched.includes('10.3.91.100:31000'), 'direct config must keep the real DB host')
+    assert.ok(!untouched.includes('127.0.0.1:1521'))
+    // the two writes did not leak into each other's directory
+    assert.ok(readFileSync(join(cfg.configDir, 'yms_middleware.json'), 'utf8').includes('127.0.0.1:1521'))
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+test('ide.launch selects the mode; an invalid value is reported and falls back to proxy', () => {
+  const direct = workspace('ide.launch=direct\n')
+  const bogus = workspace('ide.launch=both\n')
+  try {
+    const d = resolveConfig(direct)
+    assert.equal(d.config.launchMode, 'direct')
+    assert.ok(d.config.configDirectDir.endsWith('config-direct'))
+    assert.notEqual(d.config.configDir, d.config.configDirectDir)
+
+    const b = resolveConfig(bogus)
+    assert.equal(b.config.launchMode, 'proxy', 'unknown values must not become direct silently')
+    assert.ok(b.problems.some((p) => p.includes('ide.launch')), `missing problem: ${b.problems.join(' | ')}`)
+  } finally {
+    rmSync(direct, { recursive: true, force: true })
+    rmSync(bogus, { recursive: true, force: true })
+  }
+})