tamakyi
7ab33227a5
用户诉求的后半：不该让他手填经纬度和半径，应该在地图上圈。三个手填输入框
换成地图 + 圆列表：点地图加圆、拖圆心移动、拖圆边改半径、列表里可改半径/
定位/删除、可一次清空；改动立刻写进隐藏字段 areas(JSON) 与 crs，随专题表单
一起提交。
- 复用 /admin/fog-mask 那套约定：/api/map-config 取底图、底图坐标系随表单带上、
后端换算成 GCJ-02。不另起炉灶。
- areas 的初值**渲染进隐藏字段**（不是只塞给 JS）：脚本没加载上时提交的仍是原值，
否则一次保存就把已有显示区静默清空。
- 地图初始视野取生效数据集的地点包围盒（placesBounds），一上来就落在自己的地界上，
而不是全国视野。
- 上限（20 个 / 0.05~2000 km）前端也校验一份，并**禁用提交**；两边数字用守卫比对，
免得出现「前端放行、后端拒绝，用户不知道改哪里」。
实测抓到并修掉的 bug：/admin/topics 没设 p.HasMap ⇒ 布局不引入 Leaflet，
表现是脚本加载了、rondTopicAreas 也在，就是 window.L 永远 undefined，init 静默
返回、控制台不报错、页面像「什么都没发生」。已加守卫钉住这一点。
其余：
- topic-areas.js 只暴露纯函数（校验/序列化/增删改的不可变性/几何换算）供 node 单测，
另加一个最小测试钩子 api._map 供无头验证（同 window.rondMap._state 惯例）。
- CSS 用定宽容器装半径输入框：站点全局 input 规则是 width:100% 且带 10 个 :not()
（特异性 (0,11,1)），直接给 input 写宽度压不过。
- gofmt：文档注释里的缩进列表按 Go 1.19 的规则重排；顺带把工作区的 CRLF 归一到 LF
（.gitattributes 早就声明 eol=lf，blob 本来也是 LF，所以 git diff 无额外噪声）。
验证：
- topic-areas.test.js 44 条（含「增删改返回新数组不原地改」、半径换算自洽性）。
- 三个新守卫：两边上限一致、模板契约（旧输入框必须没了 + 挂点齐全 + 初值来源）、
topicsAdminPage 必须设 HasMap。
- 无头端到端：两击成两圆 → 改半径 7.5 → 删第 1 个 → 越界半径被拦且禁用提交 →
提交 200 且落库 areas=[{lat:24.72,lon:108.1,radiusKm:7.5}]（废弃列镜像 7.5）；全程无 JS 报错。
500 lines
18 KiB
Go
500 lines
18 KiB
Go
package web
|
||
|
||
import (
|
||
"encoding/json"
|
||
"fmt"
|
||
"math"
|
||
"net/http"
|
||
"net/http/httptest"
|
||
"net/url"
|
||
"os"
|
||
"regexp"
|
||
"strconv"
|
||
"strings"
|
||
"testing"
|
||
|
||
"rond-with-you/internal/geo"
|
||
)
|
||
|
||
func closeTo(a, b float64) bool { return math.Abs(a-b) < 1e-9 }
|
||
|
||
// 显示区（一组圆）的数据层不变量。这些用例都是纯函数级的，不需要数据库。
|
||
|
||
// formPost 造一个已经 ParseForm 过的 POST 请求，供 topicAreasFromForm 读字段。
|
||
func formPost(t *testing.T, values url.Values) *http.Request {
|
||
t.Helper()
|
||
r := httptest.NewRequest("POST", "/admin/topics/save", strings.NewReader(values.Encode()))
|
||
r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
||
if err := r.ParseForm(); err != nil {
|
||
t.Fatalf("ParseForm: %v", err)
|
||
}
|
||
return r
|
||
}
|
||
|
||
// ---------- 表单解析：两个入口必须走同一套校验 ----------
|
||
|
||
func TestTopicAreasFromForm(t *testing.T) {
|
||
type want struct {
|
||
areas int
|
||
lat float64
|
||
lon float64
|
||
km float64
|
||
}
|
||
cases := []struct {
|
||
name string
|
||
values url.Values
|
||
want want
|
||
wantErr string
|
||
}{
|
||
{
|
||
name: "老表单三字段 → 合成一个圆",
|
||
values: url.Values{"center_lat": {"25.6"}, "center_lon": {"100.2"}, "radius_km": {"30"}},
|
||
want: want{areas: 1, lat: 25.6, lon: 100.2, km: 30},
|
||
},
|
||
{
|
||
name: "老表单全空 → 不限区域（不是错误）",
|
||
values: url.Values{"center_lat": {""}, "center_lon": {""}, "radius_km": {""}},
|
||
want: want{areas: 0},
|
||
},
|
||
{
|
||
name: "老表单半径 0 → 不限区域",
|
||
values: url.Values{"center_lat": {"25.6"}, "center_lon": {"100.2"}, "radius_km": {"0"}},
|
||
want: want{areas: 0},
|
||
},
|
||
{
|
||
name: "老表单有半径但圆心是 0,0 → 报错（不能静默变成「圈在几内亚湾」）",
|
||
values: url.Values{"center_lat": {"0"}, "center_lon": {"0"}, "radius_km": {"30"}},
|
||
wantErr: "点选圆心",
|
||
},
|
||
{
|
||
name: "编辑器 JSON → 多个圆",
|
||
values: url.Values{"areas": {`[{"lat":25,"lon":100,"radiusKm":3},{"lat":26,"lon":101,"radiusKm":5}]`}},
|
||
want: want{areas: 2, lat: 25, lon: 100, km: 3},
|
||
},
|
||
{
|
||
name: "编辑器 JSON 空数组 → 不限区域",
|
||
values: url.Values{"areas": {"[]"}},
|
||
want: want{areas: 0},
|
||
},
|
||
{
|
||
name: "坏 JSON → 报错而不是当成「不限区域」",
|
||
values: url.Values{"areas": {"[{lat:25]"}},
|
||
wantErr: "无法解析",
|
||
},
|
||
{
|
||
name: "半径越界 → 报错",
|
||
values: url.Values{"areas": {`[{"lat":25,"lon":100,"radiusKm":0.001}]`}},
|
||
wantErr: "半径",
|
||
},
|
||
{
|
||
name: "纬度越界 → 报错",
|
||
values: url.Values{"areas": {`[{"lat":91,"lon":100,"radiusKm":3}]`}},
|
||
wantErr: "超出经纬度",
|
||
},
|
||
}
|
||
|
||
for _, tc := range cases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
got, err := topicAreasFromForm(formPost(t, tc.values))
|
||
if tc.wantErr != "" {
|
||
if err == nil {
|
||
t.Fatalf("期望报错（含 %q），却通过了：%+v", tc.wantErr, got)
|
||
}
|
||
if !strings.Contains(err.Error(), tc.wantErr) {
|
||
t.Fatalf("错误信息里应含 %q，实得 %q", tc.wantErr, err.Error())
|
||
}
|
||
return
|
||
}
|
||
if err != nil {
|
||
t.Fatalf("不该报错: %v", err)
|
||
}
|
||
if len(got) != tc.want.areas {
|
||
t.Fatalf("圆的个数 = %d，期望 %d（%+v）", len(got), tc.want.areas, got)
|
||
}
|
||
if tc.want.areas > 0 {
|
||
if got[0].Lat != tc.want.lat || got[0].Lon != tc.want.lon || got[0].RadiusKm != tc.want.km {
|
||
t.Fatalf("第一个圆 = %+v，期望 {%v %v %v}", got[0], tc.want.lat, tc.want.lon, tc.want.km)
|
||
}
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// wgs84 底图上点的圆心必须换算成 GCJ-02 再存：地点过滤是拿它跟 places 的 GCJ-02 坐标
|
||
// 直接比球面距离的，不换算会整体偏几百米（历史上照片导入那次就是这么偏掉的）。
|
||
func TestTopicAreasFromFormConvertsWGS84(t *testing.T) {
|
||
const wgsLat, wgsLon = 25.6, 100.2
|
||
gcjLat, gcjLon := geo.WGS84ToGCJ02(wgsLat, wgsLon)
|
||
|
||
args := []url.Values{
|
||
// 编辑器路径
|
||
{"areas": {fmt.Sprintf(`[{"lat":%v,"lon":%v,"radiusKm":3}]`, wgsLat, wgsLon)}, "crs": {"wgs84"}},
|
||
// 老表单路径
|
||
{"center_lat": {fmt.Sprint(wgsLat)}, "center_lon": {fmt.Sprint(wgsLon)},
|
||
"radius_km": {"3"}, "crs": {"wgs84"}},
|
||
}
|
||
for i, v := range args {
|
||
got, err := topicAreasFromForm(formPost(t, v))
|
||
if err != nil {
|
||
t.Fatalf("[%d] %v", i, err)
|
||
}
|
||
if len(got) != 1 {
|
||
t.Fatalf("[%d] 应得 1 个圆，实得 %d", i, len(got))
|
||
}
|
||
if !closeTo(got[0].Lat, gcjLat) || !closeTo(got[0].Lon, gcjLon) {
|
||
t.Errorf("[%d] 没换算成 GCJ-02：得 %.6f,%.6f 期望 %.6f,%.6f", i, got[0].Lat, got[0].Lon, gcjLat, gcjLon)
|
||
}
|
||
if d := math.Hypot(got[0].Lat-wgsLat, got[0].Lon-wgsLon); d < 1e-4 {
|
||
t.Errorf("[%d] 换算前后竟然一样（说明根本没换算）", i)
|
||
}
|
||
}
|
||
|
||
// crs 不是 wgs84 时保持原值
|
||
got, err := topicAreasFromForm(formPost(t, url.Values{
|
||
"areas": {fmt.Sprintf(`[{"lat":%v,"lon":%v,"radiusKm":3}]`, wgsLat, wgsLon)}, "crs": {"gcj02"}}))
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if got[0].Lat != wgsLat || got[0].Lon != wgsLon {
|
||
t.Errorf("gcj02 底图不该换算，实得 %+v", got[0])
|
||
}
|
||
}
|
||
|
||
// ---------- SQL 占位符纪律 ----------
|
||
|
||
var placeholderRe = regexp.MustCompile(`\$(\d+)`)
|
||
|
||
// topicAreaCond 拼进 SQL 里的 $n 必须**恰好**是 [prefix+1, len(args)] 这个连续区间：
|
||
// 不跳号也不越界。这正是「专题内容全变 0」那类事故的判据 —— 少算一个就是 pgx
|
||
// 「expected N arguments, got M」，而列表页会把错误吞掉，只表现为数字变 0。
|
||
//
|
||
// 注意断言的是「本段自己用的那 3n 个编号」：前缀那几个（列表页批量的 dataset/start/end）
|
||
// 由查询里的别处引用，不该出现在区域条件里。
|
||
func TestTopicAreaCondPlaceholderDiscipline(t *testing.T) {
|
||
for _, n := range []int{1, 2, 3, 7} {
|
||
for _, prefix := range []int{3, 0} { // 3 = 列表页批量（dataset/start/end 先占位）
|
||
areas := make([]TopicArea, 0, n)
|
||
for i := 0; i < n; i++ {
|
||
areas = append(areas, TopicArea{
|
||
Lat: 20 + float64(i), Lon: 100 + float64(i), RadiusKm: 3})
|
||
}
|
||
topic := &Topic{Areas: areas}
|
||
args := make([]any, 0, prefix+3*n)
|
||
for i := 0; i < prefix; i++ {
|
||
args = append(args, i)
|
||
}
|
||
cond := topicAreaCond(topic, &args)
|
||
|
||
if len(args) != prefix+3*n {
|
||
t.Fatalf("n=%d prefix=%d：参数个数 = %d，期望 %d", n, prefix, len(args), prefix+3*n)
|
||
}
|
||
seen := map[int]int{}
|
||
maxIdx, count := 0, 0
|
||
for _, m := range placeholderRe.FindAllStringSubmatch(cond, -1) {
|
||
idx, err := strconv.Atoi(m[1])
|
||
if err != nil {
|
||
t.Fatalf("解析占位符 %q 失败", m[1])
|
||
}
|
||
if seen[idx] == 0 {
|
||
count++
|
||
}
|
||
seen[idx]++
|
||
if idx > maxIdx {
|
||
maxIdx = idx
|
||
}
|
||
}
|
||
// 最大值必须正好是最后一个参数 —— 否则下一个条件接着编号就会错位
|
||
if maxIdx != len(args) {
|
||
t.Errorf("n=%d prefix=%d：最大编号 = $%d，应正好是 $%d（否则后续条件会错位）\n%s",
|
||
n, prefix, maxIdx, len(args), cond)
|
||
}
|
||
// 且必须是 prefix+1 起、3n 个互不相同的连续编号
|
||
if count != 3*n {
|
||
t.Errorf("n=%d prefix=%d：引用了 %d 个不同编号，期望 %d\n%s", n, prefix, count, 3*n, cond)
|
||
}
|
||
for idx := prefix + 1; idx <= len(args); idx++ {
|
||
if seen[idx] == 0 {
|
||
t.Errorf("n=%d prefix=%d：$%d 没被引用（跳号）\n%s", n, prefix, idx, cond)
|
||
}
|
||
}
|
||
for idx := 1; idx <= prefix; idx++ {
|
||
if seen[idx] != 0 {
|
||
t.Errorf("n=%d prefix=%d：不该引用前缀的 $%d（那是查询别处的参数）", n, prefix, idx)
|
||
}
|
||
}
|
||
// OR 的个数 = 圆的个数 - 1（并集语义：落在任一圆内即可）
|
||
if got := strings.Count(cond, " OR "); got != n-1 {
|
||
t.Errorf("n=%d：OR 个数 = %d，期望 %d\n%s", n, got, n-1, cond)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 不限区域时既不加参数也不加条件
|
||
args := []any{1, 2, 3}
|
||
if cond := topicAreaCond(&Topic{}, &args); cond != "" || len(args) != 3 {
|
||
t.Errorf("不限区域时应空手而归，实得 cond=%q args=%d", cond, len(args))
|
||
}
|
||
}
|
||
|
||
// 老行（areas 还没回填）与测试里直接构造 Topic 的写法都得继续工作。
|
||
func TestTopicAreaListFallsBackToLegacyCircle(t *testing.T) {
|
||
legacy := Topic{CenterLat: 25, CenterLon: 100, RadiusKm: 30}
|
||
if !legacy.HasArea() {
|
||
t.Error("只有老的三列时 HasArea 应为真")
|
||
}
|
||
if got := legacy.AreaList(); len(got) != 1 || got[0].RadiusKm != 30 {
|
||
t.Errorf("应退回单圆，实得 %+v", got)
|
||
}
|
||
// Areas 非空时以 Areas 为准，老的列不再参与
|
||
both := Topic{CenterLat: 1, CenterLon: 1, RadiusKm: 1,
|
||
Areas: []TopicArea{{Lat: 25, Lon: 100, RadiusKm: 3}, {Lat: 26, Lon: 101, RadiusKm: 4}}}
|
||
if got := both.AreaList(); len(got) != 2 || got[0].Lat != 25 {
|
||
t.Errorf("应以 Areas 为准，实得 %+v", got)
|
||
}
|
||
// 半径 0 / 无坐标 = 不限区域
|
||
if (Topic{}).HasArea() || (Topic{CenterLat: 25, CenterLon: 100}).HasArea() {
|
||
t.Error("没有圆时 HasArea 应为假")
|
||
}
|
||
}
|
||
|
||
// 出库值不能是 JSON null：areas 列有 NOT NULL，而 json.Marshal(nil slice) 恰好给 "null"。
|
||
func TestTopicAreasColumnNeverNull(t *testing.T) {
|
||
for _, in := range [][]TopicArea{nil, {}, {{Lat: 1, Lon: 2, RadiusKm: 3}}} {
|
||
got := string(topicAreasColumn(in))
|
||
if got == "null" {
|
||
t.Fatalf("输入 %+v 时写成了 null（列上有 NOT NULL）", in)
|
||
}
|
||
var back []TopicArea
|
||
if err := json.Unmarshal([]byte(got), &back); err != nil {
|
||
t.Fatalf("%s 不是合法 JSON: %v", got, err)
|
||
}
|
||
if len(back) != len(in) {
|
||
t.Errorf("往返后圆的个数 %d ≠ %d", len(back), len(in))
|
||
}
|
||
}
|
||
}
|
||
|
||
// ---------- 视野贴合 ----------
|
||
|
||
// 外接矩形必须把**每一个**圆都包住（漏一个圆，那个圆里的迷雾就会被挤到视野外）。
|
||
func TestTopicAreasBoundsCoversEveryCircle(t *testing.T) {
|
||
areas := []TopicArea{
|
||
{Lat: 25.0, Lon: 100.0, RadiusKm: 3},
|
||
{Lat: 30.5, Lon: 110.25, RadiusKm: 10},
|
||
{Lat: 20.0, Lon: 95.0, RadiusKm: 50},
|
||
}
|
||
minLat, maxLat, minLon, maxLon, ok := topicAreasBounds(areas)
|
||
if !ok {
|
||
t.Fatal("应返回 ok")
|
||
}
|
||
for _, a := range areas {
|
||
dLat := a.RadiusKm / 111.32
|
||
cos := math.Cos(a.Lat * math.Pi / 180)
|
||
dLon := a.RadiusKm / (111.32 * cos)
|
||
if a.Lat-dLat < minLat-1e-9 || a.Lat+dLat > maxLat+1e-9 ||
|
||
a.Lon-dLon < minLon-1e-9 || a.Lon+dLon > maxLon+1e-9 {
|
||
t.Errorf("圆 %+v 没被外接矩形包住：纬度[%v,%v] 经度[%v,%v]",
|
||
a, minLat, maxLat, minLon, maxLon)
|
||
}
|
||
}
|
||
// 单圆时与「圆心 ± r/111.32」等价（原来 fitCircle 用 toBounds(2r) 给的就是这个正方形）
|
||
one := []TopicArea{{Lat: 25.0, Lon: 100.0, RadiusKm: 30}}
|
||
minLat, maxLat, minLon, maxLon, _ = topicAreasBounds(one)
|
||
if !closeTo(minLat, 25-30/111.32) || !closeTo(maxLat, 25+30/111.32) {
|
||
t.Errorf("单圆纬度区间 = [%v,%v]", minLat, maxLat)
|
||
}
|
||
wantDLon := 30 / (111.32 * math.Cos(25*math.Pi/180))
|
||
if !closeTo(minLon, 100-wantDLon) || !closeTo(maxLon, 100+wantDLon) {
|
||
t.Errorf("单圆经度区间 = [%v,%v]，期望 ±%v", minLon, maxLon, wantDLon)
|
||
}
|
||
// 空 → 没有矩形
|
||
if _, _, _, _, ok := topicAreasBounds(nil); ok {
|
||
t.Error("没有圆时不该返回矩形")
|
||
}
|
||
}
|
||
|
||
// 贴合参数：有显示区就用所有圆的并集外接矩形，否则退回点集包围盒；
|
||
// 两者都没有时给 null（脚本据此再退回它自己的 fit）。
|
||
func TestFitParamsUsesBBox(t *testing.T) {
|
||
var b struct{ MinLat, MaxLat, MinLon, MaxLon float64 }
|
||
|
||
bbox := fitParams(Topic{Areas: []TopicArea{{Lat: 25, Lon: 100, RadiusKm: 3}}}, nil)
|
||
if err := json.Unmarshal([]byte(bbox), &b); err != nil {
|
||
t.Fatalf("有显示区时 fitBBox 不是合法 JSON: %s (%v)", bbox, err)
|
||
}
|
||
if !(b.MinLat < 25 && b.MaxLat > 25 && b.MinLon < 100 && b.MaxLon > 100) {
|
||
t.Errorf("fitBBox 应包住圆心：%+v", b)
|
||
}
|
||
|
||
// 多圆：矩形要同时包住两个圆，而不是只包住第一个
|
||
bbox = fitParams(Topic{Areas: []TopicArea{
|
||
{Lat: 25, Lon: 100, RadiusKm: 3}, {Lat: 30, Lon: 110, RadiusKm: 5}}}, nil)
|
||
if err := json.Unmarshal([]byte(bbox), &b); err != nil {
|
||
t.Fatalf("多圆 fitBBox 不是合法 JSON: %s (%v)", bbox, err)
|
||
}
|
||
if !(b.MinLat < 25 && b.MaxLat > 30 && b.MinLon < 100 && b.MaxLon > 110) {
|
||
t.Errorf("多圆 fitBBox 应同时包住两个圆：%+v", b)
|
||
}
|
||
|
||
// 不限区域时退回点集包围盒
|
||
bbox = fitParams(Topic{}, []MapPoint{{Lat: 21, Lon: 99}, {Lat: 23, Lon: 103}})
|
||
if err := json.Unmarshal([]byte(bbox), &b); err != nil {
|
||
t.Fatalf("点集 fitBBox 不是合法 JSON: %s", bbox)
|
||
}
|
||
if b.MinLat != 21 || b.MaxLat != 23 || b.MinLon != 99 || b.MaxLon != 103 {
|
||
t.Errorf("点集包围盒 = %+v", b)
|
||
}
|
||
|
||
// 两者都没有 → null，交给脚本自己的点集贴合
|
||
if got := fitParams(Topic{}, nil); string(got) != "null" {
|
||
t.Errorf("既无显示区又无点时应给 null，实得 %s", got)
|
||
}
|
||
}
|
||
|
||
// 经纬度夹取：极地 / 超大半径不至于算出 ±inf 或越界值喂给 fitBounds。
|
||
func TestTopicAreasBoundsClampsToGlobe(t *testing.T) {
|
||
minLat, maxLat, minLon, maxLon, ok := topicAreasBounds([]TopicArea{{Lat: 89.9, Lon: 179.9, RadiusKm: 2000}})
|
||
if !ok {
|
||
t.Fatal("应返回 ok")
|
||
}
|
||
for _, v := range []float64{minLat, maxLat} {
|
||
if v < -90 || v > 90 || math.IsInf(v, 0) || math.IsNaN(v) {
|
||
t.Errorf("纬度夹取后仍是 %v", v)
|
||
}
|
||
}
|
||
for _, v := range []float64{minLon, maxLon} {
|
||
if v < -180 || v > 180 || math.IsInf(v, 0) || math.IsNaN(v) {
|
||
t.Errorf("经度夹取后仍是 %v", v)
|
||
}
|
||
}
|
||
}
|
||
|
||
// ---------- 个数上限 ----------
|
||
|
||
func TestNormalizeTopicAreasLimits(t *testing.T) {
|
||
ok := make([]TopicArea, maxTopicAreas)
|
||
for i := range ok {
|
||
ok[i] = TopicArea{Lat: 20 + float64(i)/100, Lon: 100, RadiusKm: 3}
|
||
}
|
||
if _, err := normalizeTopicAreas(ok, ""); err != nil {
|
||
t.Errorf("%d 个圆应当允许：%v", maxTopicAreas, err)
|
||
}
|
||
tooMany := append(append([]TopicArea(nil), ok...), TopicArea{Lat: 25, Lon: 100, RadiusKm: 3})
|
||
if _, err := normalizeTopicAreas(tooMany, ""); err == nil {
|
||
t.Errorf("%d 个圆应当拒绝", len(tooMany))
|
||
}
|
||
for _, bad := range []TopicArea{
|
||
{Lat: math.NaN(), Lon: 100, RadiusKm: 3},
|
||
{Lat: 25, Lon: math.Inf(1), RadiusKm: 3},
|
||
{Lat: 25, Lon: 100, RadiusKm: math.NaN()},
|
||
{Lat: 25, Lon: 100, RadiusKm: topicAreaMaxRadiusKm + 1},
|
||
{Lat: 25, Lon: 100, RadiusKm: 0},
|
||
} {
|
||
if _, err := normalizeTopicAreas([]TopicArea{bad}, ""); err == nil {
|
||
t.Errorf("%+v 应当被拒绝", bad)
|
||
}
|
||
}
|
||
}
|
||
|
||
// ---------- 编辑器：两边写死的上限必须一致 ----------
|
||
//
|
||
// 前端 validate() 与后端 normalizeTopicAreas() 各写了一份上限。不一致的表现很别扭：
|
||
// 前端放行、后端拒绝 ⇒ 用户看到一句红字却不知道改哪里（甚至以为是自己填错了）。
|
||
// 这两份数字没有办法共享（一边 Go 一边 JS），所以直接静态比对。
|
||
func TestTopicAreaLimitsMatchBetweenGoAndJS(t *testing.T) {
|
||
js, err := staticFS.ReadFile("static/js/topic-areas.js")
|
||
if err != nil {
|
||
t.Fatalf("读取 topic-areas.js 失败: %v", err)
|
||
}
|
||
src := string(js)
|
||
get := func(name string) string {
|
||
m := regexp.MustCompile(name + `\s*=\s*([0-9.]+)`).FindStringSubmatch(src)
|
||
if m == nil {
|
||
t.Fatalf("topic-areas.js 里找不到 %s 的定义", name)
|
||
}
|
||
return m[1]
|
||
}
|
||
cases := []struct {
|
||
jsName string
|
||
want float64
|
||
}{
|
||
{"MAX_AREAS", float64(maxTopicAreas)},
|
||
{"MIN_KM", topicAreaMinRadiusKm},
|
||
{"MAX_KM", topicAreaMaxRadiusKm},
|
||
}
|
||
for _, c := range cases {
|
||
got, err := strconv.ParseFloat(get(c.jsName), 64)
|
||
if err != nil {
|
||
t.Fatalf("解析 %s 失败: %v", c.jsName, err)
|
||
}
|
||
if got != c.want {
|
||
t.Errorf("%s：JS 写的是 %v，后端是 %v —— 两边必须一致（前端放行后端拒绝，用户不知道改哪里）",
|
||
c.jsName, got, c.want)
|
||
}
|
||
}
|
||
}
|
||
|
||
// ---------- 编辑器：模板契约 ----------
|
||
//
|
||
// 钉住「编辑器的挂点」与「旧入口已经拆掉」：
|
||
//
|
||
// ① 三个手填坐标输入框必须没了 —— 留着就是第二套入口，而它只写第 1 个圆，
|
||
// 用户会觉得「我明明填了坐标，怎么只认一个」；
|
||
// ② areas 的初值必须**渲染进隐藏字段**（不是只放在 JS 里）：脚本没加载上时提交的
|
||
// 仍是原值，否则一次保存就把已有显示区静默清空；
|
||
// ③ 编辑器脚本必须在页面里引入，且 init 的挂点 id 与模板里的 id 对得上。
|
||
func TestTopicAdminUsesMapEditorNotCoordInputs(t *testing.T) {
|
||
b, err := tmplFS.ReadFile("templates/admin/topics.html")
|
||
if err != nil {
|
||
t.Fatalf("读取 admin/topics.html 失败: %v", err)
|
||
}
|
||
body := string(b)
|
||
for _, gone := range []string{`name="center_lat"`, `name="center_lon"`, `name="radius_km"`} {
|
||
if strings.Contains(body, gone) {
|
||
t.Errorf("admin/topics.html 不该再有 %s —— 显示区改由地图点选，留着就是第二套只写第 1 个圆的入口", gone)
|
||
}
|
||
}
|
||
for _, need := range []string{
|
||
`id="area-map"`, `id="area-list"`, `id="area-new-km"`, `id="area-clear"`, `id="area-hint"`,
|
||
`id="topic-form"`, `name="areas"`, `name="crs"`,
|
||
`/static/js/topic-areas.js`, `rondTopicAreas.init(`,
|
||
} {
|
||
if !strings.Contains(body, need) {
|
||
t.Errorf("admin/topics.html 里缺 %q —— 显示区编辑器没挂全", need)
|
||
}
|
||
}
|
||
// areas 初值要在隐藏字段上（服务端渲染），不是只传进 JS
|
||
if !strings.Contains(body, `name="areas" value="{{.Form.AreasJSON}}"`) {
|
||
t.Error(`areas 的初值必须渲染进隐藏字段（value="{{.Form.AreasJSON}}"）：` +
|
||
"脚本没加载上时要能原样提交，否则一次保存就清空已有显示区")
|
||
}
|
||
// 日期控件那条既有约定不能被挤掉
|
||
if !strings.Contains(body, "rondDatetime.attachAll") {
|
||
t.Error("admin/topics.html 里的日期控件初始化没了")
|
||
}
|
||
}
|
||
|
||
// 后台专题页要有地图 ⇒ 必须设 p.HasMap（布局按它决定引不引入 Leaflet）。
|
||
// 漏了的表现很隐蔽：脚本加载了、编辑器对象也在，就是 window.L 永远 undefined，
|
||
// init 直接静默返回 —— 页面看着「什么都没发生」，控制台也不报错。实测就是这么踩的。
|
||
func TestTopicsAdminPageLoadsLeaflet(t *testing.T) {
|
||
src, err := os.ReadFile(pkgFile(t, "handlers_topics.go"))
|
||
if err != nil {
|
||
t.Fatalf("读取 handlers_topics.go 失败: %v", err)
|
||
}
|
||
body := string(src)
|
||
i := strings.Index(body, "func (s *Server) topicsAdminPage(")
|
||
if i < 0 {
|
||
t.Fatal("handlers_topics.go 里找不到 topicsAdminPage")
|
||
}
|
||
// 取到下一个顶层 func 为止（函数体不会嵌套顶层 func）
|
||
rest := body[i:]
|
||
if j := strings.Index(rest[1:], "\nfunc "); j >= 0 {
|
||
rest = rest[:j+1]
|
||
}
|
||
if !strings.Contains(rest, "HasMap = true") {
|
||
t.Error("topicsAdminPage 必须设 p.HasMap = true —— 不设的话布局不引入 Leaflet，" +
|
||
"显示区编辑器会静默不出现（脚本在、编辑器在，就是 window.L 是 undefined）")
|
||
}
|
||
}
|