Waldo_test.res
1open VitestHelpers
2
3// Test data matching the Waldo API format
4let sampleResultJson = `{
5 "gid": 102191569,
6 "name": "Washington",
7 "placetype": "region",
8 "lon": -77.0369,
9 "lat": 38.9072,
10 "distance": 0.0,
11 "bearing": 0.0,
12 "region": ["Washington", "District of Columbia", "United States", "North America"],
13 "country": "US"
14}`
15
16let sampleGeocodeResponseJson = `{
17 "results": [${sampleResultJson}],
18 "num_results": 1
19}`
20
21let sampleErrorResponseJson = `{
22 "error": "missing required parameter: q"
23}`
24
25describe("Waldo FFI bindings", () => {
26 describe("decodeResult", () => {
27 test("decodes valid result", ctx => {
28 let json = JSON.parseExn(sampleResultJson)
29 switch Waldo.decodeResult(json) {
30 | Some(result) => {
31 ctx->expect(result.gid)->toBe(102191569)
32 ctx->expect(result.name)->toBe("Washington")
33 ctx->expect(result.placetype)->toBe("region")
34 ctx->expect(result.lon)->toBeCloseTo(-77.0369, ~digits=4)
35 ctx->expect(result.lat)->toBeCloseTo(38.9072, ~digits=4)
36 ctx->expect(result.distance)->toBeCloseTo(0.0, ~digits=4)
37 ctx->expect(result.bearing)->toBeCloseTo(0.0, ~digits=4)
38 ctx->expect(result.region)->toEqual(["Washington", "District of Columbia", "United States", "North America"])
39 ctx->expect(result.country)->toBe("US")
40 }
41 | None => ctx->fail("Should decode result")
42 }
43 })
44
45 test("returns None for invalid JSON", ctx => {
46 let json = JSON.parseExn(`{"invalid": "data"}`)
47 ctx->expect(Waldo.decodeResult(json))->toEqual(None)
48 })
49
50 test("returns None for missing fields", ctx => {
51 let json = JSON.parseExn(`{"gid": 123}`)
52 ctx->expect(Waldo.decodeResult(json))->toEqual(None)
53 })
54 })
55
56 describe("decodeGeocodeResponse", () => {
57 test("decodes valid geocode response", ctx => {
58 let json = JSON.parseExn(sampleGeocodeResponseJson)
59 switch Waldo.decodeGeocodeResponse(json) {
60 | Some(response) => {
61 ctx->expect(response.numResults)->toBe(1)
62 ctx->expect(response.results)->toHaveLength(1)
63 switch response.results[0] {
64 | Some(first) => ctx->expect(first.name)->toBe("Washington")
65 | None => ctx->fail("Should have first result")
66 }
67 }
68 | None => ctx->fail("Should decode response")
69 }
70 })
71
72 test("returns None for invalid response", ctx => {
73 let json = JSON.parseExn(`{"invalid": "data"}`)
74 ctx->expect(Waldo.decodeGeocodeResponse(json))->toEqual(None)
75 })
76 })
77
78 describe("decodeErrorResponse", () => {
79 test("decodes error response", ctx => {
80 let json = JSON.parseExn(sampleErrorResponseJson)
81 switch Waldo.decodeErrorResponse(json) {
82 | Some(err) => ctx->expect(err.error)->toBe("missing required parameter: q")
83 | None => ctx->fail("Should decode error")
84 }
85 })
86
87 test("returns None for non-error JSON", ctx => {
88 let json = JSON.parseExn(`{"success": true}`)
89 ctx->expect(Waldo.decodeErrorResponse(json))->toEqual(None)
90 })
91 })
92
93 describe("Forward.buildUrl", () => {
94 test("builds URL with query only", ctx => {
95 let params: Waldo.Forward.params = {query: "Washington DC"}
96 let url = Waldo.Forward.buildUrl(params)
97 ctx->expect(url)->toBe("/forward?q=Washington%20DC")
98 })
99
100 test("builds URL with bias point", ctx => {
101 let params: Waldo.Forward.params = {query: "Washington", biasPoint: (-77.0, 38.9)}
102 let url = Waldo.Forward.buildUrl(params)
103 ctx->expect(url)->toInclude("q=Washington")
104 ctx->expect(url)->toInclude("lon=-77")
105 ctx->expect(url)->toInclude("lat=38.9")
106 })
107
108 test("URL encodes special characters", ctx => {
109 let params: Waldo.Forward.params = {query: "São Paulo"}
110 let url = Waldo.Forward.buildUrl(params)
111 ctx->expect(url->String.includes(" "))->toEqual(false)
112 ctx->expect(url)->toInclude("q=S%C3%A3o%20Paulo")
113 })
114 })
115
116 describe("Reverse.buildUrl", () => {
117 test("builds URL with coordinates", ctx => {
118 let params: Waldo.Reverse.params = {lon: -77.0369, lat: 38.9072}
119 let url = Waldo.Reverse.buildUrl(params)
120 ctx->expect(url)->toBe("/reverse?lon=-77.0369&lat=38.9072")
121 })
122 })
123})
