summaryrefslogtreecommitdiff
path: root/tests/FundLab.Api.Tests/StockTradeTests.fs
blob: a2269a1b9204ba4c532fadd3a20271fafad2e023 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
namespace FundLab.Api.Tests

open System
open System.Threading
open Xunit
open FundLab.Api

module StockTradeSupport =
    let stubQuoteProbe (quote: StockQuote) =
        { new IStockQuoteProbe with
            member _.GetQuote(_, _) = Ok quote }

    let failingQuoteProbe (failure: MarketDataFailure) =
        { new IStockQuoteProbe with
            member _.GetQuote(_, _) = Error failure }

    let quote600519 =
        {
            Code = "600519"
            Name = Some "贵州茅台"
            Price = Some 1252.57m
            Currency = "CNY"
        }

    let appWithQuote (probe: IStockQuoteProbe) =
        { NavDates = NavDateProbeSupport.stubNavDateProbe
          NavSeries = NavDateProbeSupport.stubNavSeriesProbe
          BondQuotes = NavDateProbeSupport.stubBondQuoteProbe
          StockQuotes = probe
          StockDaily = NavDateProbeSupport.stubStockDailyProbe }

[<Collection("postgres")>]
type StockTradeTests(fixture: PostgresFixture) =
    let sharedRepository =
        lazy
            let value = FundRepository(fixture.ConnectionString)
            value.EnsureSchema()
            value

    let repository () = sharedRepository.Value

    let createFund () =
        let command =
            {
                Name = "股票闭环测试 FOF"
                InitialCash = 100000.00m
                InitialUnitNav = 1.00000000m
                IsSynthetic = true
            }

        let key = fixture.Key(sprintf "stock-trade-fund-%s" (Guid.NewGuid().ToString("N")))

        match repository().CreateFund(key, command) with
        | FundWriteResult.Created fund -> fund.Id
        | other -> failwithf "unexpected fund creation result: %A" other

    let app probe =
        let probes = StockTradeSupport.appWithQuote probe
        App.createApplicationWithProbes (repository ()) probes

    let buy (probe: IStockQuoteProbe) fundId body idempotencyKey =
        PersistenceTestHelpers.invoke
            (app probe)
            "POST"
            (sprintf "/api/funds/%O/stock-trades" fundId)
            [ "Authorization", "Bearer test-token"; "Idempotency-Key", idempotencyKey ]
            body

    let readPositions (probe: IStockQuoteProbe) fundId =
        PersistenceTestHelpers.invoke
            (app probe)
            "GET"
            (sprintf "/api/funds/%O/stock-positions" fundId)
            [ "Authorization", "Bearer test-token" ]
            ""

    [<Fact>]
    member _.``buying a stock with a live quote records a trade and a position``() =
        let fundId = createFund ()
        let probe = StockTradeSupport.stubQuoteProbe StockTradeSupport.quote600519

        let status, body =
            buy probe fundId """{"instrumentCode":"600519","quantity":"100"}""" (fixture.Key "stock-trade-buy-ok")

        Assert.Equal(201, status)
        Assert.Contains("\"instrumentCode\":\"600519\"", body)
        Assert.Contains("贵州茅台", body)
        Assert.Contains("1252.57", body)
        Assert.Contains("125257.00", body)

        let status, positionsBody = readPositions probe fundId
        Assert.Equal(200, status)
        Assert.Contains("\"instrumentCode\":\"600519\"", positionsBody)
        Assert.Contains("\"quantity\":\"100.00000000\"", positionsBody)
        Assert.Contains("125257.00", positionsBody)

    [<Fact>]
    member _.``buying an unknown code with an unavailable quote does not create a position``() =
        let fundId = createFund ()

        let probe =
            StockTradeSupport.failingQuoteProbe (
                MarketDataCollectorUnavailable "AKShare collector failed: no valid quote for 999999"
            )

        let status, body =
            buy probe fundId """{"instrumentCode":"999999","quantity":"100"}""" (fixture.Key "stock-trade-unknown")

        Assert.Equal(503, status)
        Assert.Contains("MARKET_DATA_UNAVAILABLE", body)

        let status, positionsBody = readPositions probe fundId
        Assert.Equal(200, status)
        Assert.DoesNotContain("999999", positionsBody)
        Assert.Contains("\"positions\":[]", positionsBody)

    [<Fact>]
    member _.``buying with a non-positive quantity is rejected without a position``() =
        let fundId = createFund ()
        let probe = StockTradeSupport.stubQuoteProbe StockTradeSupport.quote600519

        let status, body =
            buy probe fundId """{"instrumentCode":"600519","quantity":"0"}""" (fixture.Key "stock-trade-zero")

        Assert.Equal(400, status)
        Assert.Contains("INVALID_STOCK_TRADE_REQUEST", body)

        let _, positionsBody = readPositions probe fundId
        Assert.Contains("\"positions\":[]", positionsBody)

    [<Fact>]
    member _.``buying with a malformed code is rejected``() =
        let fundId = createFund ()
        let probe = StockTradeSupport.stubQuoteProbe StockTradeSupport.quote600519

        let status, body =
            buy probe fundId """{"instrumentCode":"abc","quantity":"100"}""" (fixture.Key "stock-trade-badcode")

        Assert.Equal(400, status)
        Assert.Contains("six digits", body)

    [<Fact>]
    member _.``replaying a buy with the same idempotency key does not double the position``() =
        let fundId = createFund ()
        let probe = StockTradeSupport.stubQuoteProbe StockTradeSupport.quote600519
        let key = fixture.Key "stock-trade-replay"

        let status, _ = buy probe fundId """{"instrumentCode":"600519","quantity":"100"}""" key
        Assert.Equal(201, status)

        let status, _ = buy probe fundId """{"instrumentCode":"600519","quantity":"100"}""" key
        Assert.Equal(200, status)

        let _, positionsBody = readPositions probe fundId
        Assert.Contains("\"quantity\":\"100.00000000\"", positionsBody)
        Assert.DoesNotContain("\"quantity\":\"200.00000000\"", positionsBody)

    [<Fact>]
    member _.``buying a fund that does not exist answers 404``() =
        let probe = StockTradeSupport.stubQuoteProbe StockTradeSupport.quote600519

        let status, body =
            buy probe (Guid.NewGuid()) """{"instrumentCode":"600519","quantity":"100"}""" (fixture.Key "stock-trade-missing")

        Assert.Equal(404, status)
        Assert.Contains("FUND_NOT_FOUND", body)