w-trade-solve 1.0.1

package/test/unit-estimKeys.test.mjs

@@ -0,0 +1,260 @@
+import assert from 'assert'
+import fs from 'fs'
+import path from 'path'
+import estimKeys from '../src/estimKeys.mjs'
+import readStrategies from '../src/readStrategies.mjs'
+import genTid from '../src/genTid.mjs'
+import cont from '../src/cont.mjs'
+import ott from '../src/ott.mjs'
+import { buildFdTmp, buildFdData, buildSt, keySettings } from './unit-setup.mjs'
+
+
+//規格來源: src/estimKeys.mjs
+//  estimKeys(ott, st, fdOhlc, fdParam, timeStart, timeEnd, mode, keys, fdData, opt):
+//    設計變數為[止損, 止盈, ...各key門檻], 止損止盈由opt.thsSl與opt.thsTp之百分比清單除以100離散取值
+//    各key門檻由rang(-2,2,40)之41點各自平移+10與-10為82點, 解值>0代表'>'條件、<0代表'<'條件, 還原時扣除平移值
+//    以omlPSO求解, 各次以runStrategy回測並經calcFitness計算適應值
+//    滿足thNumTrade、thRWin與thREquivalentCumuProfitOrLossFinalNormYear三門檻者, 以genStrategyFileName存入fdData
+//    同tkid(tid+級距)已有策略時, 僅於等效年化盈虧更佳時抽換並刪除較差者, 故同tkid恆僅一檔
+//    fdData不存在時自動建立
+
+
+let fdTmp = buildFdTmp('estimKeys')
+
+
+let st = buildSt()
+
+
+//optBase: 三門檻皆放寬, 使求解過程之可用參數組必然寫出策略檔
+let optBase = {
+    keySettings,
+    thsTp: [3],
+    thsSl: [2],
+    thNumTrade: 1,
+    thRWin: 0,
+    thREquivalentCumuProfitOrLossFinalNormYear: -1e9,
+}
+
+
+describe('estimKeys', function() {
+
+    after(function() {
+        fs.rmSync(fdTmp, { recursive: true, force: true })
+    })
+
+    describe('求解與策略儲存', function() {
+
+        let keys = ['btc_4hr_ma_1day']
+        let d = null
+        let m = null
+
+        before(async function() {
+            this.timeout(120000)
+            d = buildFdData(fdTmp, 'solve', keys, { n: 20 })
+            m = await estimKeys(ott, st, d.fdOhlc, d.fdParam, d.timeStart, d.timeEnd, 'long', keys, d.fdData, optBase)
+        })
+
+        it('回傳omlPSO之求解結果, 含bestSolution與停止資訊', function() {
+            assert.ok(typeof m === 'object' && m !== null)
+            assert.ok(Number.isFinite(m.bestSolution.fitness), `fitness須為有限數: ${m.bestSolution.fitness}`)
+            assert.ok(typeof m.stopMode === 'string' && m.stopMode.length > 0)
+            assert.ok(m.stopExecutions > 0)
+        })
+
+        it('設計變數個數為2(止損止盈)加上keys個數', function() {
+            assert.strictEqual(m.bestSolution.ps.length, 2 + keys.length)
+        })
+
+        it('止損與止盈之解值取自opt.thsSl與opt.thsTp除以100', function() {
+            //thsSl=[2] → 0.02, thsTp=[3] → 0.03, 各僅1點故解值唯一
+            assert.strictEqual(m.bestSolution.ps[0].value, 0.02)
+            assert.strictEqual(m.bestSolution.ps[1].value, 0.03)
+        })
+
+        it('各key門檻之解值落於平移後之兩區間, 絕對值介於8至12', function() {
+            //rang(-2,2,40)之值域[-2,2], 平移量vdir=10, 故'>'組為[8,12]、'<'組為[-12,-8]
+            m.bestSolution.ps.slice(2).forEach((p, i) => {
+                assert.ok(Math.abs(p.value) >= 8 - 1e-9 && Math.abs(p.value) <= 12 + 1e-9, `第${i}個門檻解值 ${p.value} 超出範圍`)
+            })
+        })
+
+        it('fdData不存在時自動建立, 並寫出策略檔', function() {
+            assert.ok(fs.existsSync(d.fdData), 'fdData須被建立')
+            let ss = readStrategies(d.fdData)
+            assert.ok(ss.length > 0, '門檻放寬時須有策略檔寫出')
+        })
+
+        it('策略檔名之tid段等同於genTid之輸出', function() {
+            let tid = genTid('btc', '4hr', 'long', keys)
+            let ss = readStrategies(d.fdData)
+            ss.forEach((s) => {
+                assert.strictEqual(s.tid, tid, `檔名 ${s.name}`)
+            })
+        })
+
+        it('同tkid恆僅保留一檔', function() {
+            let ss = readStrategies(d.fdData)
+            let tkids = ss.map((v) => {
+                return v.tkid
+            })
+            assert.strictEqual(new Set(tkids).size, tkids.length, `tkid重複: ${tkids}`)
+        })
+
+        it('策略檔內容含策略、回測摘要與適應值', function() {
+            let ss = readStrategies(d.fdData, { readContent: true })
+            ss.forEach((s) => {
+                let c = s.data
+                assert.strictEqual(c.tid, s.tid)
+                assert.ok(typeof c.sid === 'string' && c.sid.length > 0)
+                assert.strictEqual(c.name, 'btc')
+                assert.strictEqual(c.symbol, 'BTCUSDT')
+                assert.strictEqual(c.interval, '4hr')
+                assert.strictEqual(c.mode, 'long')
+                assert.strictEqual(c.keyOhlc, 'btc_price_4hr') //`${name}_price_${interval}`
+                assert.ok(Number.isFinite(c.fitness))
+                assert.ok(typeof c.summary === 'object' && c.summary !== null)
+            })
+        })
+
+        it('策略檔內之conds各元素為{key,sym,th}, key取自keys, sym為>或<, th落於[-2,2]', function() {
+            let ss = readStrategies(d.fdData, { readContent: true })
+            ss.forEach((s) => {
+                assert.strictEqual(s.data.conds.length, keys.length)
+                s.data.conds.forEach((cond) => {
+                    assert.ok(keys.includes(cond.key), `key[${cond.key}]不在keys內`)
+                    assert.ok(cond.sym === '>' || cond.sym === '<', `sym[${cond.sym}]非預期`)
+                    assert.ok(cond.th >= -2 - 1e-9 && cond.th <= 2 + 1e-9, `th[${cond.th}]超出[-2,2]`)
+                })
+            })
+        })
+
+        it('策略檔內之settings止盈止損等同於opt所給之百分比除以100', function() {
+            let ss = readStrategies(d.fdData, { readContent: true })
+            ss.forEach((s) => {
+                assert.strictEqual(s.data.settings.rStopLoss, 0.02)
+                assert.strictEqual(s.data.settings.rTakeProfit, 0.03)
+                assert.strictEqual(s.data.settings.uIni, 1000)
+                assert.strictEqual(s.data.settings.uTrade, 1)
+                assert.strictEqual(s.data.settings.rFee, 0.0005)
+            })
+        })
+
+        it('策略檔之級距段與檔內summary.numTrade一致', function() {
+            let ss = readStrategies(d.fdData, { readContent: true })
+            ss.forEach((s) => {
+                let numTrade = Number(s.data.summary.numTrade)
+                assert.ok(numTrade >= 1, `已存策略之交易次數須達thNumTrade: ${numTrade}`)
+            })
+        })
+
+        it('策略檔之等效年化盈虧段與檔內summary一致', function() {
+            let ss = readStrategies(d.fdData, { readContent: true })
+            ss.forEach((s) => {
+                assert.strictEqual(s.rEquivalentCumuProfitOrLossFinalNormYear, s.data.summary.rEquivalentCumuProfitOrLossFinalNormYear)
+            })
+        })
+
+    })
+
+    describe('儲存門檻', function() {
+
+        it('交易次數門檻無法達成時不寫出任何策略檔', async function() {
+            this.timeout(120000)
+            let keys = ['btc_4hr_ma_1day']
+            let d = buildFdData(fdTmp, 'nosave', keys, { n: 20 })
+
+            await estimKeys(ott, st, d.fdOhlc, d.fdParam, d.timeStart, d.timeEnd, 'long', keys, d.fdData, {
+                ...optBase,
+                thNumTrade: 1e9, //資料僅20根K線, 無從達成
+            })
+
+            assert.deepStrictEqual(readStrategies(d.fdData), [])
+        })
+
+    })
+
+    describe('輸入檢核', function() {
+
+        let keys = ['btc_4hr_ma_1day']
+        let d = null
+
+        before(function() {
+            d = buildFdData(fdTmp, 'check', keys, { n: 10 })
+        })
+
+        //call: 以合法引數為底, 依opt覆寫指定引數後呼叫
+        let call = (ov = {}) => {
+            let a = {
+                fdOhlc: d.fdOhlc,
+                fdParam: d.fdParam,
+                timeStart: d.timeStart,
+                timeEnd: d.timeEnd,
+                mode: 'long',
+                keys,
+                fdData: d.fdData,
+                opt: optBase,
+                ...ov,
+            }
+            return estimKeys(ott, st, a.fdOhlc, a.fdParam, a.timeStart, a.timeEnd, a.mode, a.keys, a.fdData, a.opt)
+        }
+
+        it('fdOhlc非有效字串時reject', async function() {
+            await assert.rejects(call({ fdOhlc: '' }), /invalid fdOhlc/)
+            await assert.rejects(call({ fdOhlc: null }), /invalid fdOhlc/)
+        })
+
+        it('fdParam非有效字串時reject', async function() {
+            await assert.rejects(call({ fdParam: '' }), /invalid fdParam/)
+        })
+
+        it('timeStart非有效字串時reject', async function() {
+            await assert.rejects(call({ timeStart: '' }), /invalid timeStart/)
+        })
+
+        it('timeEnd非有效字串時reject', async function() {
+            await assert.rejects(call({ timeEnd: '' }), /invalid timeEnd/)
+        })
+
+        it('mode非long或short時reject', async function() {
+            await assert.rejects(call({ mode: 'buy' }), /invalid mode/)
+            await assert.rejects(call({ mode: '' }), /invalid mode/)
+        })
+
+        it('keys非有效陣列時reject', async function() {
+            await assert.rejects(call({ keys: [] }), /invalid keys/)
+            await assert.rejects(call({ keys: 'aa' }), /invalid keys/)
+        })
+
+        it('fdData非有效字串時reject', async function() {
+            await assert.rejects(call({ fdData: '' }), /invalid fdData/)
+        })
+
+        it('opt.keySettings非有效字串時reject', async function() {
+            await assert.rejects(call({ opt: {} }), /invalid opt.keySettings/)
+            await assert.rejects(call({ opt: { keySettings: 123 } }), /invalid opt.keySettings/)
+        })
+
+        it('回測時間範圍超出資料範圍時reject', async function() {
+            //w-data-tdprovide之getTimeSeriesFullByTimeRange檢核起訖時間
+            await assert.rejects(call({ timeStart: '1990-01-01T00:00:00' }), /timeStartData/)
+            await assert.rejects(call({ timeEnd: '2099-01-01T00:00:00' }), /timeEndData/)
+        })
+
+    })
+
+    describe('策略檔名規則', function() {
+
+        it('檔名恰可由dlmPkgs切為3段', function() {
+            //由求解階段所產生之檔案驗證
+            let fdData = path.resolve(fdTmp, 'solve', 'data-strategy')
+            let fns = fs.readdirSync(fdData)
+            assert.ok(fns.length > 0)
+            fns.forEach((fn) => {
+                assert.strictEqual(fn.slice(0, -5).split(cont.dlmPkgs).length, 3, `檔名 ${fn}`)
+                assert.ok(fn.endsWith('.json'), `檔名 ${fn}`)
+            })
+        })
+
+    })
+
+})

package/test/unit-estimPicks.test.mjs

@@ -0,0 +1,241 @@
+import assert from 'assert'
+import fs from 'fs'
+import estimPicks from '../src/estimPicks.mjs'
+import ott from '../src/ott.mjs'
+import { buildFdTmp, buildFdData, buildSt, keySettings } from './unit-setup.mjs'
+
+
+//規格來源: src/estimPicks.mjs
+//  estimPicks(ott, st, fdOhlc, fdParam, timeStart, timeEnd, mode, funPickKeys, fdData, opt):
+//    由fdParam列舉全部指標key後分3類: 開頭為'index_'者為keysIndex, 含'_vbs_'者為keysVolumn, 其餘為keysNorm
+//    分類後各類依序經opt.funFilterKeysNorm、opt.funFilterKeysIndex、opt.funFilterKeysVolumn過濾(皆await)
+//    再呼叫funPickKeys({keysNorm,keysIndex,keysVolumn})取得keys, 最後交由estimKeys求解
+//  觀察方式: 以funPickKeys回傳空陣列, 使estimKeys於keys檢核即reject, 藉此於不進入求解之情況下驗證分類與過濾
+
+
+let fdTmp = buildFdTmp('estimPicks')
+
+
+let st = buildSt()
+
+
+//keysParam: 涵蓋3類, index_開頭為指數類, 含_vbs_為成交量類, 其餘為一般類
+let keyNormA = 'btc_4hr_ma_1day'
+let keyNormB = 'btc_4hr_rsi'
+let keyIndex = 'index_fear_greed'
+let keyVolumn = 'btc_4hr_vbs_ratio'
+let keysParam = [keyNormA, keyNormB, keyIndex, keyVolumn]
+
+
+let d = null
+
+
+//call: 以合法引數為底, 依ov覆寫指定引數後呼叫
+let call = (ov = {}) => {
+    let a = {
+        fdOhlc: d.fdOhlc,
+        fdParam: d.fdParam,
+        timeStart: d.timeStart,
+        timeEnd: d.timeEnd,
+        mode: 'long',
+        funPickKeys: () => {
+            return []
+        },
+        fdData: d.fdData,
+        opt: { keySettings },
+        ...ov,
+    }
+    return estimPicks(ott, st, a.fdOhlc, a.fdParam, a.timeStart, a.timeEnd, a.mode, a.funPickKeys, a.fdData, a.opt)
+}
+
+
+describe('estimPicks', function() {
+
+    before(function() {
+        d = buildFdData(fdTmp, 'picks', keysParam, { n: 10 })
+    })
+
+    after(function() {
+        fs.rmSync(fdTmp, { recursive: true, force: true })
+    })
+
+    describe('指標key分類', function() {
+
+        it('依名稱分為keysNorm、keysIndex與keysVolumn三類', async function() {
+            let got = null
+            await assert.rejects(call({
+                funPickKeys: (o) => {
+                    got = o
+                    return []
+                },
+            }), /invalid keys/)
+
+            assert.deepStrictEqual(got.keysNorm.sort(), [keyNormA, keyNormB].sort())
+            assert.deepStrictEqual(got.keysIndex, [keyIndex])
+            assert.deepStrictEqual(got.keysVolumn, [keyVolumn])
+        })
+
+        it('分類互斥且涵蓋fdParam內全部key', async function() {
+            let got = null
+            await assert.rejects(call({
+                funPickKeys: (o) => {
+                    got = o
+                    return []
+                },
+            }), /invalid keys/)
+
+            let all = [...got.keysNorm, ...got.keysIndex, ...got.keysVolumn]
+            assert.strictEqual(all.length, keysParam.length)
+            assert.deepStrictEqual(all.sort(), [...keysParam].sort())
+        })
+
+        it('僅開頭為index_者歸為指數類, 名稱中段含index_者仍為一般類', async function() {
+            let dd = buildFdData(fdTmp, 'cls-index', ['btc_index_rsi', 'index_rsi'], { n: 10 })
+            let got = null
+            await assert.rejects(estimPicks(ott, st, dd.fdOhlc, dd.fdParam, dd.timeStart, dd.timeEnd, 'long', (o) => {
+                got = o
+                return []
+            }, dd.fdData, { keySettings }), /invalid keys/)
+
+            assert.deepStrictEqual(got.keysIndex, ['index_rsi'])
+            assert.deepStrictEqual(got.keysNorm, ['btc_index_rsi'])
+        })
+
+        it('含_vbs_者優先於一般類, 且index_開頭優先於成交量類', async function() {
+            //判斷順序為index_開頭 → 含_vbs_ → 其餘
+            let dd = buildFdData(fdTmp, 'cls-vbs', ['index_a_vbs_b', 'btc_vbs_c'], { n: 10 })
+            let got = null
+            await assert.rejects(estimPicks(ott, st, dd.fdOhlc, dd.fdParam, dd.timeStart, dd.timeEnd, 'long', (o) => {
+                got = o
+                return []
+            }, dd.fdData, { keySettings }), /invalid keys/)
+
+            assert.deepStrictEqual(got.keysIndex, ['index_a_vbs_b'])
+            assert.deepStrictEqual(got.keysVolumn, ['btc_vbs_c'])
+            assert.deepStrictEqual(got.keysNorm, [])
+        })
+
+    })
+
+    describe('過濾函數', function() {
+
+        it('funFilterKeysNorm之回傳取代原keysNorm', async function() {
+            let got = null
+            await assert.rejects(call({
+                opt: {
+                    keySettings,
+                    funFilterKeysNorm: (ks) => {
+                        return ks.filter((v) => {
+                            return v === keyNormA
+                        })
+                    },
+                },
+                funPickKeys: (o) => {
+                    got = o
+                    return []
+                },
+            }), /invalid keys/)
+
+            assert.deepStrictEqual(got.keysNorm, [keyNormA])
+        })
+
+        it('funFilterKeysIndex與funFilterKeysVolumn同樣可過濾各自類別', async function() {
+            let got = null
+            await assert.rejects(call({
+                opt: {
+                    keySettings,
+                    funFilterKeysIndex: () => {
+                        return []
+                    },
+                    funFilterKeysVolumn: () => {
+                        return []
+                    },
+                },
+                funPickKeys: (o) => {
+                    got = o
+                    return []
+                },
+            }), /invalid keys/)
+
+            assert.deepStrictEqual(got.keysIndex, [])
+            assert.deepStrictEqual(got.keysVolumn, [])
+            assert.strictEqual(got.keysNorm.length, 2) //未給過濾函數者不受影響
+        })
+
+        it('過濾函數為async時亦被await', async function() {
+            let got = null
+            await assert.rejects(call({
+                opt: {
+                    keySettings,
+                    funFilterKeysNorm: async (ks) => {
+                        return ks.slice(0, 1)
+                    },
+                },
+                funPickKeys: (o) => {
+                    got = o
+                    return []
+                },
+            }), /invalid keys/)
+
+            assert.strictEqual(got.keysNorm.length, 1)
+            assert.ok(typeof got.keysNorm[0] === 'string')
+        })
+
+    })
+
+    describe('keys傳遞', function() {
+
+        it('funPickKeys回傳空陣列時, estimKeys於keys檢核reject', async function() {
+            await assert.rejects(call({
+                funPickKeys: () => {
+                    return []
+                },
+            }), /invalid keys/)
+        })
+
+        it('funPickKeys回傳非空陣列時通過keys檢核, 續往後續檢核', async function() {
+            //opt未給keySettings, 故停在estimKeys之opt.keySettings檢核, 代表keys已通過
+            await assert.rejects(call({
+                funPickKeys: () => {
+                    return [keyNormA]
+                },
+                opt: {},
+            }), /invalid opt.keySettings/)
+        })
+
+    })
+
+    describe('輸入檢核', function() {
+
+        it('fdOhlc非有效字串時reject', async function() {
+            await assert.rejects(call({ fdOhlc: '' }), /invalid fdOhlc/)
+        })
+
+        it('fdParam非有效字串時reject', async function() {
+            await assert.rejects(call({ fdParam: '' }), /invalid fdParam/)
+        })
+
+        it('timeStart非有效字串時reject', async function() {
+            await assert.rejects(call({ timeStart: '' }), /invalid timeStart/)
+        })
+
+        it('timeEnd非有效字串時reject', async function() {
+            await assert.rejects(call({ timeEnd: '' }), /invalid timeEnd/)
+        })
+
+        it('mode非long或short時reject', async function() {
+            await assert.rejects(call({ mode: 'buy' }), /invalid mode/)
+        })
+
+        it('funPickKeys非函數時reject', async function() {
+            await assert.rejects(call({ funPickKeys: null }), /funPickKeys is not a function/)
+            await assert.rejects(call({ funPickKeys: 'aa' }), /funPickKeys is not a function/)
+        })
+
+        it('fdData非有效字串時reject', async function() {
+            await assert.rejects(call({ fdData: '' }), /invalid fdData/)
+        })
+
+    })
+
+})

package/test/unit-genSid.test.mjs

@@ -0,0 +1,75 @@
+import assert from 'assert'
+import genSid from '../src/genSid.mjs'
+import genTid from '../src/genTid.mjs'
+import cont from '../src/cont.mjs'
+
+
+//規格來源: src/genSid.mjs
+//  genSid(coin, interval, mode, conds): 各cond先組為`${key}${sym}${th}`,
+//    再以cont.dlmSeps串接mode與各cond, 最後進行與genTid相同之縮寫替換
+//    sid已含門檻, 故同組keys之不同門檻對應不同sid
+
+
+let d = cont.dlmSeps
+
+
+describe('genSid', function() {
+
+    it('各cond組為 key + sym + th 後以dlmSeps串接', function() {
+        let conds = [
+            { key: 'aa', sym: '>', th: 0.05 },
+            { key: 'bb', sym: '<', th: -0.2 },
+        ]
+        let sid = genSid('btc', '4hr', 'long', conds)
+        assert.strictEqual(sid, `long${d}aa>0.05${d}bb<-0.2`)
+    })
+
+    it('縮寫替換與genTid一致', function() {
+        let conds = [
+            { key: 'btc_price_4hr_ma_1day', sym: '>', th: 0.05 },
+            { key: 'btc_index_rsi_4hr', sym: '<', th: -0.2 },
+        ]
+        let sid = genSid('btc', '4hr', 'long', conds)
+        assert.strictEqual(sid, `long${d}p_ma_1day>0.05${d}i_rsi_4hr<-0.2`)
+    })
+
+    it('Ohlc_轉o_, Close_轉c_, Volumn_轉v_', function() {
+        let conds = [
+            { key: 'Ohlc_a', sym: '>', th: 1 },
+            { key: 'Close_b', sym: '>', th: 2 },
+            { key: 'Volumn_c', sym: '<', th: 3 },
+        ]
+        let sid = genSid('btc', '4hr', 'long', conds)
+        assert.strictEqual(sid, `long${d}o_a>1${d}c_b>2${d}v_c<3`)
+    })
+
+    it('conds為空陣列時僅回傳mode', function() {
+        assert.strictEqual(genSid('btc', '4hr', 'long', []), 'long')
+    })
+
+    it('門檻不同時sid不同, 但對應之tid相同', function() {
+        //sid區別門檻, tid區別keys, 兩者為策略之不同層級識別
+        let keys = ['btc_price_4hr_ma_1day']
+        let condsA = [{ key: keys[0], sym: '>', th: 0.05 }]
+        let condsB = [{ key: keys[0], sym: '>', th: 0.35 }]
+        assert.notStrictEqual(genSid('btc', '4hr', 'long', condsA), genSid('btc', '4hr', 'long', condsB))
+        assert.strictEqual(genTid('btc', '4hr', 'long', keys), genTid('btc', '4hr', 'long', keys))
+    })
+
+    it('sym不同時sid不同', function() {
+        let condsU = [{ key: 'aa', sym: '>', th: 0.5 }]
+        let condsL = [{ key: 'aa', sym: '<', th: 0.5 }]
+        assert.notStrictEqual(genSid('btc', '4hr', 'long', condsU), genSid('btc', '4hr', 'long', condsL))
+    })
+
+    it('mode為short時開頭為short', function() {
+        let conds = [{ key: 'aa', sym: '>', th: 1 }]
+        assert.strictEqual(genSid('btc', '4hr', 'short', conds), `short${d}aa>1`)
+    })
+
+    it('coin為空字串時替換樣式退化為底線, 將剔除全部底線', function() {
+        let conds = [{ key: 'btc_ma_1day', sym: '>', th: 1 }]
+        assert.strictEqual(genSid('', '4hr', 'long', conds), `long${d}btcma1day>1`)
+    })
+
+})

package/test/unit-genStrategyFileName.test.mjs

@@ -0,0 +1,85 @@
+import assert from 'assert'
+import genStrategyFileName from '../src/genStrategyFileName.mjs'
+import genTid from '../src/genTid.mjs'
+import calcLevelNumTrade from '../src/calcLevelNumTrade.mjs'
+import cont from '../src/cont.mjs'
+
+
+//規格來源: src/genStrategyFileName.mjs
+//  genStrategyFileName(coin, interval, mode, keys, settings, summary):
+//    檔名為`${tid}${cont.dlmPkgs}${levelNumTrade}${cont.dlmPkgs}${rEquivalentCumuProfitOrLossFinalNormYear}.json`
+//    tid由genTid(coin, interval, mode, keys)產生
+//    levelNumTrade由calcLevelNumTrade(cint(summary.numTrade))產生
+//    rEquivalentCumuProfitOrLossFinalNormYear直接取自summary, 未經轉換
+//    settings未參與檔名組成
+
+
+let p = cont.dlmPkgs
+
+
+let settings = { uIni: 1000, uTrade: 1, rTakeProfit: 0.05, rStopLoss: 0.03, rFee: 0.0005 }
+
+
+describe('genStrategyFileName', function() {
+
+    it('檔名由tid、級距與等效年化盈虧以dlmPkgs串接並附.json', function() {
+        let keys = ['btc_price_4hr_ma_1day']
+        let summary = { numTrade: 30, rEquivalentCumuProfitOrLossFinalNormYear: '31.25%' }
+        let fn = genStrategyFileName('btc', '4hr', 'long', keys, settings, summary)
+        assert.strictEqual(fn, `long${cont.dlmSeps}p_ma_1day${p}12${p}31.25%.json`)
+    })
+
+    it('tid段與genTid之輸出一致', function() {
+        let keys = ['btc_index_rsi_4hr', 'btc_price_4hr_ma_1day']
+        let summary = { numTrade: 8, rEquivalentCumuProfitOrLossFinalNormYear: '5%' }
+        let fn = genStrategyFileName('btc', '4hr', 'short', keys, settings, summary)
+        assert.strictEqual(fn.split(p)[0], genTid('btc', '4hr', 'short', keys))
+    })
+
+    it('級距段與calcLevelNumTrade之輸出一致', function() {
+        let keys = ['aa']
+        let nums = [0, 3, 30, 120, 3500, 9000]
+        nums.forEach((numTrade) => {
+            let summary = { numTrade, rEquivalentCumuProfitOrLossFinalNormYear: '1%' }
+            let fn = genStrategyFileName('btc', '4hr', 'long', keys, settings, summary)
+            assert.strictEqual(fn.split(p)[1], String(calcLevelNumTrade(numTrade)), `numTrade[${numTrade}]`)
+        })
+    })
+
+    it('等效年化盈虧原樣帶入, 含負值與%符號', function() {
+        let keys = ['aa']
+        let summary = { numTrade: 30, rEquivalentCumuProfitOrLossFinalNormYear: '-71.17%' }
+        let fn = genStrategyFileName('btc', '4hr', 'long', keys, settings, summary)
+        assert.strictEqual(fn, `long${cont.dlmSeps}aa${p}12${p}-71.17%.json`)
+    })
+
+    it('settings不影響檔名', function() {
+        let keys = ['aa']
+        let summary = { numTrade: 30, rEquivalentCumuProfitOrLossFinalNormYear: '10%' }
+        let a = genStrategyFileName('btc', '4hr', 'long', keys, settings, summary)
+        let b = genStrategyFileName('btc', '4hr', 'long', keys, { uIni: 99999 }, summary)
+        assert.strictEqual(a, b)
+    })
+
+    it('同tid但交易次數落於不同級距時, 檔名不同, 故可各自保留最佳策略', function() {
+        let keys = ['aa']
+        let a = genStrategyFileName('btc', '4hr', 'long', keys, settings, { numTrade: 20, rEquivalentCumuProfitOrLossFinalNormYear: '10%' })
+        let b = genStrategyFileName('btc', '4hr', 'long', keys, settings, { numTrade: 30, rEquivalentCumuProfitOrLossFinalNormYear: '10%' })
+        assert.notStrictEqual(a, b)
+        assert.strictEqual(a.split(p)[0], b.split(p)[0]) //tid相同
+    })
+
+    it('檔名恰可由dlmPkgs切為3段', function() {
+        let keys = ['btc_price_4hr_ma_1day', 'btc_index_rsi_4hr']
+        let summary = { numTrade: 30, rEquivalentCumuProfitOrLossFinalNormYear: '31.25%' }
+        let fn = genStrategyFileName('btc', '4hr', 'long', keys, settings, summary)
+        assert.strictEqual(fn.split(p).length, 3)
+    })
+
+    it('summary.numTrade非數值時先經cint轉為0, 級距為0', function() {
+        //cint('abc')為0, 故不throw而落於<=0之級距
+        let fn = genStrategyFileName('btc', '4hr', 'long', ['aa'], settings, { numTrade: 'abc', rEquivalentCumuProfitOrLossFinalNormYear: '1%' })
+        assert.strictEqual(fn.split(p)[1], '0')
+    })
+
+})