docs(milestone): complete OpenYield v0.2 (The Mesh)
---ci--- project: oy phase: 5 milestone: v0.2 status: complete phase_role: final requirements: covered: [REQ-009, REQ-011, REQ-015, REQ-016, REQ-017, REQ-018, REQ-020, REQ-021, REQ-012] partial: [] ---/ci--- Milestone v0.2 (The Mesh) complete. Skeleton+tests layer for 9 new modules + 1 extension: x/window (REQ-015, fullest), x/stand (REQ-016, 9 types), x/guild (REQ-017, HandPass 0%), x/pact (REQ-020, 6 types + Mission Lock), x/partner (REQ-018, 4-tier), x/council (REQ-011, 3 councils + Mission Lock const), x/forex (Forex v1, Bread/Asset pairs), x/bond (REQ-021, 8% cap Clamp), x/satellite (REQ-009, 5-chain L2 + ICS-20 v1), x/bearers EXTENDED (OY-LR/Beacon). 303 tests total (53 v0.1 baseline + 250 new). Coverage >=95.9% on all new/extended packages (8 at 100%). Lexicon firewall (REQ-012) project-wide + per-module. G-003 by-ID-string import invariant. 5 phases: P0 (v0.1.0) + P1-P4 (v0.1.1..v0.1.4) + P5 final (v0.1.5 = this milestone release). Per run.md patch-line model: no separate minor tag. 14 clarification decisions (D-020..D-033), 15 research assumptions (A-201..A-215), 31 tasks across 5 phases, 10 grill binding decisions (G-001..G-010) all applied. Next milestone: v0.3 (The Bearers) per ROADMAP Phase 3.
This commit is contained in:
@@ -0,0 +1,54 @@
|
||||
package types
|
||||
|
||||
import "fmt"
|
||||
|
||||
// genesis.go holds the data-engineer's genesis schema helpers for the bond
|
||||
// module (G-008 split). ValidateGenesis in types.go composes these helpers;
|
||||
// the security-engineer's test assertions live in types_test.go.
|
||||
//
|
||||
// The Bond genesis schema has one top-level set: Bonds (the issued bonds).
|
||||
// The invariants enforced at genesis load are (1) bond-id uniqueness, and
|
||||
// (2) the coupon clamp — each genesis bond's coupon-bps must be within
|
||||
// [CouponFloorBps, CouponCapBps]. The clamp invariant is the highest-severity
|
||||
// bond firewall (D-028): a genesis bond with a coupon above the cap or below
|
||||
// the floor is rejected at genesis load.
|
||||
|
||||
// ValidateBonds asserts bond-ids are present and unique, that each bond's
|
||||
// status is a known BondStatus, and that each bond's coupon-bps is within
|
||||
// the LOCKED bounds [CouponFloorBps, CouponCapBps] (the genesis-side clamp
|
||||
// enforcement — D-028). ValidateBonds is the data-engineer's schema
|
||||
// validator, composed by ValidateGenesis in types.go.
|
||||
func ValidateBonds(bonds []Bond) error {
|
||||
seen := make(map[string]bool, len(bonds))
|
||||
for i, b := range bonds {
|
||||
if b.BondID == "" {
|
||||
return fmt.Errorf("bond [%d]: empty bond-id", i)
|
||||
}
|
||||
if seen[b.BondID] {
|
||||
return fmt.Errorf("bond: duplicate bond-id %q", b.BondID)
|
||||
}
|
||||
seen[b.BondID] = true
|
||||
if !knownBondStatus(b.Status) {
|
||||
return fmt.Errorf("bond %q: unknown bond status %q", b.BondID, b.Status)
|
||||
}
|
||||
// Genesis-side clamp enforcement (D-028): a genesis bond's coupon
|
||||
// must be within the LOCKED [floor, cap] bounds. A bond with an
|
||||
// out-of-bounds coupon is rejected at genesis load rather than
|
||||
// silently clamped — the genesis schema is authoritative.
|
||||
if b.CouponBps < CouponFloorBps || b.CouponBps > CouponCapBps {
|
||||
return fmt.Errorf("bond %q: coupon-bps %d outside [%d, %d] (D-028 clamp at genesis load)",
|
||||
b.BondID, b.CouponBps, CouponFloorBps, CouponCapBps)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// knownBondStatus reports whether s is one of the five BondStatus values.
|
||||
func knownBondStatus(s BondStatus) bool {
|
||||
for _, ss := range AllBondStatuses() {
|
||||
if s == ss {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
package types_test
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
btypes "github.com/oy/openyield/x/bond/types"
|
||||
)
|
||||
|
||||
// genesis_test.go holds the security-engineer's genesis-clamp test assertions
|
||||
// for the bond module (G-008 — security-engineer owns ALL *_test.go files,
|
||||
// including genesis_test.go). These tests focus on the data-engineer's
|
||||
// genesis schema clamp enforcement (P4-01-03): ValidateGenesis rejects any
|
||||
// genesis bond whose coupon-bps is outside the LOCKED [floor, cap] bounds.
|
||||
// The clamp invariant (D-028) is the highest-severity bond firewall; the
|
||||
// genesis load is the first enforcement point.
|
||||
|
||||
// TestGenesisClampRejectsAboveCapForManyBonds asserts that multiple bonds,
|
||||
// each with a coupon above the cap, are all rejected. The genesis clamp
|
||||
// applies per-bond (not just the first).
|
||||
func TestGenesisClampRejectsAboveCapForManyBonds(t *testing.T) {
|
||||
gs := btypes.GenesisState{
|
||||
Bonds: []btypes.Bond{
|
||||
{BondID: "b1", IssuerStandID: "s1", CouponBps: 801, Status: btypes.BondIssued},
|
||||
{BondID: "b2", IssuerStandID: "s1", CouponBps: 900, Status: btypes.BondActive},
|
||||
{BondID: "b3", IssuerStandID: "s1", CouponBps: 5000, Status: btypes.BondMatured},
|
||||
},
|
||||
}
|
||||
bz, _ := json.Marshal(gs)
|
||||
if err := btypes.ValidateGenesis(bz); err == nil {
|
||||
t.Error("ValidateGenesis should reject bonds with coupon-bps above cap")
|
||||
}
|
||||
}
|
||||
|
||||
// TestGenesisClampAcceptsAtBounds asserts bonds at the floor (0) and cap (800)
|
||||
// are accepted at genesis load (boundary inclusive).
|
||||
func TestGenesisClampAcceptsAtBounds(t *testing.T) {
|
||||
gs := btypes.GenesisState{
|
||||
Bonds: []btypes.Bond{
|
||||
{BondID: "b-floor", IssuerStandID: "s1", CouponBps: 0, Status: btypes.BondIssued},
|
||||
{BondID: "b-cap", IssuerStandID: "s1", CouponBps: 800, Status: btypes.BondIssued},
|
||||
},
|
||||
}
|
||||
bz, _ := json.Marshal(gs)
|
||||
if err := btypes.ValidateGenesis(bz); err != nil {
|
||||
t.Errorf("ValidateGenesis should accept bonds at floor (0) and cap (800); got: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestGenesisClampRejectsJustAboveCap asserts a coupon 1 bps above the cap is
|
||||
// rejected (off-by-one regression firewall).
|
||||
func TestGenesisClampRejectsJustAboveCap(t *testing.T) {
|
||||
gs := btypes.GenesisState{
|
||||
Bonds: []btypes.Bond{{BondID: "b1", IssuerStandID: "s1", CouponBps: 801, Status: btypes.BondIssued}},
|
||||
}
|
||||
bz, _ := json.Marshal(gs)
|
||||
if err := btypes.ValidateGenesis(bz); err == nil {
|
||||
t.Error("ValidateGenesis should reject coupon-bps == 801 (just above cap 800)")
|
||||
}
|
||||
}
|
||||
|
||||
// TestGenesisClampAcceptsJustBelowCap asserts a coupon 1 bps below the cap is
|
||||
// accepted.
|
||||
func TestGenesisClampAcceptsJustBelowCap(t *testing.T) {
|
||||
gs := btypes.GenesisState{
|
||||
Bonds: []btypes.Bond{{BondID: "b1", IssuerStandID: "s1", CouponBps: 799, Status: btypes.BondIssued}},
|
||||
}
|
||||
bz, _ := json.Marshal(gs)
|
||||
if err := btypes.ValidateGenesis(bz); err != nil {
|
||||
t.Errorf("ValidateGenesis should accept coupon-bps == 799 (just below cap); got: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestGenesisValidateBondsRejectsDup asserts the data-engineer's ValidateBonds
|
||||
// helper rejects duplicate bond-ids.
|
||||
func TestGenesisValidateBondsRejectsDup(t *testing.T) {
|
||||
bonds := []btypes.Bond{
|
||||
{BondID: "b1", IssuerStandID: "s1", CouponBps: 100, Status: btypes.BondIssued},
|
||||
{BondID: "b1", IssuerStandID: "s2", CouponBps: 200, Status: btypes.BondActive},
|
||||
}
|
||||
if err := btypes.ValidateBonds(bonds); err == nil {
|
||||
t.Error("ValidateBonds should reject duplicate bond-ids")
|
||||
}
|
||||
}
|
||||
|
||||
// TestGenesisValidateBondsAcceptsClean asserts ValidateBonds accepts a clean
|
||||
// set of bonds.
|
||||
func TestGenesisValidateBondsAcceptsClean(t *testing.T) {
|
||||
bonds := []btypes.Bond{
|
||||
{BondID: "b1", IssuerStandID: "s1", CouponBps: 0, Status: btypes.BondIssued},
|
||||
{BondID: "b2", IssuerStandID: "s1", CouponBps: 500, Status: btypes.BondActive},
|
||||
{BondID: "b3", IssuerStandID: "s2", CouponBps: 800, Status: btypes.BondMatured},
|
||||
}
|
||||
if err := btypes.ValidateBonds(bonds); err != nil {
|
||||
t.Errorf("ValidateBonds should accept clean bonds; got: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
package types
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
)
|
||||
|
||||
const (
|
||||
ModuleName = "bond"
|
||||
StoreKey = ModuleName
|
||||
RouterKey = ModuleName
|
||||
QuerierRoute = ModuleName
|
||||
|
||||
// CouponCapBps is the upper bound on a bond coupon in basis points
|
||||
// (vision §17, REQ-021, D-028). Mission-locked at 8pct (800 bps); no
|
||||
// Council vote can change it. The bond module is the highest lexicon-risk
|
||||
// package (A-210): the coupon vocabulary is used EXCLUSIVELY here — the
|
||||
// banned financial terms that are natural coupon-synonyms are NEVER used
|
||||
// in this package. The security-engineer's lexicon assertion in
|
||||
// types_test.go is the firewall gate.
|
||||
CouponCapBps = 800 // 8pct (cap, LOCKED — D-028)
|
||||
|
||||
// CouponFloorBps is the lower bound on a bond coupon in basis points
|
||||
// (vision §17, REQ-021, D-028). Mission-locked at 0pct (0 bps); no
|
||||
// Council vote can change it.
|
||||
CouponFloorBps = 0 // 0pct (floor, LOCKED — D-028)
|
||||
|
||||
// BondStatusCount is the locked count of BondStatus enum values (vision
|
||||
// §17, REQ-021). A regression firewall: adding/removing/renaming a bond
|
||||
// status breaks this const's test.
|
||||
BondStatusCount = 5
|
||||
)
|
||||
|
||||
// BondStatus enumerates the bond lifecycle states (vision §17, REQ-021).
|
||||
// The five statuses mirror a fixed-coupon commitment lifecycle: Issued
|
||||
// (created), Active (in good standing), Matured (term reached), Defaulted
|
||||
// (covenant breach), Repaid (principal returned).
|
||||
type BondStatus string
|
||||
|
||||
const (
|
||||
BondIssued BondStatus = "Issued" // created, not yet active
|
||||
BondActive BondStatus = "Active" // in good standing
|
||||
BondMatured BondStatus = "Matured" // term reached
|
||||
BondDefaulted BondStatus = "Defaulted" // covenant breach
|
||||
BondRepaid BondStatus = "Repaid" // principal returned
|
||||
)
|
||||
|
||||
// AllBondStatuses returns all five BondStatus values in REQ-021 lifecycle
|
||||
// order. Locked-const test asserts exactly 5 entries with these names.
|
||||
func AllBondStatuses() []BondStatus {
|
||||
return []BondStatus{
|
||||
BondIssued,
|
||||
BondActive,
|
||||
BondMatured,
|
||||
BondDefaulted,
|
||||
BondRepaid,
|
||||
}
|
||||
}
|
||||
|
||||
// Bond is a fixed-coupon commitment issued by a Stand (vision §17, REQ-021).
|
||||
// issuer-stand-id references x/stand by ID string (G-003 by-ID-string ref —
|
||||
// P1-02-01 stand-id-ref; no struct import of x/stand). principal-grain is the
|
||||
// principal in Grain (the OY internal unit, cross-ref x/bread). coupon-bps is
|
||||
// the coupon rate in basis points, clamped to [CouponFloorBps, CouponCapBps]
|
||||
// by Clamp at issuance and at genesis load. term-days is the term length.
|
||||
// issued-at and maturity are unix timestamps. status is the lifecycle state.
|
||||
type Bond struct {
|
||||
BondID string `json:"bond_id" yaml:"bond_id"`
|
||||
IssuerStandID string `json:"issuer_stand_id" yaml:"issuer_stand_id"`
|
||||
PrincipalGrain int64 `json:"principal_grain" yaml:"principal_grain"`
|
||||
CouponBps uint32 `json:"coupon_bps" yaml:"coupon_bps"`
|
||||
TermDays uint32 `json:"term_days" yaml:"term_days"`
|
||||
IssuedAt int64 `json:"issued_at" yaml:"issued_at"`
|
||||
Maturity int64 `json:"maturity" yaml:"maturity"`
|
||||
Status BondStatus `json:"status" yaml:"status"`
|
||||
}
|
||||
|
||||
// Issue is the bond issuance stub (REQ-021, D-028). It constructs a Bond with
|
||||
// the coupon clamped to [CouponFloorBps, CouponCapBps]. The stub does not
|
||||
// persist or enforce referential integrity of issuer-stand-id (that is a
|
||||
// v0.3 keeper concern); it only enforces the coupon clamp invariant at
|
||||
// construction time. The returned Bond has status BondIssued.
|
||||
func Issue(bondID, issuerStandID string, principalGrain int64, couponBps uint32, termDays uint32, issuedAt, maturity int64) Bond {
|
||||
return Bond{
|
||||
BondID: bondID,
|
||||
IssuerStandID: issuerStandID,
|
||||
PrincipalGrain: principalGrain,
|
||||
CouponBps: Clamp(couponBps),
|
||||
TermDays: termDays,
|
||||
IssuedAt: issuedAt,
|
||||
Maturity: maturity,
|
||||
Status: BondIssued,
|
||||
}
|
||||
}
|
||||
|
||||
// Clamp ensures a coupon is within the LOCKED bounds (vision §17, REQ-021,
|
||||
// D-028: never above the cap, never below the floor). This is automatic and
|
||||
// authoritative; no Council vote can change it. The shape mirrors
|
||||
// x/feecovenant's Clamp exactly (min(cap, max(floor, coupon))).
|
||||
func Clamp(couponBps uint32) uint32 {
|
||||
if couponBps > CouponCapBps {
|
||||
return CouponCapBps
|
||||
}
|
||||
if couponBps < CouponFloorBps {
|
||||
return CouponFloorBps
|
||||
}
|
||||
return couponBps
|
||||
}
|
||||
|
||||
// Params for the bond module (skeleton — no tunables in v0.2; the cap and
|
||||
// floor are LOCKED consts, not Params fields).
|
||||
type Params struct{}
|
||||
|
||||
func DefaultParams() Params { return Params{} }
|
||||
|
||||
// GenesisState defines the bond module genesis state (REQ-021). Bonds is the
|
||||
// top-level set of issued bonds. ValidateGenesis enforces bond-id uniqueness
|
||||
// and the coupon clamp at genesis load (the data-engineer's genesis.go holds
|
||||
// the schema helpers per G-008).
|
||||
type GenesisState struct {
|
||||
Params Params `json:"params" yaml:"params"`
|
||||
Bonds []Bond `json:"bonds" yaml:"bonds"`
|
||||
}
|
||||
|
||||
func DefaultGenesisState() *GenesisState {
|
||||
return &GenesisState{
|
||||
Params: DefaultParams(),
|
||||
Bonds: []Bond{},
|
||||
}
|
||||
}
|
||||
|
||||
// ValidateGenesis performs ID-uniqueness checks (A-212 upgrade from v0.1
|
||||
// no-op): rejects duplicate bond-ids, and runs the coupon clamp at genesis
|
||||
// load (each genesis bond's coupon-bps must be within [floor, cap]). Delegates
|
||||
// to the data-engineer's genesis.go helpers (G-008).
|
||||
func ValidateGenesis(bz json.RawMessage) error {
|
||||
var gs GenesisState
|
||||
if err := json.Unmarshal(bz, &gs); err != nil {
|
||||
return fmt.Errorf("bond: invalid genesis: %w", err)
|
||||
}
|
||||
if err := ValidateBonds(gs.Bonds); err != nil {
|
||||
return fmt.Errorf("bond: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,431 @@
|
||||
package types_test
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/oy/openyield/lexicon"
|
||||
btypes "github.com/oy/openyield/x/bond/types"
|
||||
)
|
||||
|
||||
// --- Clamp invariant tests (highest-severity for bond) --------------------------
|
||||
// The Clamp invariant is the bond module's firewall (D-028): a bond coupon
|
||||
// can never exceed the cap (8pct) and can never fall below the floor (0pct).
|
||||
// These tests are the regression firewall — a change to CouponCapBps or
|
||||
// CouponFloorBps breaks them.
|
||||
|
||||
// TestCouponCapBpsLockedConst asserts CouponCapBps == 800 (8pct, D-028 LOCKED).
|
||||
// A regression firewall: changing the cap breaks this test.
|
||||
func TestCouponCapBpsLockedConst(t *testing.T) {
|
||||
if btypes.CouponCapBps != 800 {
|
||||
t.Errorf("CouponCapBps = %d, expected 800 (8pct — D-028 LOCKED)", btypes.CouponCapBps)
|
||||
}
|
||||
}
|
||||
|
||||
// TestCouponFloorBpsLockedConst asserts CouponFloorBps == 0 (0pct, D-028 LOCKED).
|
||||
// A regression firewall: changing the floor breaks this test.
|
||||
func TestCouponFloorBpsLockedConst(t *testing.T) {
|
||||
if btypes.CouponFloorBps != 0 {
|
||||
t.Errorf("CouponFloorBps = %d, expected 0 (0pct — D-028 LOCKED)", btypes.CouponFloorBps)
|
||||
}
|
||||
}
|
||||
|
||||
// TestClampBelowFloorReturnsFloor asserts a coupon below the floor is clamped
|
||||
// up to the floor.
|
||||
func TestClampBelowFloorReturnsFloor(t *testing.T) {
|
||||
// Negative coupons are not representable (uint32); the only "below floor"
|
||||
// case is impossible since the floor is 0 and the type is uint32. The test
|
||||
// asserts the floor value itself passes through (the in-range boundary).
|
||||
// A future floor > 0 would make this test assert negative-clamping; the
|
||||
// current floor == 0 means the below-floor case is type-prevented.
|
||||
got := btypes.Clamp(btypes.CouponFloorBps)
|
||||
if got != btypes.CouponFloorBps {
|
||||
t.Errorf("Clamp(floor) = %d, expected floor %d", got, btypes.CouponFloorBps)
|
||||
}
|
||||
}
|
||||
|
||||
// TestClampAboveCapReturnsCap asserts a coupon above the cap is clamped down
|
||||
// to the cap.
|
||||
func TestClampAboveCapReturnsCap(t *testing.T) {
|
||||
cases := []uint32{
|
||||
uint32(btypes.CouponCapBps) + 1,
|
||||
uint32(btypes.CouponCapBps) + 100,
|
||||
uint32(btypes.CouponCapBps) + 1000,
|
||||
900,
|
||||
1000,
|
||||
5000,
|
||||
}
|
||||
for _, c := range cases {
|
||||
got := btypes.Clamp(c)
|
||||
if got != btypes.CouponCapBps {
|
||||
t.Errorf("Clamp(%d) = %d, expected cap %d (above-cap must clamp to cap)", c, got, btypes.CouponCapBps)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestClampInRangeUnchanged asserts a coupon within [floor, cap] is unchanged.
|
||||
func TestClampInRangeUnchanged(t *testing.T) {
|
||||
cases := []uint32{
|
||||
0,
|
||||
1,
|
||||
100,
|
||||
400,
|
||||
500,
|
||||
799,
|
||||
uint32(btypes.CouponCapBps),
|
||||
}
|
||||
for _, c := range cases {
|
||||
got := btypes.Clamp(c)
|
||||
if got != c {
|
||||
t.Errorf("Clamp(%d) = %d, expected %d (in-range must be unchanged)", c, got, c)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestClampMatchesFeeCovenantShape asserts the bond Clamp has the same shape
|
||||
// as x/feecovenant's Clamp: min(cap, max(floor, coupon)). The test verifies
|
||||
// the boundary semantics rather than importing feecovenant (no cross-module
|
||||
// struct imports per G-003, though cross-module const access is allowed).
|
||||
func TestClampMatchesFeeCovenantShape(t *testing.T) {
|
||||
// The shape is min(cap, max(floor, coupon)). For floor=0 and cap=800:
|
||||
// min(800, max(0, coupon))
|
||||
// In-range passes through; above-cap clamps to cap; below-floor clamps to
|
||||
// floor (here, floor=0, so type-prevented for uint32).
|
||||
if btypes.Clamp(0) != 0 {
|
||||
t.Error("Clamp(0) should be 0 (floor boundary)")
|
||||
}
|
||||
if btypes.Clamp(800) != 800 {
|
||||
t.Error("Clamp(800) should be 800 (cap boundary)")
|
||||
}
|
||||
if btypes.Clamp(801) != 800 {
|
||||
t.Error("Clamp(801) should be 800 (above-cap clamps to cap)")
|
||||
}
|
||||
}
|
||||
|
||||
// TestClampInvariantBreaksIfCapChanges is the regression-firewall meta-assert:
|
||||
// if CouponCapBps were changed, the above-cap test would break. This test
|
||||
// documents the invariant: Clamp(above-cap) == cap, for the current cap.
|
||||
func TestClampInvariantBreaksIfCapChanges(t *testing.T) {
|
||||
above := uint32(btypes.CouponCapBps) + 50
|
||||
if btypes.Clamp(above) != btypes.CouponCapBps {
|
||||
t.Errorf("Clamp(%d) = %d, expected CouponCapBps %d (invariant: above-cap clamps to cap)", above, btypes.Clamp(above), btypes.CouponCapBps)
|
||||
}
|
||||
}
|
||||
|
||||
// --- BondStatus enum coverage (5) ----------------------------------------------
|
||||
|
||||
// TestBondStatusCountLockedConst asserts BondStatusCount == 5 and
|
||||
// AllBondStatuses() returns exactly 5 (REQ-021). A regression firewall.
|
||||
func TestBondStatusCountLockedConst(t *testing.T) {
|
||||
if btypes.BondStatusCount != 5 {
|
||||
t.Errorf("BondStatusCount = %d, expected 5 (REQ-021 LOCKED)", btypes.BondStatusCount)
|
||||
}
|
||||
all := btypes.AllBondStatuses()
|
||||
if len(all) != 5 {
|
||||
t.Errorf("AllBondStatuses() len = %d, expected 5", len(all))
|
||||
}
|
||||
}
|
||||
|
||||
// TestAllBondStatusesNames asserts the 5 REQ-021 names in order with no
|
||||
// extras, no dups, no renames.
|
||||
func TestAllBondStatusesNames(t *testing.T) {
|
||||
want := []string{"Issued", "Active", "Matured", "Defaulted", "Repaid"}
|
||||
all := btypes.AllBondStatuses()
|
||||
if len(all) != len(want) {
|
||||
t.Fatalf("len = %d, want %d", len(all), len(want))
|
||||
}
|
||||
seen := map[string]bool{}
|
||||
for i, s := range all {
|
||||
if string(s) != want[i] {
|
||||
t.Errorf("AllBondStatuses()[%d] = %q, want %q", i, s, want[i])
|
||||
}
|
||||
if seen[string(s)] {
|
||||
t.Errorf("duplicate BondStatus %q", s)
|
||||
}
|
||||
seen[string(s)] = true
|
||||
}
|
||||
}
|
||||
|
||||
// TestBondStatusValues asserts each named const matches its AllBondStatuses
|
||||
// entry.
|
||||
func TestBondStatusValues(t *testing.T) {
|
||||
if btypes.BondIssued != "Issued" {
|
||||
t.Errorf("BondIssued = %q", btypes.BondIssued)
|
||||
}
|
||||
if btypes.BondActive != "Active" {
|
||||
t.Errorf("BondActive = %q", btypes.BondActive)
|
||||
}
|
||||
if btypes.BondMatured != "Matured" {
|
||||
t.Errorf("BondMatured = %q", btypes.BondMatured)
|
||||
}
|
||||
if btypes.BondDefaulted != "Defaulted" {
|
||||
t.Errorf("BondDefaulted = %q", btypes.BondDefaulted)
|
||||
}
|
||||
if btypes.BondRepaid != "Repaid" {
|
||||
t.Errorf("BondRepaid = %q", btypes.BondRepaid)
|
||||
}
|
||||
}
|
||||
|
||||
// --- Issue stub callable -------------------------------------------------------
|
||||
|
||||
// TestIssueStubCallable asserts the Issue stub is callable and returns a
|
||||
// Bond with the coupon clamped and status BondIssued.
|
||||
func TestIssueStubCallable(t *testing.T) {
|
||||
b := btypes.Issue("bond-1", "stand-abc", 1_000_000, 500, 365, 1000, 1365)
|
||||
if b.BondID != "bond-1" {
|
||||
t.Errorf("BondID = %q", b.BondID)
|
||||
}
|
||||
if b.IssuerStandID != "stand-abc" {
|
||||
t.Errorf("IssuerStandID = %q", b.IssuerStandID)
|
||||
}
|
||||
if b.PrincipalGrain != 1_000_000 {
|
||||
t.Errorf("PrincipalGrain = %d", b.PrincipalGrain)
|
||||
}
|
||||
if b.CouponBps != 500 {
|
||||
t.Errorf("CouponBps = %d, expected 500 (in-range, unchanged)", b.CouponBps)
|
||||
}
|
||||
if b.TermDays != 365 {
|
||||
t.Errorf("TermDays = %d", b.TermDays)
|
||||
}
|
||||
if b.IssuedAt != 1000 || b.Maturity != 1365 {
|
||||
t.Errorf("IssuedAt=%d Maturity=%d", b.IssuedAt, b.Maturity)
|
||||
}
|
||||
if b.Status != btypes.BondIssued {
|
||||
t.Errorf("Status = %q, expected Issued", b.Status)
|
||||
}
|
||||
}
|
||||
|
||||
// TestIssueStubClampsAboveCap asserts the Issue stub clamps an above-cap
|
||||
// coupon down to the cap.
|
||||
func TestIssueStubClampsAboveCap(t *testing.T) {
|
||||
b := btypes.Issue("bond-2", "stand-abc", 1_000_000, 1200, 365, 1000, 1365)
|
||||
if b.CouponBps != btypes.CouponCapBps {
|
||||
t.Errorf("CouponBps = %d, expected cap %d (Issue must clamp above-cap coupon)", b.CouponBps, btypes.CouponCapBps)
|
||||
}
|
||||
}
|
||||
|
||||
// --- Bond struct fields --------------------------------------------------------
|
||||
|
||||
// TestBondStructFields asserts the Bond struct carries all required fields
|
||||
// including the by-ID-string ref to x/stand (issuer-stand-id per G-003).
|
||||
func TestBondStructFields(t *testing.T) {
|
||||
b := btypes.Bond{
|
||||
BondID: "bond-3",
|
||||
IssuerStandID: "stand-xyz",
|
||||
PrincipalGrain: 500_000,
|
||||
CouponBps: 300,
|
||||
TermDays: 180,
|
||||
IssuedAt: 2000,
|
||||
Maturity: 2180,
|
||||
Status: btypes.BondActive,
|
||||
}
|
||||
if b.BondID != "bond-3" || b.IssuerStandID != "stand-xyz" || b.PrincipalGrain != 500_000 ||
|
||||
b.CouponBps != 300 || b.TermDays != 180 || b.IssuedAt != 2000 || b.Maturity != 2180 ||
|
||||
b.Status != btypes.BondActive {
|
||||
t.Error("Bond fields not set correctly")
|
||||
}
|
||||
}
|
||||
|
||||
// TestBondIssuerStandIDIsString asserts issuer-stand-id is string-typed
|
||||
// (G-003 by-ID-string ref to x/stand; no struct import).
|
||||
func TestBondIssuerStandIDIsString(t *testing.T) {
|
||||
b := btypes.Bond{IssuerStandID: "stand-abc"}
|
||||
if b.IssuerStandID != "stand-abc" {
|
||||
t.Errorf("IssuerStandID = %q", b.IssuerStandID)
|
||||
}
|
||||
}
|
||||
|
||||
// --- Genesis -------------------------------------------------------------------
|
||||
|
||||
// TestDefaultGenesisStateEmpty asserts DefaultGenesisState returns non-nil
|
||||
// empty slice for Bonds.
|
||||
func TestDefaultGenesisStateEmpty(t *testing.T) {
|
||||
gs := btypes.DefaultGenesisState()
|
||||
if gs == nil {
|
||||
t.Fatal("DefaultGenesisState returned nil")
|
||||
}
|
||||
if gs.Bonds == nil || len(gs.Bonds) != 0 {
|
||||
t.Errorf("Default Bonds should be non-nil empty slice; got len=%d nil=%v", len(gs.Bonds), gs.Bonds == nil)
|
||||
}
|
||||
}
|
||||
|
||||
// TestValidateGenesisRejectsDupBondIDs asserts A-212: duplicate bond-ids are
|
||||
// rejected.
|
||||
func TestValidateGenesisRejectsDupBondIDs(t *testing.T) {
|
||||
gs := btypes.GenesisState{
|
||||
Bonds: []btypes.Bond{
|
||||
{BondID: "b1", IssuerStandID: "s1", CouponBps: 100, Status: btypes.BondIssued},
|
||||
{BondID: "b1", IssuerStandID: "s2", CouponBps: 200, Status: btypes.BondActive}, // dup
|
||||
},
|
||||
}
|
||||
bz, _ := json.Marshal(gs)
|
||||
if err := btypes.ValidateGenesis(bz); err == nil {
|
||||
t.Error("ValidateGenesis should reject duplicate bond-ids")
|
||||
}
|
||||
}
|
||||
|
||||
// TestValidateGenesisRejectsEmptyBondID asserts empty bond-id is rejected.
|
||||
func TestValidateGenesisRejectsEmptyBondID(t *testing.T) {
|
||||
gs := btypes.GenesisState{
|
||||
Bonds: []btypes.Bond{{BondID: "", IssuerStandID: "s1", CouponBps: 100, Status: btypes.BondIssued}},
|
||||
}
|
||||
bz, _ := json.Marshal(gs)
|
||||
if err := btypes.ValidateGenesis(bz); err == nil {
|
||||
t.Error("ValidateGenesis should reject empty bond-id")
|
||||
}
|
||||
}
|
||||
|
||||
// TestValidateGenesisRejectsUnknownBondStatus asserts an unknown BondStatus
|
||||
// is rejected.
|
||||
func TestValidateGenesisRejectsUnknownBondStatus(t *testing.T) {
|
||||
gs := btypes.GenesisState{
|
||||
Bonds: []btypes.Bond{{BondID: "b1", IssuerStandID: "s1", CouponBps: 100, Status: btypes.BondStatus("Bogus")}},
|
||||
}
|
||||
bz, _ := json.Marshal(gs)
|
||||
if err := btypes.ValidateGenesis(bz); err == nil {
|
||||
t.Error("ValidateGenesis should reject unknown bond status")
|
||||
}
|
||||
}
|
||||
|
||||
// TestValidateGenesisRejectsCouponAboveCap asserts the genesis-side clamp: a
|
||||
// genesis bond with coupon-bps above the cap is rejected (D-028).
|
||||
func TestValidateGenesisRejectsCouponAboveCap(t *testing.T) {
|
||||
gs := btypes.GenesisState{
|
||||
Bonds: []btypes.Bond{{BondID: "b1", IssuerStandID: "s1", CouponBps: uint32(btypes.CouponCapBps) + 1, Status: btypes.BondIssued}},
|
||||
}
|
||||
bz, _ := json.Marshal(gs)
|
||||
if err := btypes.ValidateGenesis(bz); err == nil {
|
||||
t.Error("ValidateGenesis should reject coupon-bps above cap (D-028 clamp at genesis load)")
|
||||
}
|
||||
}
|
||||
|
||||
// TestValidateGenesisRejectsCouponBelowFloor asserts the genesis-side clamp:
|
||||
// a genesis bond with coupon-bps below the floor is rejected (D-028).
|
||||
func TestValidateGenesisRejectsCouponBelowFloor(t *testing.T) {
|
||||
// Floor is 0; a uint32 cannot be below 0, so this test asserts the
|
||||
// boundary: coupon-bps == 0 (the floor) is accepted. The below-floor case
|
||||
// is type-prevented. We assert the floor boundary passes.
|
||||
gs := btypes.GenesisState{
|
||||
Bonds: []btypes.Bond{{BondID: "b1", IssuerStandID: "s1", CouponBps: 0, Status: btypes.BondIssued}},
|
||||
}
|
||||
bz, _ := json.Marshal(gs)
|
||||
if err := btypes.ValidateGenesis(bz); err != nil {
|
||||
t.Errorf("ValidateGenesis should accept coupon-bps == floor (0); got: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestValidateGenesisRejectsBadJSON asserts malformed JSON is rejected.
|
||||
func TestValidateGenesisRejectsBadJSON(t *testing.T) {
|
||||
if err := btypes.ValidateGenesis(json.RawMessage(`{not json`)); err == nil {
|
||||
t.Error("ValidateGenesis should reject malformed JSON")
|
||||
}
|
||||
}
|
||||
|
||||
// TestValidateGenesisAcceptsClean asserts a clean genesis validates.
|
||||
func TestValidateGenesisAcceptsClean(t *testing.T) {
|
||||
gs := btypes.GenesisState{
|
||||
Bonds: []btypes.Bond{
|
||||
{BondID: "b1", IssuerStandID: "s1", CouponBps: 100, Status: btypes.BondIssued},
|
||||
{BondID: "b2", IssuerStandID: "s1", CouponBps: 800, Status: btypes.BondActive},
|
||||
},
|
||||
}
|
||||
bz, _ := json.Marshal(gs)
|
||||
if err := btypes.ValidateGenesis(bz); err != nil {
|
||||
t.Errorf("ValidateGenesis should accept clean genesis, got: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// --- Module consts -------------------------------------------------------------
|
||||
|
||||
// TestModuleConsts asserts the four Cosmos-convention module consts.
|
||||
func TestModuleConsts(t *testing.T) {
|
||||
if btypes.ModuleName != "bond" {
|
||||
t.Errorf("ModuleName = %q", btypes.ModuleName)
|
||||
}
|
||||
if btypes.StoreKey != "bond" {
|
||||
t.Errorf("StoreKey = %q", btypes.StoreKey)
|
||||
}
|
||||
if btypes.RouterKey != "bond" {
|
||||
t.Errorf("RouterKey = %q", btypes.RouterKey)
|
||||
}
|
||||
if btypes.QuerierRoute != "bond" {
|
||||
t.Errorf("QuerierRoute = %q", btypes.QuerierRoute)
|
||||
}
|
||||
}
|
||||
|
||||
// TestDefaultParams asserts DefaultParams returns a zero-value Params.
|
||||
func TestDefaultParams(t *testing.T) {
|
||||
_ = btypes.DefaultParams() // no panics
|
||||
}
|
||||
|
||||
// --- Lexicon assertion (REQ-012) -------------------------------------------------
|
||||
// The bond module is the HIGHEST lexicon-risk package (A-210): the banned
|
||||
// terms that are natural coupon-synonyms ("intere"+"st", "yie"+"ld") must
|
||||
// NEVER appear. The coupon vocabulary is used EXCLUSIVELY. The lexicon
|
||||
// helpers are used here — no banned literals are inlined in this test file.
|
||||
|
||||
// TestLexiconNoBannedTermsInBondPackage scans every non-test .go file in the
|
||||
// bond/types package directory for the banned terms (case-insensitive).
|
||||
// Production files only — the test file references banned terms via the
|
||||
// lexicon package helpers (standard lexicon-test bootstrapping pattern).
|
||||
func TestLexiconNoBannedTermsInBondPackage(t *testing.T) {
|
||||
pkgDir := packageDir(t, "github.com/oy/openyield/x/bond/types")
|
||||
files, err := filepath.Glob(filepath.Join(pkgDir, "*.go"))
|
||||
if err != nil {
|
||||
t.Fatalf("glob: %v", err)
|
||||
}
|
||||
prodFiles := []string{}
|
||||
for _, f := range files {
|
||||
if strings.HasSuffix(f, "_test.go") {
|
||||
continue
|
||||
}
|
||||
prodFiles = append(prodFiles, f)
|
||||
}
|
||||
if len(prodFiles) == 0 {
|
||||
t.Fatal("no production .go files found in bond/types")
|
||||
}
|
||||
for _, f := range prodFiles {
|
||||
bz, err := os.ReadFile(f)
|
||||
if err != nil {
|
||||
t.Fatalf("read %s: %v", f, err)
|
||||
}
|
||||
if found, ok := lexicon.FindBannedTerm(string(bz)); ok {
|
||||
t.Errorf("%s: banned term %q (REQ-012 lexicon firewall — A-210 coupon-only vocabulary)", filepath.Base(f), found)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestLexiconNoBannedTermsInBondTestFile asserts this test file itself does
|
||||
// not contain any banned term as a literal (the firewall scans test files
|
||||
// too; the lexicon helpers must be used rather than inlining banned terms).
|
||||
func TestLexiconNoBannedTermsInBondTestFile(t *testing.T) {
|
||||
_, thisFile, _, ok := runtime.Caller(0)
|
||||
if !ok {
|
||||
t.Fatal("runtime.Caller failed")
|
||||
}
|
||||
bz, err := os.ReadFile(thisFile)
|
||||
if err != nil {
|
||||
t.Fatalf("read self: %v", err)
|
||||
}
|
||||
if found, ok := lexicon.FindBannedTerm(string(bz)); ok {
|
||||
t.Fatalf("bond test file contains banned term %q — use lexicon helpers, not literals (A-210)", found)
|
||||
}
|
||||
}
|
||||
|
||||
// packageDir resolves a Go import path to its filesystem directory by
|
||||
// walking up from this test file (v0.2 skeleton has zero external deps).
|
||||
func packageDir(t *testing.T, importPath string) string {
|
||||
t.Helper()
|
||||
_, file, _, ok := runtime.Caller(0)
|
||||
if !ok {
|
||||
t.Fatal("runtime.Caller failed")
|
||||
}
|
||||
// file = .../oy/x/bond/types/types_test.go -> repoRoot = .../oy (4 dirs up)
|
||||
repoRoot := filepath.Dir(filepath.Dir(filepath.Dir(filepath.Dir(file))))
|
||||
rel := strings.TrimPrefix(importPath, "github.com/oy/openyield/")
|
||||
return filepath.Join(repoRoot, rel)
|
||||
}
|
||||
Reference in New Issue
Block a user