Skip to content

test: connections — dbt-profiles, Docker, MongoDB auth #511

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
anandgupta42 wants to merge 1 commit into from
+279 −2
Closed

test: connections — dbt-profiles, Docker, MongoDB auth #511

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
281 changes: 279 additions & 2 deletions packages/opencode/test/altimate/connections.test.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,8 +11,10 @@ afterAll(() => { delete process.env.ALTIMATE_TELEMETRY_DISABLED })

import * as Registry from "../../src/altimate/native/connections/registry"
import * as CredentialStore from "../../src/altimate/native/connections/credential-store"
import { parseDbtProfiles } from "../../src/altimate/native/connections/dbt-profiles"
import { discoverContainers } from "../../src/altimate/native/connections/docker-discovery"
import { parseDbtProfiles, dbtConnectionsToConfigs } from "../../src/altimate/native/connections/dbt-profiles"
import { discoverContainers, containerToConfig } from "../../src/altimate/native/connections/docker-discovery"
import { detectAuthMethod, categorizeConnectionError } from "../../src/altimate/native/connections/registry"
Copy link
Copy Markdown

@coderabbitai coderabbitai bot Mar 27, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Potential issue | 🟡 Minor

Unused import: categorizeConnectionError

This function is imported but never used in any test. Either add tests for it or remove the import.

-import { detectAuthMethod, categorizeConnectionError } from "../../src/altimate/native/connections/registry"
+import { detectAuthMethod } from "../../src/altimate/native/connections/registry"
📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change
import { detectAuthMethod, categorizeConnectionError } from "../../src/altimate/native/connections/registry"
import { detectAuthMethod } from "../../src/altimate/native/connections/registry"
🤖 Prompt for AI Agents 
Verify each finding against the current code and only fix it if needed.

In `@packages/opencode/test/altimate/connections.test.ts` at line 16, The import
list in the test currently includes categorizeConnectionError which is unused;
either remove categorizeConnectionError from the import statement (leaving
detectAuthMethod) or add tests that exercise the categorizeConnectionError
function (call categorizeConnectionError with representative error inputs and
assert expected categories), ensuring the test actually references the function
so the import is used.

import type { DockerContainer } from "../../src/altimate/native/types"
import { registerAll } from "../../src/altimate/native/connections/register"

// ---------------------------------------------------------------------------
Expand Down Expand Up @@ -263,6 +265,212 @@ snow:
})
})

// ---------------------------------------------------------------------------
// dbt profiles parser — advanced parsing
// ---------------------------------------------------------------------------

describe("dbt profiles parser: edge cases", () => {
test("env_var with default value resolves to default when env var is missing", async () => {
const fs = await import("fs")
const os = await import("os")
const path = await import("path")

delete process.env.DBT_TEST_NONEXISTENT_VAR

const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "dbt-test-"))
const profilesPath = path.join(tmpDir, "profiles.yml")

fs.writeFileSync(
profilesPath,
`
myproject:
outputs:
dev:
type: postgres
host: localhost
password: "{{ env_var('DBT_TEST_NONEXISTENT_VAR', 'fallback_pw') }}"
dbname: testdb
`,
)

try {
const connections = await parseDbtProfiles(profilesPath)
expect(connections).toHaveLength(1)
expect(connections[0].config.password).toBe("fallback_pw")
} finally {
fs.rmSync(tmpDir, { recursive: true })
}
})

test("spark adapter maps to databricks", async () => {
const fs = await import("fs")
const os = await import("os")
const path = await import("path")

const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "dbt-test-"))
const profilesPath = path.join(tmpDir, "profiles.yml")

fs.writeFileSync(
profilesPath,
`
spark_project:
outputs:
prod:
type: spark
server_hostname: my-spark-cluster.databricks.com
http_path: /sql/1.0/warehouses/abc123
token: dapi_secret
`,
)

try {
const connections = await parseDbtProfiles(profilesPath)
expect(connections).toHaveLength(1)
expect(connections[0].type).toBe("databricks")
expect(connections[0].config.type).toBe("databricks")
} finally {
fs.rmSync(tmpDir, { recursive: true })
}
})

test("trino adapter maps to postgres (wire-compatible)", async () => {
const fs = await import("fs")
const os = await import("os")
const path = await import("path")

const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "dbt-test-"))
const profilesPath = path.join(tmpDir, "profiles.yml")

fs.writeFileSync(
profilesPath,
`
trino_project:
outputs:
prod:
type: trino
host: trino.example.com
port: 8080
user: analyst
dbname: hive
`,
)

try {
const connections = await parseDbtProfiles(profilesPath)
expect(connections).toHaveLength(1)
expect(connections[0].type).toBe("postgres")
expect(connections[0].config.type).toBe("postgres")
} finally {
fs.rmSync(tmpDir, { recursive: true })
}
})

test("top-level config key is skipped (not treated as a profile)", async () => {
const fs = await import("fs")
const os = await import("os")
const path = await import("path")

const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "dbt-test-"))
const profilesPath = path.join(tmpDir, "profiles.yml")

fs.writeFileSync(
profilesPath,
`
config:
send_anonymous_usage_stats: false
use_colors: true

real_project:
outputs:
dev:
type: postgres
host: localhost
dbname: mydb
`,
)

try {
const connections = await parseDbtProfiles(profilesPath)
expect(connections).toHaveLength(1)
expect(connections[0].name).toBe("real_project_dev")
// Ensure no connection was created for the config key
expect(connections.find((c) => c.name.startsWith("config"))).toBeUndefined()
} finally {
fs.rmSync(tmpDir, { recursive: true })
}
})

test("multiple profiles with multiple outputs parsed correctly", async () => {
const fs = await import("fs")
const os = await import("os")
const path = await import("path")

const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "dbt-test-"))
const profilesPath = path.join(tmpDir, "profiles.yml")

fs.writeFileSync(
profilesPath,
`
analytics:
outputs:
dev:
type: postgres
host: localhost
dbname: analytics_dev
prod:
type: postgres
host: prod.example.com
dbname: analytics_prod

warehouse:
outputs:
staging:
type: snowflake
account: abc123
production:
type: snowflake
account: xyz789
`,
)

try {
const connections = await parseDbtProfiles(profilesPath)
expect(connections).toHaveLength(4)
const names = connections.map((c) => c.name).sort()
expect(names).toEqual([
"analytics_dev",
"analytics_prod",
"warehouse_production",
"warehouse_staging",
])
} finally {
fs.rmSync(tmpDir, { recursive: true })
}
})
})

// ---------------------------------------------------------------------------
// dbtConnectionsToConfigs
// ---------------------------------------------------------------------------

describe("dbtConnectionsToConfigs", () => {
test("converts connection array to keyed record", () => {
const connections = [
{ name: "pg_dev", type: "postgres", config: { type: "postgres", host: "localhost" } },
{ name: "sf_prod", type: "snowflake", config: { type: "snowflake", account: "abc" } },
]
const result = dbtConnectionsToConfigs(connections)
expect(Object.keys(result)).toHaveLength(2)
expect(result["pg_dev"].type).toBe("postgres")
expect(result["sf_prod"].type).toBe("snowflake")
})

test("returns empty object for empty array", () => {
const result = dbtConnectionsToConfigs([])
expect(result).toEqual({})
})
})

// ---------------------------------------------------------------------------
// Docker discovery (dockerode not available)
// ---------------------------------------------------------------------------
Expand All @@ -274,6 +482,75 @@ describe("Docker discovery", () => {
})
})

// ---------------------------------------------------------------------------
// containerToConfig — Docker container to ConnectionConfig conversion
// ---------------------------------------------------------------------------

describe("containerToConfig", () => {
test("creates ConnectionConfig with all fields from a fully-populated container", () => {
const container: DockerContainer = {
container_id: "abc123def456",
name: "my-postgres",
image: "postgres:16",
db_type: "postgres",
host: "127.0.0.1",
port: 5432,
user: "admin",
password: "secret",
database: "mydb",
status: "running",
}
const config = containerToConfig(container)
expect(config.type).toBe("postgres")
expect(config.host).toBe("127.0.0.1")
expect(config.port).toBe(5432)
expect(config.user).toBe("admin")
expect(config.password).toBe("secret")
expect(config.database).toBe("mydb")
})

test("omits user, password, database when undefined on container", () => {
const container: DockerContainer = {
container_id: "abc123def456",
name: "bare-mysql",
image: "mysql:8",
db_type: "mysql",
host: "127.0.0.1",
port: 3306,
user: undefined,
password: undefined,
database: undefined,
status: "running",
}
const config = containerToConfig(container)
expect(config.type).toBe("mysql")
expect(config.host).toBe("127.0.0.1")
expect(config.port).toBe(3306)
// These keys should not exist at all — not just be undefined
expect("user" in config).toBe(false)
expect("password" in config).toBe(false)
expect("database" in config).toBe(false)
})
})

// ---------------------------------------------------------------------------
// detectAuthMethod — MongoDB support (#482)
// ---------------------------------------------------------------------------

describe("detectAuthMethod: MongoDB", () => {
test("returns connection_string for mongodb with no password", () => {
// This is the only reachable MongoDB-specific branch — the generic
// password check fires first if password is set.
const result = detectAuthMethod({ type: "mongodb" })
expect(result).toBe("connection_string")
})

test("returns connection_string for mongo alias with no password", () => {
const result = detectAuthMethod({ type: "mongo" })
expect(result).toBe("connection_string")
})
})

// ---------------------------------------------------------------------------
// Dispatcher registration
// ---------------------------------------------------------------------------
Expand Down
Loading