test/test-version.sgl — sigil-version

1(import (sigil test)

2 (sigil version))

4;; ============================================================

5;; Parsing

6;; ============================================================

8(test-group "parse-version"

9 (test "basic version"

10 (let ((v (parse-version "1.2.3")))

11 (assert-true (version? v))

12 (assert-equal 1 (version-major v))

13 (assert-equal 2 (version-minor v))

14 (assert-equal 3 (version-patch v))

15 (assert-false (version-prerelease v))

16 (assert-false (version-build v))))

18 (test "version with v prefix"

19 (let ((v (parse-version "v2.0.0")))

20 (assert-true (version? v))

21 (assert-equal 2 (version-major v))))

23 (test "version with V prefix"

24 (let ((v (parse-version "V1.0.0")))

25 (assert-true (version? v))

26 (assert-equal 1 (version-major v))))

28 (test "single major only"

29 (let ((v (parse-version "1")))

30 (assert-true (version? v))

31 (assert-equal 1 (version-major v))

32 (assert-equal 0 (version-minor v))

33 (assert-equal 0 (version-patch v))))

35 (test "major.minor only"

36 (let ((v (parse-version "1.0")))

37 (assert-true (version? v))

38 (assert-equal 1 (version-major v))

39 (assert-equal 0 (version-minor v))

40 (assert-equal 0 (version-patch v))))

42 (test "leading whitespace"

43 (let ((v (parse-version " 1.2.3")))

44 (assert-true (version? v))

45 (assert-equal 1 (version-major v))))

47 (test "prerelease"

48 (let ((v (parse-version "1.0.0-alpha.1")))

49 (assert-true (version? v))

50 (assert-equal '("alpha" 1) (version-prerelease v))))

52 (test "build metadata"

53 (let ((v (parse-version "1.0.0+build.42")))

54 (assert-true (version? v))

55 (assert-equal "build.42" (version-build v))))

57 (test "prerelease and build"

58 (let ((v (parse-version "1.0.0-beta+exp.sha")))

59 (assert-true (version? v))

60 (assert-equal '("beta") (version-prerelease v))

61 (assert-equal "exp.sha" (version-build v))))

63 (test "invalid: empty string"

64 (assert-false (parse-version "")))

66 (test "invalid: letters"

67 (assert-false (parse-version "abc")))

69 (test "invalid: non-string raises error"

70 (assert-error (parse-version #f))))

72;; ============================================================

73;; version->string roundtrip

74;; ============================================================

76(test-group "version->string"

77 (test "basic roundtrip"

78 (assert-equal "1.2.3" (version->string (parse-version "1.2.3"))))

80 (test "prerelease roundtrip"

81 (assert-equal "1.0.0-alpha.1" (version->string (parse-version "1.0.0-alpha.1"))))

83 (test "build roundtrip"

84 (assert-equal "1.0.0+build.42" (version->string (parse-version "1.0.0+build.42"))))

86 (test "combined roundtrip"

87 (assert-equal "1.0.0-beta+exp.sha"

88 (version->string (parse-version "1.0.0-beta+exp.sha")))))

90;; ============================================================

91;; Comparison

92;; ============================================================

94(test-group "version comparison"

95 (test "equal versions"

96 (assert-true (version=? (parse-version "1.0.0") (parse-version "1.0.0"))))

98 (test "less than by major"

99 (assert-true (version<? (parse-version "1.0.0") (parse-version "2.0.0"))))

100

101 (test "less than by minor"

102 (assert-true (version<? (parse-version "1.0.0") (parse-version "1.1.0"))))

103

104 (test "less than by patch"

105 (assert-true (version<? (parse-version "1.0.0") (parse-version "1.0.1"))))

106

107 (test "greater than"

108 (assert-true (version>? (parse-version "2.0.0") (parse-version "1.0.0"))))

109

110 (test "less than or equal"

111 (assert-true (version<=? (parse-version "1.0.0") (parse-version "1.0.0")))

112 (assert-true (version<=? (parse-version "1.0.0") (parse-version "1.0.1"))))

113

114 (test "greater than or equal"

115 (assert-true (version>=? (parse-version "1.0.0") (parse-version "1.0.0")))

116 (assert-true (version>=? (parse-version "1.0.1") (parse-version "1.0.0"))))

117

118 (test "build metadata ignored in comparison"

119 (assert-true (version=? (parse-version "1.0.0+build1")

120 (parse-version "1.0.0+build2")))))

121

122;; ============================================================

123;; Prerelease ordering

124;; ============================================================

125

126(test-group "prerelease ordering"

127 (test "alpha < alpha.1"

128 (assert-true (version<? (parse-version "1.0.0-alpha")

129 (parse-version "1.0.0-alpha.1"))))

130

131 (test "alpha.1 < beta"

132 (assert-true (version<? (parse-version "1.0.0-alpha.1")

133 (parse-version "1.0.0-beta"))))

134

135 (test "prerelease < release"

136 (assert-true (version<? (parse-version "1.0.0-beta")

137 (parse-version "1.0.0"))))

138

139 (test "numeric ids sort before string ids"

140 (assert-true (version<? (parse-version "1.0.0-1")

141 (parse-version "1.0.0-alpha")))))

142

143;; ============================================================

144;; Constraints

145;; ============================================================

146

147(test-group "parse-constraint"

148 (test "wildcard"

149 (assert-equal '(any) (parse-constraint "*")))

150

151 (test "exact (no operator)"

152 (let ((c (parse-constraint "1.2.3")))

153 (assert-equal '= (car c))))

154

155 (test "exact with ="

156 (let ((c (parse-constraint "= 1.2.3")))

157 (assert-equal '= (car c))))

158

159 (test "greater than"

160 (let ((c (parse-constraint "> 1.0.0")))

161 (assert-equal '> (car c))))

162

163 (test "greater than or equal"

164 (let ((c (parse-constraint ">= 1.0.0")))

165 (assert-equal '>= (car c))))

166

167 (test "less than"

168 (let ((c (parse-constraint "< 2.0.0")))

169 (assert-equal '< (car c))))

170

171 (test "less than or equal"

172 (let ((c (parse-constraint "<= 2.0.0")))

173 (assert-equal '<= (car c))))

174

175 (test "caret"

176 (let ((c (parse-constraint "^1.2.3")))

177 (assert-equal 'caret (car c))))

178

179 (test "tilde"

180 (let ((c (parse-constraint "~1.2.3")))

181 (assert-equal 'tilde (car c))))

182

183 (test "invalid constraint"

184 (assert-false (parse-constraint "not-a-version"))))

185

186(test-group "version-satisfies?"

187 (test "wildcard matches anything"

188 (assert-true (version-satisfies? (parse-version "5.0.0") "*")))

189

190 (test "exact match"

191 (assert-true (version-satisfies? (parse-version "1.2.3") "= 1.2.3"))

192 (assert-false (version-satisfies? (parse-version "1.2.4") "= 1.2.3")))

193

194 (test "greater than"

195 (assert-true (version-satisfies? (parse-version "2.0.0") "> 1.0.0"))

196 (assert-false (version-satisfies? (parse-version "1.0.0") "> 1.0.0")))

197

198 (test "greater than or equal"

199 (assert-true (version-satisfies? (parse-version "1.0.0") ">= 1.0.0"))

200 (assert-true (version-satisfies? (parse-version "2.0.0") ">= 1.0.0")))

201

202 (test "less than"

203 (assert-true (version-satisfies? (parse-version "0.9.0") "< 1.0.0"))

204 (assert-false (version-satisfies? (parse-version "1.0.0") "< 1.0.0")))

205

206 (test "less than or equal"

207 (assert-true (version-satisfies? (parse-version "1.0.0") "<= 1.0.0"))

208 (assert-true (version-satisfies? (parse-version "0.5.0") "<= 1.0.0"))))

209

210(test-group "caret constraints"

211 (test "^1.2.3 allows same major"

212 (assert-true (version-satisfies? (parse-version "1.5.0") "^1.2.3"))

213 (assert-false (version-satisfies? (parse-version "2.0.0") "^1.2.3")))

214

215 (test "^1.2.3 requires >= base"

216 (assert-false (version-satisfies? (parse-version "1.2.2") "^1.2.3")))

217

218 (test "^0.2.0 pins minor for 0.x"

219 (assert-true (version-satisfies? (parse-version "0.2.5") "^0.2.0"))

220 (assert-false (version-satisfies? (parse-version "0.3.0") "^0.2.0")))

221

222 (test "^0.0.3 pins patch for 0.0.x"

223 (assert-true (version-satisfies? (parse-version "0.0.3") "^0.0.3"))

224 (assert-false (version-satisfies? (parse-version "0.0.4") "^0.0.3"))))

225

226(test-group "tilde constraints"

227 (test "~1.2.3 allows same major.minor"

228 (assert-true (version-satisfies? (parse-version "1.2.5") "~1.2.3"))

229 (assert-false (version-satisfies? (parse-version "1.3.0") "~1.2.3")))

230

231 (test "~1.2.3 requires >= base"

232 (assert-false (version-satisfies? (parse-version "1.2.2") "~1.2.3"))))

233

234;; ============================================================

235;; Bump utilities

236;; ============================================================

237

238(test-group "version bumping"

239 (test "bump major resets minor and patch"

240 (let ((v (version-bump-major (parse-version "1.2.3"))))

241 (assert-equal "2.0.0" (version->string v))))

242

243 (test "bump minor resets patch"

244 (let ((v (version-bump-minor (parse-version "1.2.3"))))

245 (assert-equal "1.3.0" (version->string v))))

246

247 (test "bump patch"

248 (let ((v (version-bump-patch (parse-version "1.2.3"))))

249 (assert-equal "1.2.4" (version->string v)))))

250

251;; ============================================================

252;; version-compatible?

253;; ============================================================

254

255(test-group "version-compatible?"

256 (test "same major, higher version is compatible"

257 (assert-true (version-compatible? (parse-version "1.5.0")

258 (parse-version "1.2.0"))))

259

260 (test "different major is not compatible"

261 (assert-false (version-compatible? (parse-version "2.0.0")

262 (parse-version "1.2.0"))))

263

264 (test "lower version is not compatible"

265 (assert-false (version-compatible? (parse-version "1.1.0")

266 (parse-version "1.2.0")))))

267

268;; ============================================================

269;; string->version alias

270;; ============================================================

271

272(test-group "string->version"

273 (test "string->version is same as parse-version"

274 (let ((v (string->version "1.2.3")))

275 (assert-true (version? v))

276 (assert-equal 1 (version-major v))

277 (assert-equal 2 (version-minor v))

278 (assert-equal 3 (version-patch v)))))

279

280(run-tests)