(define-module (rodion tests services)
  #:use-module (gnu tests)
  #:use-module (gnu system)
  #:use-module (gnu system vm)
  #:use-module (gnu services)
  #:use-module (gnu services networking)
  #:use-module (gnu services databases)
  #:use-module (gnu packages databases)
  #:use-module (guix monads)
  #:use-module (guix store)
  #:use-module (guix profiles)
  #:use-module (rodion services miniflux)
  #:use-module (guix gexp))

(define retry-on-error
  #~(lambda* (f #:key times delay)
      (let loop ((attempt 1))
        (match (catch
                 #t
                 (lambda ()
                   (cons #t
                         (f)))
                 (lambda args
                   (cons #f
                         args)))
          ((#t . return-value)
           return-value)
          ((#f . error-args)
           (if (>= attempt times)
               error-args
               (begin
                 (sleep delay)
                 (loop (+ 1 attempt)))))))))

(define %miniflux-os
  (simple-operating-system
   (service dhcp-client-service-type)
   (service postgresql-service-type
	    (postgresql-configuration
	     (postgresql postgresql-15)))
   (service miniflux-service-type
	    (miniflux-configuration
	     (listen-addr "0.0.0.0:8080")))))

(define* (run-miniflux-test name test-os)
  (define os
    (marionette-operating-system
     test-os
     #:imported-modules '((gnu services herd)
                          (guix combinators))))

  (define forwarded-port 8080)

  (define vm
    (virtual-machine
     (operating-system os)
     (memory-size 512)
     (port-forwardings `((8080 . ,forwarded-port)))))

  (define test
    (with-imported-modules '((gnu build marionette))
      #~(begin
          (use-modules (srfi srfi-64)
		       (srfi srfi-11)
                       (gnu build marionette)
		       (web client)
		       (web uri)
                       (web response)
		       (ice-9 match))

          (define marionette
            (make-marionette (list #$vm)))

          (test-runner-current (system-test-runner #$output))
          (test-begin #$name)

          (test-assert #$(string-append name " service running")
            (marionette-eval
             '(begin
                (use-modules (gnu services herd))
                (match (start-service '#$(string->symbol name))
                  (#f #f)
                  (('service response-parts ...)
                   (match (assq-ref response-parts 'running)
                     ((#t) #t)
                     ((pid) (number? pid))))))
             marionette))

          (test-assert "Miniflux TCP port ready, IPv4"
            (wait-for-tcp-port #$forwarded-port marionette))

	  (test-assert "Miniflux login page is opened"
            (begin
              (wait-for-tcp-port #$forwarded-port marionette)
              (#$retry-on-error
               (lambda ()
                 (let-values (((response text)
                               (http-get
				#$(format #f "http://localhost:~A/" forwarded-port)
				#:decode-body? #t)))
                   (string-contains text "<title>Sign In - Miniflux</title>")))
               #:times 10
               #:delay 5)))
	  
          (test-end))))
  (gexp->derivation "miniflux-test" test))

(define %test-miniflux
  (system-test
   (name "miniflux")
   (description "Connect to a running Miniflux service.")
   (value (run-miniflux-test name %miniflux-os))))

(define (system-test->manifest-entry test)
  "Return a manifest entry for TEST, a system test."
  (manifest-entry
    (name (string-append "test." (system-test-name test)))
    (version "0")
    (item test)))

(manifest (map system-test->manifest-entry (list %test-miniflux)))