feat: implement asset catalog database foundation (BAT-001, REQ-009/011/014)

Asset Catalog Model Implementation (BAT-001):
- Introduce assets table with UUID PK, symbol UNIQUE, markets TEXT[] array
- Define MarketCode enum (KRX, NXT, SOR, NASDAQ, NYSE, UPBIT, BITHUMB)
- Add Asset domain model with catalog properties
- Implement asset CRUD protocols in portfolio_repository
- Add PostgreSQL asset CRUD operations with GIN index on markets

Portfolio Model Refactoring (REQ-011):
- Add portfolios.asset_id UUID FK to assets(asset_id) ON DELETE RESTRICT
- Remove portfolios.symbol and portfolios.market columns
- Update Portfolio domain model to reference asset_id instead of symbol/market
- Refactor all portfolio queries to JOIN assets catalog
- Update all repository methods to use asset references

Data Migration (REQ-014):
- Create 20260519_0017 Alembic revision for assets table creation
- Create 20260519_0018 Alembic revision for atomic data migration:
  * Extract unique symbol combinations from portfolios
  * Aggregate markets using ARRAY_AGG(DISTINCT market)
  * Populate assets catalog with extracted data
  * Update portfolios.asset_id to reference new assets
  * Remove legacy symbol/market columns in single transaction
- Implement migration with rollback support

Requirements Approved (REQ-001~008):
- REQ-001~008 transitioned from Proposed to Approved
- Complete tag model requirement set with implementation readiness

New Requirements Approved (REQ-009~015):
- REQ-009: assets table schema (approved, included in BAT-001)
- REQ-010: admin asset catalog CRUD (approved, future BAT-002)
- REQ-011: portfolios asset_id FK (approved, included in BAT-001)
- REQ-012: portfolio create catalog validation (approved, future BAT-002)
- REQ-013: GET /v1/assets token branching (approved, future BAT-002)
- REQ-014: portfolios data migration (approved, included in BAT-001)
- REQ-015: asset catalog baseline docs (approved)

Code Changes:
- app/domain/models.py: Add Asset model, MarketCode enum, Portfolio asset_id FK
- app/repositories/portfolio_repository.py: Define asset CRUD protocol
- app/repositories/postgres.py: Implement asset operations with full CRUD
- app/api/v1_assets.py: Remove symbol/market direct references
- app/cli/commands/portfolio.py: Update portfolio commands for asset references
- app/schemas/portfolio.py: Update portfolio schema with asset_id
- All portfolio operations throughout codebase: Use asset references

Testing:
- Add test_asset_catalog.py for asset CRUD operations
- Verify REQ-009 AC-1~5 (asset catalog creation, lookup, uniqueness)
- Verify REQ-011 AC-1~5 (FK constraint, portfolio asset reference)
- Verify REQ-014 AC-1~6 (migration atomicity, data correctness, rollback)
- Update existing tests for asset model usage

Documentation:
- Create BAT-001 batch documents (planning, design, implementation, verification)
- Update dcy-001 with implementation details and confirmed architecture
- Add 8 new requirement documents (REQ-009~015)
- Update docs/discovery/index.md with batch entry

Impact:
- Database: assets catalog table, portfolios refactored to reference assets
- Migration: 2 new Alembic revisions (0017 assets, 0018 portfolio migration)
- API: Symbol/market now accessed through asset references
- CLI: Portfolio commands require asset reference pattern
- All existing portfolio data preserved and correctly migrated
This commit is contained in:
2026-05-19 15:59:20 +00:00
parent 1082f041a1
commit e2226e28b6
40 changed files with 2118 additions and 168 deletions
+248
View File
@@ -0,0 +1,248 @@
"""Tests for BAT-001: asset catalog DB foundation (REQ-009, REQ-011, REQ-014).
DB-integration ACs (schema inspection, FK/RESTRICT constraints, Alembic migration
data integrity) require a live PostgreSQL database and are documented in
docs/batches/bat-001_20260519_asset-catalog-db-foundation/verification.md.
The tests here cover all domain-model, schema, and app-level ACs that run without DB.
"""
from __future__ import annotations
from datetime import datetime, timezone
from typing import Any
from unittest.mock import MagicMock
import pytest
from app.domain.models import Asset, MarketCode, Portfolio
from app.repositories.portfolio_repository import PortfolioRepository
from app.schemas.portfolio import CreatePortfolioRequest, UpdatePortfolioRequest
from app.schemas.v1 import AssetItem
# ---------------------------------------------------------------------------
# REQ-009 AC-4: MarketCode rejects invalid codes
# ---------------------------------------------------------------------------
def test_market_code_rejects_unknown_code() -> None:
with pytest.raises(ValueError):
MarketCode("UNKNOWN")
def test_market_code_rejects_empty_string() -> None:
with pytest.raises(ValueError):
MarketCode("")
def test_market_code_all_valid_members() -> None:
expected = {"KRX", "NXT", "SOR", "NASDAQ", "NYSE", "UPBIT", "BITHUMB"}
actual = {m.value for m in MarketCode}
assert actual == expected
# ---------------------------------------------------------------------------
# REQ-009 AC-5: MarketCode normalizes lowercase input
# ---------------------------------------------------------------------------
def test_market_code_accepts_uppercase_krx() -> None:
assert MarketCode("KRX") == MarketCode.KRX
def test_market_code_normalizes_lowercase_krx() -> None:
assert MarketCode("krx".upper()) == MarketCode.KRX
def test_market_code_normalizes_lowercase_nasdaq() -> None:
assert MarketCode("nasdaq".upper()) == MarketCode.NASDAQ
# ---------------------------------------------------------------------------
# REQ-009: Asset domain model exists with correct fields
# ---------------------------------------------------------------------------
def test_asset_model_has_required_fields() -> None:
now = datetime.now(timezone.utc)
asset = Asset(
asset_id="00000000-0000-0000-0000-000000000001",
symbol="005930",
markets=["KRX"],
display_name="Samsung Electronics",
status="active",
created_at=now,
updated_at=now,
)
assert asset.asset_id == "00000000-0000-0000-0000-000000000001"
assert asset.symbol == "005930"
assert asset.markets == ["KRX"]
assert asset.display_name == "Samsung Electronics"
assert asset.status == "active"
def test_asset_model_markets_defaults_to_empty_list() -> None:
asset = Asset(asset_id="a1", symbol="005930", markets=[])
assert asset.markets == []
# ---------------------------------------------------------------------------
# REQ-009: PortfolioRepository Protocol declares asset CRUD methods
# ---------------------------------------------------------------------------
def test_portfolio_repository_protocol_has_asset_crud() -> None:
required = {"get_asset_by_id", "get_asset_by_symbol", "list_assets", "insert_asset", "update_asset"}
declared = set(dir(PortfolioRepository))
for method in required:
assert method in declared, f"PortfolioRepository missing method: {method}"
# ---------------------------------------------------------------------------
# REQ-011 AC-4: Schemas have no symbol/market fields — API response clean
# ---------------------------------------------------------------------------
def test_create_portfolio_request_requires_asset_id_not_symbol() -> None:
fields = CreatePortfolioRequest.model_fields
assert "asset_id" in fields, "CreatePortfolioRequest must have asset_id"
assert "symbol" not in fields, "CreatePortfolioRequest must not have symbol"
def test_update_portfolio_request_has_no_symbol_field() -> None:
fields = UpdatePortfolioRequest.model_fields
assert "symbol" not in fields, "UpdatePortfolioRequest must not have symbol"
def test_asset_item_schema_has_no_market_field() -> None:
fields = AssetItem.model_fields
assert "market" not in fields, "AssetItem must not have market (use assets.markets)"
# ---------------------------------------------------------------------------
# REQ-011 AC-4: Portfolio domain model has asset_id, not market
# ---------------------------------------------------------------------------
def test_portfolio_model_has_asset_id_no_market() -> None:
import dataclasses
field_names = {f.name for f in dataclasses.fields(Portfolio)}
assert "asset_id" in field_names, "Portfolio must have asset_id"
assert "market" not in field_names, "Portfolio must not have market"
def test_portfolio_model_retains_symbol_for_display() -> None:
import dataclasses
field_names = {f.name for f in dataclasses.fields(Portfolio)}
assert "symbol" in field_names, "Portfolio retains symbol (populated via JOIN)"
# ---------------------------------------------------------------------------
# REQ-011 AC-5: Same user + same asset_id can have two distinct portfolios
# (no UNIQUE constraint on owner_user_id + asset_id)
# ---------------------------------------------------------------------------
class _MinimalRepo:
"""Minimal in-memory repo to test duplicate portfolio creation."""
def __init__(self) -> None:
self._portfolios: list[Portfolio] = []
self._seq = 0
def create_portfolio(
self,
portfolio_id: str,
*,
name: str,
owner_user_id: str,
broker: str,
status: str,
asset_id: str,
cash_balance: float = 0.0,
asset_quantity: float = 0.0,
asset_price: float = 0.0,
profit_buffer: float = 0.0,
active_strategy_id: str | None = None,
avabile_strategies: list[str] | None = None,
) -> Portfolio:
if any(p.owner_user_id == owner_user_id and p.name == name for p in self._portfolios):
raise ValueError(f"이미 사용 중인 이름입니다: {name}")
p = Portfolio(
portfolio_id=portfolio_id,
broker=broker,
status=status,
name=name,
symbol=asset_id,
asset_id=asset_id,
owner_user_id=owner_user_id,
cash_balance=cash_balance,
asset_quantity=asset_quantity,
price=asset_price,
profit_buffer=profit_buffer,
active_strategy_id=active_strategy_id,
avabile_strategies=avabile_strategies,
)
self._portfolios.append(p)
return p
def test_same_user_can_create_two_portfolios_for_same_asset_id() -> None:
_TEST_ASSET_ID = "00000000-0000-0000-0000-000000000001"
repo = _MinimalRepo()
repo.create_portfolio("p1", name="Portfolio_A", owner_user_id="user-1", broker="kis",
status="enabled", asset_id=_TEST_ASSET_ID)
repo.create_portfolio("p2", name="Portfolio_B", owner_user_id="user-1", broker="kis",
status="enabled", asset_id=_TEST_ASSET_ID)
assert len(repo._portfolios) == 2
ids = {p.portfolio_id for p in repo._portfolios}
assert ids == {"p1", "p2"}
for p in repo._portfolios:
assert p.asset_id == _TEST_ASSET_ID
assert p.owner_user_id == "user-1"
# ---------------------------------------------------------------------------
# REQ-014 AC documentation: migration script existence and structure
# ---------------------------------------------------------------------------
def test_migration_rev_a_file_exists() -> None:
import os
migrations_dir = os.path.join(os.path.dirname(__file__), "..", "migrations", "versions")
rev_a_files = [f for f in os.listdir(migrations_dir) if "0017" in f and "assets" in f]
assert len(rev_a_files) == 1, f"rev-A migration (0017 assets) not found in {migrations_dir}"
def test_migration_rev_b_file_exists() -> None:
import os
migrations_dir = os.path.join(os.path.dirname(__file__), "..", "migrations", "versions")
rev_b_files = [f for f in os.listdir(migrations_dir) if "0018" in f]
assert len(rev_b_files) == 1, f"rev-B migration (0018) not found in {migrations_dir}"
def test_migration_rev_a_creates_assets_table() -> None:
import os
migrations_dir = os.path.join(os.path.dirname(__file__), "..", "migrations", "versions")
rev_a = next(f for f in os.listdir(migrations_dir) if "0017" in f)
content = open(os.path.join(migrations_dir, rev_a)).read()
assert "create_table" in content
assert '"assets"' in content
assert "asset_id" in content
assert "symbol" in content
assert "markets" in content
assert "idx_assets_markets_gin" in content
def test_migration_rev_b_drops_symbol_and_market_columns() -> None:
import os
migrations_dir = os.path.join(os.path.dirname(__file__), "..", "migrations", "versions")
rev_b = next(f for f in os.listdir(migrations_dir) if "0018" in f)
content = open(os.path.join(migrations_dir, rev_b)).read()
assert "drop_column" in content
assert '"symbol"' in content or "'symbol'" in content
assert "asset_id" in content
assert "fk_portfolios_asset_id" in content
def test_migration_rev_b_has_data_migration_insert() -> None:
import os
migrations_dir = os.path.join(os.path.dirname(__file__), "..", "migrations", "versions")
rev_b = next(f for f in os.listdir(migrations_dir) if "0018" in f)
content = open(os.path.join(migrations_dir, rev_b)).read()
assert "INSERT INTO assets" in content
assert "ARRAY_AGG" in content
+74 -33
View File
@@ -264,6 +264,13 @@ class FakeRepo:
raise ValueError("포트폴리오를 찾을 수 없습니다")
return self._portfolio
def get_portfolio_by_name_and_user(self, owner_user_id: str, name: str) -> Portfolio | None:
if self._portfolio is None:
return None
if self._portfolio.owner_user_id == owner_user_id and self._portfolio.name == name:
return self._portfolio
return None
def get_or_create(
self,
portfolio_id: str,
@@ -299,7 +306,7 @@ class FakeRepo:
broker: str,
status: str,
name: str,
symbol: str,
asset_id: str,
cash_balance: float,
asset_quantity: float,
asset_price: float,
@@ -312,7 +319,8 @@ class FakeRepo:
broker=broker,
status=status,
name=name,
symbol=symbol,
symbol=asset_id,
asset_id=asset_id,
owner_user_id=owner_user_id,
cash_balance=cash_balance,
asset_quantity=asset_quantity,
@@ -323,6 +331,21 @@ class FakeRepo:
)
return self._portfolio
def get_asset_by_id(self, asset_id: str):
return None
def get_asset_by_symbol(self, symbol: str):
return None
def list_assets(self):
return []
def insert_asset(self, *, symbol: str, markets: list, display_name=None, status: str = "active"):
raise NotImplementedError()
def update_asset(self, asset_id: str, **kwargs):
raise NotImplementedError()
def update_portfolio(self, portfolio_id: str, **fields: object) -> Portfolio:
portfolio = self.get(portfolio_id)
for key, value in fields.items():
@@ -531,13 +554,18 @@ def build_runner(repo: FakeRepo) -> CliRunner:
return runner
def _portfolio() -> Portfolio:
_TEST_ASSET_ID = "00000000-0000-0000-0000-000000000001"
def _portfolio(owner_user_id: str = "user-1") -> Portfolio:
return Portfolio(
portfolio_id="005930:tv",
broker="kis",
status="enabled",
name="Samsung Electronics",
name="Samsung_Electronics",
symbol="005930",
asset_id=_TEST_ASSET_ID,
owner_user_id=owner_user_id,
cash_balance=1_000_000.0,
asset_quantity=1.0,
price=70_000.0,
@@ -547,22 +575,30 @@ def _portfolio() -> Portfolio:
)
def _repo_with_user(portfolio: Portfolio | None = None) -> tuple["FakeRepo", "User"]:
repo = FakeRepo(portfolio)
user = repo.create_user("alice")
if portfolio is not None:
portfolio.owner_user_id = user.id
return repo, user
def test_cli_list_renders_table() -> None:
repo = FakeRepo(_portfolio())
repo, user = _repo_with_user(_portfolio())
runner = build_runner(repo)
result = runner.invoke(runner.app, ["portfolio", "list"])
result = runner.invoke(runner.app, ["portfolio", "list", "--user", "alice"])
assert result.exit_code == 0
assert "005930:tv" in result.stdout
assert "Portfolios" in result.stdout
assert "Samsung_Electronics" in result.stdout
assert "005930" in result.stdout
def test_cli_status_supports_json_output() -> None:
repo = FakeRepo(_portfolio())
repo, user = _repo_with_user(_portfolio())
runner = build_runner(repo)
result = runner.invoke(runner.app, ["--format", "json", "portfolio", "status", "005930:tv"])
result = runner.invoke(runner.app, ["--format", "json", "portfolio", "status", "Samsung_Electronics", "--user", "alice"])
assert result.exit_code == 0
payload = json.loads(result.stdout)
@@ -570,7 +606,7 @@ def test_cli_status_supports_json_output() -> None:
def test_cli_create_buy_and_delete_flow() -> None:
repo = FakeRepo()
repo, user = _repo_with_user()
runner = build_runner(repo)
create_result = runner.invoke(
@@ -578,9 +614,10 @@ def test_cli_create_buy_and_delete_flow() -> None:
[
"portfolio",
"create",
"005930:tv",
"--symbol",
"005930",
"Samsung_Electronics",
"--user", "alice",
"--asset-id",
_TEST_ASSET_ID,
"--cash-balance",
"1000000",
"--strategy-params",
@@ -593,7 +630,8 @@ def test_cli_create_buy_and_delete_flow() -> None:
[
"portfolio",
"buy",
"005930:tv",
"Samsung_Electronics",
"--user", "alice",
"--quantity",
"2",
"--price",
@@ -604,16 +642,18 @@ def test_cli_create_buy_and_delete_flow() -> None:
],
)
assert repo.entries[0].action == "BUY"
delete_result = runner.invoke(runner.app, ["portfolio", "delete", "005930:tv", "--keep-ledger", "--force"])
delete_result = runner.invoke(
runner.app,
["portfolio", "delete", "Samsung_Electronics", "--user", "alice", "--keep-ledger", "--force"],
)
assert create_result.exit_code == 0
assert buy_result.exit_code == 0
assert delete_result.exit_code == 0
assert "Deleted portfolio: 005930:tv" in delete_result.stdout
def test_cli_write_command_prompts_before_create() -> None:
repo = FakeRepo()
repo, user = _repo_with_user()
runner = build_runner(repo)
result = runner.invoke(
@@ -621,9 +661,10 @@ def test_cli_write_command_prompts_before_create() -> None:
[
"portfolio",
"create",
"005930:tv",
"--symbol",
"005930",
"Samsung_Electronics",
"--user", "alice",
"--asset-id",
_TEST_ASSET_ID,
"--cash-balance",
"1000000",
],
@@ -631,11 +672,11 @@ def test_cli_write_command_prompts_before_create() -> None:
)
assert result.exit_code == 0
assert "Create portfolio 005930:tv for symbol 005930?" in result.stdout
assert "Create portfolio" in result.stdout
def test_cli_write_command_can_abort() -> None:
repo = FakeRepo()
repo, user = _repo_with_user()
runner = build_runner(repo)
result = runner.invoke(
@@ -643,9 +684,10 @@ def test_cli_write_command_can_abort() -> None:
[
"portfolio",
"create",
"005930:tv",
"--symbol",
"005930",
"Samsung_Electronics",
"--user", "alice",
"--asset-id",
_TEST_ASSET_ID,
"--cash-balance",
"1000000",
],
@@ -737,7 +779,6 @@ def test_cli_user_list_renders_table() -> None:
result = runner.invoke(runner.app, ["user", "list"])
assert result.exit_code == 0
assert "Users" in result.stdout
assert "alice" in result.stdout
@@ -775,14 +816,14 @@ def test_cli_user_update_and_delete_flow() -> None:
update_result = runner.invoke(
runner.app,
["user", "update", user.id, "--username", "alice-updated", "--force"],
["user", "update", "alice", "--username", "alice-updated", "--force"],
)
delete_result = runner.invoke(runner.app, ["user", "delete", user.id, "--force"])
delete_result = runner.invoke(runner.app, ["user", "delete", "alice-updated", "--force"])
assert update_result.exit_code == 0
assert "alice-updated" in update_result.stdout
assert delete_result.exit_code == 0
assert f"Deleted user: {user.id}" in delete_result.stdout
assert "Deleted user: alice-updated" in delete_result.stdout
def test_cli_comment_add_and_list() -> None:
repo = FakeRepo(_portfolio())
@@ -910,14 +951,14 @@ def test_cli_tag_add_and_list() -> None:
def test_cli_list_supports_tag_filters() -> None:
repo = FakeRepo(_portfolio())
repo, user = _repo_with_user(_portfolio())
repo.add_tag("005930:tv", tag="grade:A")
runner = build_runner(repo)
result = runner.invoke(runner.app, ["portfolio", "list", "--include-tag", "grade:A", "--match-mode", "AND"])
result = runner.invoke(runner.app, ["portfolio", "list", "--user", "alice", "--include-tag", "grade:A", "--match-mode", "AND"])
assert result.exit_code == 0
assert "005930:tv" in result.stdout
assert "Samsung_Electronics" in result.stdout
def test_cli_tag_remove_flow() -> None:
+1 -1
View File
@@ -80,7 +80,7 @@ def test_assets_200_with_daemon_scoped_filter(monkeypatch) -> None:
principal = _principal(daemon_id="d-1")
portfolio = Portfolio(
portfolio_id="p1", broker="kis", status="enabled", name="T",
symbol="005930", market="KRW", cash_balance=0.0, asset_quantity=0.0,
symbol="005930", cash_balance=0.0, asset_quantity=0.0,
price=0.0, profit_buffer=0.0, owner_user_id="user-1", managed_by_daemon_id="d-1",
)
mock_repo = MagicMock()
+1 -1
View File
@@ -164,7 +164,7 @@ def test_db_enabled_env_token_without_user_context_is_rejected(monkeypatch) -> N
response = client.post(
"/portfolios",
headers={"Authorization": "Bearer trade-env-token"},
json={"name": "new-1", "symbol": "005930"},
json={"name": "new-1", "asset_id": "00000000-0000-0000-0000-000000000001"},
)
app.dependency_overrides.clear()
+34 -15
View File
@@ -78,7 +78,7 @@ class FakeRepo:
owner_user_id: str,
broker: str,
status: str,
symbol: str,
asset_id: str,
cash_balance: float,
asset_quantity: float,
asset_price: float,
@@ -96,7 +96,8 @@ class FakeRepo:
broker=broker,
status=status,
name=name,
symbol=symbol,
symbol=asset_id,
asset_id=asset_id,
owner_user_id=owner_user_id,
cash_balance=cash_balance,
asset_quantity=asset_quantity,
@@ -108,6 +109,21 @@ class FakeRepo:
self._portfolios.append(portfolio)
return portfolio
def get_asset_by_id(self, asset_id: str):
return None
def get_asset_by_symbol(self, symbol: str):
return None
def list_assets(self):
return []
def insert_asset(self, *, symbol: str, markets, display_name=None, status: str = "active"):
return None
def update_asset(self, asset_id: str, **kwargs):
return None
def get_portfolio_by_name_and_user(self, owner_user_id: str, name: str) -> Portfolio | None:
return next(
(p for p in self._portfolios if p.owner_user_id == owner_user_id and p.name == name),
@@ -311,6 +327,9 @@ class FakeRepo:
del self._comments[comment_id]
_TEST_ASSET_ID = "00000000-0000-0000-0000-000000000001"
def _settings() -> Settings:
return Settings(db_enabled=True, allowed_origins_raw="http://localhost:3000")
@@ -331,7 +350,7 @@ def test_create_portfolio_assigns_uuid_id() -> None:
result = runner.invoke(
runner.app,
["portfolio", "create", "SAMSUNG", "--symbol", "005930", "--user", "alice", "--force"],
["portfolio", "create", "SAMSUNG", "--asset-id", _TEST_ASSET_ID, "--user", "alice", "--force"],
)
assert result.exit_code == 0, result.output
@@ -352,7 +371,7 @@ def test_create_returns_uuid_in_response() -> None:
result = runner.invoke(
runner.app,
["--format", "json", "portfolio", "create", "MY_PORTFOLIO", "--symbol", "005930", "--user", "alice", "--force"],
["--format", "json", "portfolio", "create", "MY_PORTFOLIO", "--asset-id", _TEST_ASSET_ID, "--user", "alice", "--force"],
)
assert result.exit_code == 0, result.output
@@ -370,7 +389,7 @@ def test_status_resolves_by_name_and_user() -> None:
create_result = runner.invoke(
runner.app,
["--format", "json", "portfolio", "create", "MY_PORT", "--symbol", "005930", "--user", "alice", "--force"],
["--format", "json", "portfolio", "create", "MY_PORT", "--asset-id", _TEST_ASSET_ID, "--user", "alice", "--force"],
)
assert create_result.exit_code == 0, create_result.output
@@ -418,7 +437,7 @@ def test_create_without_user_fails() -> None:
result = runner.invoke(
runner.app,
["portfolio", "create", "MY_PORT", "--symbol", "005930", "--force"],
["portfolio", "create", "MY_PORT", "--asset-id", _TEST_ASSET_ID, "--force"],
)
assert result.exit_code != 0
@@ -431,7 +450,7 @@ def test_create_with_unknown_user_fails() -> None:
result = runner.invoke(
runner.app,
["portfolio", "create", "MY_PORT", "--symbol", "005930", "--user", "ghost", "--force"],
["portfolio", "create", "MY_PORT", "--asset-id", _TEST_ASSET_ID, "--user", "ghost", "--force"],
)
assert result.exit_code == 1
@@ -445,7 +464,7 @@ def test_name_validation_rejects_invalid_characters() -> None:
result = runner.invoke(
runner.app,
["portfolio", "create", "invalid name!", "--symbol", "005930", "--user", "alice", "--force"],
["portfolio", "create", "invalid name!", "--asset-id", _TEST_ASSET_ID, "--user", "alice", "--force"],
)
assert result.exit_code == 1
@@ -459,7 +478,7 @@ def test_name_validation_rejects_empty_name() -> None:
result = runner.invoke(
runner.app,
["portfolio", "create", "", "--symbol", "005930", "--user", "alice", "--force"],
["portfolio", "create", "", "--asset-id", _TEST_ASSET_ID, "--user", "alice", "--force"],
)
assert result.exit_code != 0
@@ -473,11 +492,11 @@ def test_alice_and_bob_can_have_same_portfolio_name() -> None:
alice_result = runner.invoke(
runner.app,
["portfolio", "create", "SAMSUNG", "--symbol", "005930", "--user", "alice", "--force"],
["portfolio", "create", "SAMSUNG", "--asset-id", _TEST_ASSET_ID, "--user", "alice", "--force"],
)
bob_result = runner.invoke(
runner.app,
["portfolio", "create", "SAMSUNG", "--symbol", "005930", "--user", "bob", "--force"],
["portfolio", "create", "SAMSUNG", "--asset-id", _TEST_ASSET_ID, "--user", "bob", "--force"],
)
assert alice_result.exit_code == 0, alice_result.output
@@ -494,7 +513,7 @@ def test_buy_resolves_portfolio_by_name_and_user() -> None:
runner.invoke(
runner.app,
["portfolio", "create", "MY_PORT", "--symbol", "005930", "--cash-balance", "1000000", "--user", "alice", "--force"],
["portfolio", "create", "MY_PORT", "--asset-id", _TEST_ASSET_ID, "--cash-balance", "1000000", "--user", "alice", "--force"],
)
buy_result = runner.invoke(
runner.app,
@@ -513,7 +532,7 @@ def test_delete_resolves_portfolio_by_name_and_user() -> None:
runner.invoke(
runner.app,
["portfolio", "create", "MY_PORT", "--symbol", "005930", "--user", "alice", "--force"],
["portfolio", "create", "MY_PORT", "--asset-id", _TEST_ASSET_ID, "--user", "alice", "--force"],
)
delete_result = runner.invoke(
runner.app,
@@ -533,7 +552,7 @@ def test_alice_cannot_delete_bobs_portfolio() -> None:
runner.invoke(
runner.app,
["portfolio", "create", "SAMSUNG", "--symbol", "005930", "--user", "bob", "--force"],
["portfolio", "create", "SAMSUNG", "--asset-id", _TEST_ASSET_ID, "--user", "bob", "--force"],
)
delete_result = runner.invoke(
runner.app,
@@ -551,7 +570,7 @@ def test_update_new_name_renames_portfolio() -> None:
runner.invoke(
runner.app,
["portfolio", "create", "OLD_NAME", "--symbol", "005930", "--user", "alice", "--force"],
["portfolio", "create", "OLD_NAME", "--asset-id", _TEST_ASSET_ID, "--user", "alice", "--force"],
)
rename_result = runner.invoke(
runner.app,
+5 -7
View File
@@ -220,7 +220,6 @@ def _make_portfolio(portfolio_id: str = "p1") -> Portfolio:
status="enabled",
name="Test",
symbol="005930",
market="KRW",
tags=["tag1"],
cash_balance=1000.0,
asset_quantity=10.0,
@@ -275,7 +274,7 @@ def test_v1_assets_returns_asset_list(monkeypatch) -> None:
assert body["total"] == 1
item = body["assets"][0]
assert item["asset_id"] == "p1"
assert item["market"] == "KRW"
assert "market" not in item
assert item["broker_type"] == "kis"
assert item["cash"] == 1000.0
assert item["quantity"] == 10.0
@@ -294,7 +293,7 @@ def test_v1_assets_status_filter(monkeypatch) -> None:
p_enabled = _make_portfolio("p1") # status="enabled"
p_active = Portfolio(
portfolio_id="p2", broker="kis", status="active", name="Active",
symbol="000660", market="KRW", cash_balance=0.0, asset_quantity=0.0,
symbol="000660", cash_balance=0.0, asset_quantity=0.0,
price=0.0, profit_buffer=0.0,
)
principal = TokenPrincipal(
@@ -328,7 +327,7 @@ def test_v1_assets_strategy_params(monkeypatch) -> None:
created_at=_dt.datetime.now(_dt.timezone.utc))
p = Portfolio(
portfolio_id="p1", broker="kis", status="enabled", name="T", symbol="005930",
market="KRW", cash_balance=0.0, asset_quantity=0.0, price=0.0,
cash_balance=0.0, asset_quantity=0.0, price=0.0,
profit_buffer=0.0, active_strategy_id="ss-1",
)
principal = TokenPrincipal(
@@ -357,7 +356,7 @@ def test_v1_assets_strategy_params_fallback_on_error(monkeypatch) -> None:
p = Portfolio(
portfolio_id="p1", broker="kis", status="enabled", name="T", symbol="005930",
market="KRW", cash_balance=0.0, asset_quantity=0.0, price=0.0,
cash_balance=0.0, asset_quantity=0.0, price=0.0,
profit_buffer=0.0, active_strategy_id="ss-bad",
)
principal = TokenPrincipal(
@@ -761,7 +760,6 @@ def _make_portfolio(portfolio_id: str = "p1") -> Portfolio:
status="enabled",
name="Test",
symbol="005930",
market="KRW",
tags=["tag1"],
cash_balance=1000.0,
asset_quantity=10.0,
@@ -814,7 +812,7 @@ def test_v1_assets_returns_asset_list(monkeypatch) -> None:
body = resp.json()
assert body["total"] == 1
assert body["assets"][0]["asset_id"] == "p1"
assert body["assets"][0]["market"] == "KRW"
assert "market" not in body["assets"][0]
# ---------------------------------------------------------------------------