projects/guix·blob version-1.4.0 · refs

483 lines · 15.7 KiB

1;;; GNU Guix --- Functional package management for GNU
2;;; Copyright © 2017 Christopher Baines <[email protected]>
3;;; Copyright © 2020, 2022 Marius Bakke <[email protected]>
4;;;
5;;; This file is part of GNU Guix.
6;;;
7;;; GNU Guix is free software; you can redistribute it and/or modify it
8;;; under the terms of the GNU General Public License as published by
9;;; the Free Software Foundation; either version 3 of the License, or (at
10;;; your option) any later version.
11;;;
12;;; GNU Guix is distributed in the hope that it will be useful, but
13;;; WITHOUT ANY WARRANTY; without even the implied warranty of
14;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15;;; GNU General Public License for more details.
16;;;
17;;; You should have received a copy of the GNU General Public License
18;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
19
20(define-module (gnu tests databases)
21 #:use-module (gnu tests)
22 #:use-module (gnu system)
23 #:use-module (gnu system file-systems)
24 #:use-module (gnu system shadow)
25 #:use-module (gnu system vm)
26 #:use-module (gnu services)
27 #:use-module (gnu services databases)
28 #:use-module (gnu services networking)
29 #:use-module (gnu packages databases)
30 #:use-module (guix gexp)
31 #:use-module (guix store)
32 #:use-module (srfi srfi-1)
33 #:export (%test-memcached
34 %test-postgresql
35 %test-timescaledb
36 %test-mysql))
37
38;;;
39;;; The Memcached service.
40;;;
41
42(define %memcached-os
43 (simple-operating-system
44 (service dhcp-client-service-type)
45 (service memcached-service-type)))
46
47(define* (run-memcached-test #:optional (port 11211))
48 "Run tests in %MEMCACHED-OS, forwarding PORT."
49 (define os
50 (marionette-operating-system
51 %memcached-os
52 #:imported-modules '((gnu services herd)
53 (guix combinators))))
54
55 (define vm
56 (virtual-machine
57 (operating-system os)
58 (port-forwardings `((11211 . ,port)))))
59
60 (define test
61 (with-imported-modules '((gnu build marionette))
62 #~(begin
63 (use-modules (srfi srfi-11) (srfi srfi-64)
64 (gnu build marionette)
65 (ice-9 rdelim))
66
67 (define marionette
68 (make-marionette (list #$vm)))
69
70 (test-runner-current (system-test-runner #$output))
71 (test-begin "memcached")
72
73 ;; Wait for memcached to be up and running.
74 (test-assert "service running"
75 (marionette-eval
76 '(begin
77 (use-modules (gnu services herd))
78 (match (start-service 'memcached)
79 (#f #f)
80 (('service response-parts ...)
81 (match (assq-ref response-parts 'running)
82 ((pid) (number? pid))))))
83 marionette))
84
85 (let* ((ai (car (getaddrinfo "localhost"
86 #$(number->string port))))
87 (s (socket (addrinfo:fam ai)
88 (addrinfo:socktype ai)
89 (addrinfo:protocol ai)))
90 (key "testkey")
91 (value "guix"))
92 (connect s (addrinfo:addr ai))
93
94 (test-equal "set"
95 "STORED\r"
96 (begin
97 (simple-format s "set ~A 0 60 ~A\r\n~A\r\n"
98 key
99 (string-length value)
100 value)
101 (read-line s)))
102
103 (test-equal "get"
104 (simple-format #f "VALUE ~A 0 ~A\r~A\r"
105 key
106 (string-length value)
107 value)
108 (begin
109 (simple-format s "get ~A\r\n" key)
110 (string-append
111 (read-line s)
112 (read-line s))))
113
114 (close-port s))
115
116 ;; There should be a log file in here.
117 (test-assert "log file"
118 (marionette-eval
119 '(file-exists? "/var/log/memcached")
120 marionette))
121
122 (test-end))))
123
124 (gexp->derivation "memcached-test" test))
125
126(define %test-memcached
127 (system-test
128 (name "memcached")
129 (description "Connect to a running MEMCACHED server.")
130 (value (run-memcached-test))))
131
132
133;;;
134;;; The PostgreSQL service.
135;;;
136
137(define %postgresql-log-directory
138 "/var/log/postgresql")
139
140(define %role-log-file
141 "/var/log/postgresql_roles.log")
142
143(define %postgresql-os
144 (simple-operating-system
145 (service postgresql-service-type
146 (postgresql-configuration
147 (postgresql postgresql)
148 (config-file
149 (postgresql-config-file
150 (extra-config
151 '(("session_preload_libraries" "auto_explain")
152 ("random_page_cost" 2)
153 ("auto_explain.log_min_duration" "100 ms")
154 ("work_mem" "500 MB")
155 ("debug_print_plan" #t)))))))
156 (service postgresql-role-service-type
157 (postgresql-role-configuration
158 (roles
159 (list (postgresql-role
160 (name "root")
161 (create-database? #t))))))))
162
163(define (run-postgresql-test)
164 "Run tests in %POSTGRESQL-OS."
165 (define os
166 (marionette-operating-system
167 %postgresql-os
168 #:imported-modules '((gnu services herd)
169 (guix combinators))))
170
171 (define vm
172 (virtual-machine
173 (operating-system os)
174 (memory-size 512)))
175
176 (define test
177 (with-imported-modules '((gnu build marionette))
178 #~(begin
179 (use-modules (srfi srfi-64)
180 (gnu build marionette))
181
182 (define marionette
183 (make-marionette (list #$vm)))
184
185 (test-runner-current (system-test-runner #$output))
186 (test-begin "postgresql")
187
188 (test-assert "service running"
189 (marionette-eval
190 '(begin
191 (use-modules (gnu services herd))
192 (start-service 'postgres))
193 marionette))
194
195 (test-assert "log-file"
196 (marionette-eval
197 '(begin
198 (use-modules (ice-9 ftw)
199 (ice-9 match))
200 (current-output-port
201 (open-file "/dev/console" "w0"))
202 (let ((server-log-file
203 (string-append #$%postgresql-log-directory
204 "/pg_ctl.log")))
205 (and (file-exists? server-log-file)
206 (display
207 (call-with-input-file server-log-file
208 get-string-all)))
209 #t))
210 marionette))
211
212 (test-assert "database ready"
213 (begin
214 (marionette-eval
215 '(begin
216 (let loop ((i 10))
217 (unless (or (zero? i)
218 (and (file-exists? #$%role-log-file)
219 (string-contains
220 (call-with-input-file #$%role-log-file
221 get-string-all)
222 ";\nCREATE DATABASE")))
223 (sleep 1)
224 (loop (- i 1)))))
225 marionette)))
226
227 (test-assert "database creation"
228 (marionette-eval
229 '(begin
230 (use-modules (gnu services herd)
231 (ice-9 popen))
232 (current-output-port
233 (open-file "/dev/console" "w0"))
234 (let* ((port (open-pipe*
235 OPEN_READ
236 #$(file-append postgresql "/bin/psql")
237 "-tA" "-c" "SELECT 1 FROM pg_database WHERE
238 datname='root'"))
239 (output (get-string-all port)))
240 (close-pipe port)
241 (string-contains output "1")))
242 marionette))
243
244 (test-end))))
245
246 (gexp->derivation "postgresql-test" test))
247
248(define %test-postgresql
249 (system-test
250 (name "postgresql")
251 (description "Start the PostgreSQL service.")
252 (value (run-postgresql-test))))
253
254;; Test TimescaleDB, a PostgreSQL extension.
255(define %timescaledb-os
256 (let* ((postgresql-services (operating-system-services %postgresql-os))
257 (postgresql-service-configuration
258 (service-value (find (lambda (svc)
259 (eq? (service-kind svc) postgresql-service-type))
260 postgresql-services)))
261 (postgresql-role-service-configuration
262 (service-value (find (lambda (svc)
263 (eq? (service-kind svc)
264 postgresql-role-service-type))
265 postgresql-services))))
266 (simple-operating-system
267 (service postgresql-service-type
268 (postgresql-configuration
269 (inherit postgresql-service-configuration)
270 (extension-packages (list timescaledb))
271 (config-file
272 (postgresql-config-file
273 (inherit (postgresql-configuration-file
274 postgresql-service-configuration))
275 (extra-config
276 (append '(("shared_preload_libraries" "timescaledb"))
277 (postgresql-config-file-extra-config
278 (postgresql-configuration-file
279 postgresql-service-configuration))))))))
280 (service postgresql-role-service-type
281 (postgresql-role-configuration
282 (inherit postgresql-role-service-configuration))))))
283
284(define (run-timescaledb-test)
285 "Run tests in %TIMESCALEDB-OS."
286 (define os
287 (marionette-operating-system
288 %timescaledb-os
289 #:imported-modules '((gnu services herd)
290 (guix combinators))))
291
292 (define vm
293 (virtual-machine
294 (operating-system os)
295 (memory-size 512)))
296
297 (define test
298 (with-imported-modules '((gnu build marionette))
299 #~(begin
300 (use-modules (srfi srfi-64)
301 (gnu build marionette))
302
303 (define marionette
304 (make-marionette (list #$vm)))
305
306 (test-runner-current (system-test-runner #$output))
307 (test-begin "timescaledb")
308
309 (test-assert "PostgreSQL running"
310 (marionette-eval
311 '(begin
312 (use-modules (gnu services herd))
313 (start-service 'postgres))
314 marionette))
315
316 (test-assert "database ready"
317 (begin
318 (marionette-eval
319 '(begin
320 (let loop ((i 10))
321 (unless (or (zero? i)
322 (and (file-exists? #$%role-log-file)
323 (string-contains
324 (call-with-input-file #$%role-log-file
325 get-string-all)
326 ";\nCREATE DATABASE")))
327 (sleep 1)
328 (loop (- i 1)))))
329 marionette)))
330
331 (test-assert "database creation"
332 (marionette-eval
333 '(begin
334 (current-output-port
335 (open-file "/dev/console" "w0"))
336 (invoke #$(file-append postgresql "/bin/psql")
337 "-tA" "-c" "CREATE DATABASE test"))
338 marionette))
339
340 (test-assert "load extension"
341 (marionette-eval
342 '(begin
343 (current-output-port (open-file "/dev/console" "w0"))
344 ;; Capture stderr for the next test.
345 (current-error-port (open-file "timescaledb.stderr" "w0"))
346 (invoke #$(file-append postgresql "/bin/psql")
347 "-tA" "-c" "CREATE EXTENSION timescaledb"
348 "test"))
349 marionette))
350
351 (test-assert "telemetry is disabled"
352 (marionette-eval
353 '(begin
354 (string-contains (call-with-input-file "timescaledb.stderr"
355 (lambda (port)
356 (get-string-all port)))
357 "Please enable telemetry"))
358 marionette))
359
360 (test-assert "create hypertable"
361 (marionette-eval
362 '(begin
363 (current-output-port (open-file "/dev/console" "w0"))
364 (invoke #$(file-append postgresql "/bin/psql")
365 "-tA" "-c" "CREATE TABLE ht (
366time TIMESTAMP NOT NULL,
367data double PRECISION NULL
368)"
369 "test")
370 (invoke #$(file-append postgresql "/bin/psql")
371 "-tA" "-c" "SELECT create_hypertable('ht','time')"
372 "test"))
373 marionette))
374
375 (test-end))))
376
377 (gexp->derivation "timescaledb-test" test))
378
379(define %test-timescaledb
380 (system-test
381 (name "timescaledb")
382 (description "Test the TimescaleDB PostgreSQL extension.")
383 (value (run-timescaledb-test))))
384
385
386;;;
387;;; The MySQL service.
388;;;
389
390(define %mysql-os
391 (simple-operating-system
392 (service mysql-service-type)))
393
394(define* (run-mysql-test)
395 "Run tests in %MYSQL-OS."
396 (define os
397 (marionette-operating-system
398 %mysql-os
399 #:imported-modules '((gnu services herd)
400 (guix combinators))))
401
402 (define vm
403 (virtual-machine
404 (operating-system os)
405 (memory-size 512)))
406
407 (define test
408 (with-imported-modules '((gnu build marionette))
409 #~(begin
410 (use-modules (srfi srfi-11) (srfi srfi-64)
411 (gnu build marionette))
412
413 (define marionette
414 (make-marionette (list #$vm)))
415
416 (test-runner-current (system-test-runner #$output))
417 (test-begin "mysql")
418
419 (test-assert "service running"
420 (marionette-eval
421 '(begin
422 (use-modules (gnu services herd))
423 (match (start-service 'mysql)
424 (#f #f)
425 (('service response-parts ...)
426 (match (assq-ref response-parts 'running)
427 ((pid) (number? pid))))))
428 marionette))
429
430 (test-assert "mysql_upgrade completed"
431 (wait-for-file "/var/lib/mysql/mysql_upgrade_info" marionette))
432
433 (test-assert "socket is ready"
434 (wait-for-unix-socket "/run/mysqld/mysqld.sock" marionette))
435
436 (test-eq "create database"
437 0
438 (marionette-eval
439 '(begin
440 (system* #$(file-append mariadb "/bin/mysql")
441 "-e" "CREATE DATABASE guix;"))
442 marionette))
443
444 (test-eq "create table"
445 0
446 (marionette-eval
447 '(begin
448 (system*
449 #$(file-append mariadb "/bin/mysql") "guix"
450 "-e" "CREATE TABLE facts (id INT, data VARCHAR(12));"))
451 marionette))
452
453 (test-eq "insert data"
454 0
455 (marionette-eval
456 '(begin
457 (system* #$(file-append mariadb "/bin/mysql") "guix"
458 "-e" "INSERT INTO facts VALUES (1, 'awesome')"))
459 marionette))
460
461 (test-equal "retrieve data"
462 "awesome\n"
463 (marionette-eval
464 '(begin
465 (use-modules (ice-9 popen))
466 (let* ((port (open-pipe*
467 OPEN_READ
468 #$(file-append mariadb "/bin/mysql") "guix"
469 "-NB" "-e" "SELECT data FROM facts WHERE id=1;"))
470 (output (get-string-all port)))
471 (close-pipe port)
472 output))
473 marionette))
474
475 (test-end))))
476
477 (gexp->derivation "mysql-test" test))
478
479(define %test-mysql
480 (system-test
481 (name "mysql")
482 (description "Start the MySQL service.")
483 (value (run-mysql-test))))