From 907c98acbbf533715983c61a1e53cb29a52c4bef Mon Sep 17 00:00:00 2001
From: Ludovic Courtès <ludo@gnu.org>
Date: Mon, 29 Dec 2014 20:39:58 +0100
Subject: lint: Add tests for the 'home-page' checker.

Suggested by Cyril Roelandt <tipecaml@gmail.com>.

* tests/lint.scm (%http-server-port, %http-server-socket, %local-url,
  stub-http-server): New variables.
  (http-write, call-with-http-server): New procedures.
  (with-http-server): New macro.
  ("home-page: wrong home-page", "home-page: invalid URI", "home-page:
  host not found", "home-page: Connection refused", "home-page: 200",
  "home-page: 404"): New tests.
* guix/scripts/lint.scm (check-home-page): Export.
---
 tests/lint.scm | 147 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 146 insertions(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/lint.scm b/tests/lint.scm
index e77d443264..8ae129d9fe 100644
--- a/tests/lint.scm
+++ b/tests/lint.scm
@@ -26,10 +26,82 @@
   #:use-module (guix ui)
   #:use-module (gnu packages)
   #:use-module (gnu packages pkg-config)
+  #:use-module (web server)
+  #:use-module (web server http)
+  #:use-module (web response)
+  #:use-module (ice-9 threads)
+  #:use-module (srfi srfi-9 gnu)
   #:use-module (srfi srfi-64))
 
 ;; Test the linter.
 
+(define %http-server-port
+  ;; TCP port to use for the stub HTTP server.
+  9999)
+
+(define %local-url
+  ;; URL to use for 'home-page' tests.
+  (string-append "http://localhost:" (number->string %http-server-port)
+                 "/foo/bar"))
+
+(define %http-server-socket
+  ;; Socket used by the Web server.
+  (catch 'system-error
+    (lambda ()
+      (let ((sock (socket PF_INET SOCK_STREAM 0)))
+        (setsockopt sock SOL_SOCKET SO_REUSEADDR 1)
+        (bind sock
+              (make-socket-address AF_INET INADDR_LOOPBACK
+                                   %http-server-port))
+        sock))
+    (lambda args
+      (let ((err (system-error-errno args)))
+        (format (current-error-port)
+                "warning: cannot run Web server for tests: ~a~%"
+                (strerror err))
+        #f))))
+
+(define (http-write server client response body)
+  "Write RESPONSE."
+  (let* ((response (write-response response client))
+         (port     (response-port response)))
+    (cond
+     ((not body))                                 ;pass
+     (else
+      (write-response-body response body)))
+    (close-port port)
+    (quit #t)                                     ;exit the server thread
+    (values)))
+
+(define-server-impl stub-http-server
+  ;; Stripped-down version of Guile's built-in HTTP server.
+  (@@ (web server http) http-open)
+  (@@ (web server http) http-read)
+  http-write
+  (@@ (web server http) http-close))
+
+(define (call-with-http-server code thunk)
+  "Call THUNK with an HTTP server running and returning CODE on HTTP
+requests."
+  (define (server-body)
+    (define (handle request body)
+      (values (build-response #:code code
+                              #:reason-phrase "Such is life")
+              "Hello, world."))
+
+    (catch 'quit
+      (lambda ()
+        (run-server handle stub-http-server
+                    `(#:socket ,%http-server-socket)))
+      (const #t)))
+
+  (let* ((server (make-thread server-body)))
+    ;; Normally SERVER exits automatically once it has received a request.
+    (thunk)))
+
+(define-syntax-rule (with-http-server code body ...)
+  (call-with-http-server code (lambda () body ...)))
+
 
 (test-begin "lint")
 
@@ -235,9 +307,82 @@
                         (sha256 "somesha")
                         (patches (list "/path/to/y.patch")))))))
               (check-patches pkg))))
-         "file names of patches should start with the package name")))
+     "file names of patches should start with the package name")))
+
+(test-assert "home-page: wrong home-page"
+  (->bool
+   (string-contains
+    (call-with-warnings
+     (lambda ()
+       (let ((pkg (package
+                    (inherit (dummy-package "x"))
+                    (home-page #f))))
+         (check-home-page pkg))))
+    "invalid")))
+
+(test-assert "home-page: invalid URI"
+  (->bool
+   (string-contains
+    (call-with-warnings
+     (lambda ()
+       (let ((pkg (package
+                    (inherit (dummy-package "x"))
+                    (home-page "foobar"))))
+         (check-home-page pkg))))
+    "invalid home page URL")))
+
+(test-assert "home-page: host not found"
+  (->bool
+   (string-contains
+    (call-with-warnings
+     (lambda ()
+       (let ((pkg (package
+                    (inherit (dummy-package "x"))
+                    (home-page "http://does-not-exist"))))
+         (check-home-page pkg))))
+    "domain not found")))
+
+(test-skip (if %http-server-socket 0 1))
+(test-assert "home-page: Connection refused"
+  (->bool
+   (string-contains
+    (call-with-warnings
+     (lambda ()
+       (let ((pkg (package
+                    (inherit (dummy-package "x"))
+                    (home-page %local-url))))
+         (check-home-page pkg))))
+    "Connection refused")))
+
+(test-skip (if %http-server-socket 0 1))
+(test-equal "home-page: 200"
+  ""
+  (call-with-warnings
+   (lambda ()
+     (with-http-server 200
+       (let ((pkg (package
+                    (inherit (dummy-package "x"))
+                    (home-page %local-url))))
+         (check-home-page pkg))))))
+
+(test-skip (if %http-server-socket 0 1))
+(test-assert "home-page: 404"
+  (->bool
+   (string-contains
+    (call-with-warnings
+     (lambda ()
+       (with-http-server 404
+         (let ((pkg (package
+                      (inherit (dummy-package "x"))
+                      (home-page %local-url))))
+           (check-home-page pkg)))))
+    "not reachable: 404")))
 
 (test-end "lint")
 
 
 (exit (= (test-runner-fail-count (test-runner-current)) 0))
+
+;; Local Variables:
+;; eval: (put 'with-http-server 'scheme-indent-function 1)
+;; End:
-- 
cgit v1.2.3


From 8b385969cf30c6646ec3cf78f1ee69e03029b7a1 Mon Sep 17 00:00:00 2001
From: Ludovic Courtès <ludo@gnu.org>
Date: Mon, 29 Dec 2014 19:11:09 +0100
Subject: tests: Factorize the 'dummy-package' macro.

* guix/tests.scm (dummy-package): New macro.
* tests/lint.scm (dummy-package): Remove.
* tests/packages.scm (dummy-package): Remove.
---
 guix/tests.scm     | 12 +++++++++++-
 tests/lint.scm     |  7 +------
 tests/packages.scm |  7 -------
 3 files changed, 12 insertions(+), 14 deletions(-)

(limited to 'tests')

diff --git a/guix/tests.scm b/guix/tests.scm
index 022679902a..82ae7e2084 100644
--- a/guix/tests.scm
+++ b/guix/tests.scm
@@ -27,7 +27,8 @@
   #:export (open-connection-for-tests
             random-text
             random-bytevector
-            with-derivation-narinfo))
+            with-derivation-narinfo
+            dummy-package))
 
 ;;; Commentary:
 ;;;
@@ -120,6 +121,15 @@ substituter's viewpoint."
     (lambda ()
       body ...)))
 
+(define-syntax-rule (dummy-package name* extra-fields ...)
+  "Return a \"dummy\" package called NAME*, with all its compulsory fields
+initialized with default values, and with EXTRA-FIELDS set as specified."
+  (package extra-fields ...
+           (name name*) (version "0") (source #f)
+           (build-system gnu-build-system)
+           (synopsis #f) (description #f)
+           (home-page #f) (license #f)))
+
 ;; Local Variables:
 ;; eval: (put 'call-with-derivation-narinfo 'scheme-indent-function 1)
 ;; End:
diff --git a/tests/lint.scm b/tests/lint.scm
index 8ae129d9fe..e7e548b626 100644
--- a/tests/lint.scm
+++ b/tests/lint.scm
@@ -19,6 +19,7 @@
 
 
 (define-module (test-packages)
+  #:use-module (guix tests)
   #:use-module (guix build download)
   #:use-module (guix build-system gnu)
   #:use-module (guix packages)
@@ -105,12 +106,6 @@ requests."
 
 (test-begin "lint")
 
-(define-syntax-rule (dummy-package name* extra-fields ...)
-  (package extra-fields ... (name name*) (version "0") (source #f)
-           (build-system gnu-build-system)
-           (synopsis #f) (description #f)
-           (home-page #f) (license #f) ))
-
 (define (call-with-warnings thunk)
   (let ((port (open-output-string)))
     (parameterize ((guix-warning-port port))
diff --git a/tests/packages.scm b/tests/packages.scm
index 98fa9b5698..f7d6155ecc 100644
--- a/tests/packages.scm
+++ b/tests/packages.scm
@@ -48,13 +48,6 @@
 (define %store
   (open-connection-for-tests))
 
-(define-syntax-rule (dummy-package name* extra-fields ...)
-  (package (name name*) (version "0") (source #f)
-           (build-system gnu-build-system)
-           (synopsis #f) (description #f)
-           (home-page #f) (license #f)
-           extra-fields ...))
-
 
 (test-begin "packages")
 
-- 
cgit v1.2.3


From 4fbf4ca552b4e1f68e1d0a84b334319d5152cc38 Mon Sep 17 00:00:00 2001
From: Ludovic Courtès <ludo@gnu.org>
Date: Mon, 29 Dec 2014 20:44:10 +0100
Subject: tests: Make the 'lint' tests slightly more concise.

* tests/lint.scm (with-warnings): New macro.
  Replace all uses of 'call-with-warnings' with the corresponding
  'with-warnings' form.
---
 tests/lint.scm | 281 ++++++++++++++++++++++++++-------------------------------
 1 file changed, 129 insertions(+), 152 deletions(-)

(limited to 'tests')

diff --git a/tests/lint.scm b/tests/lint.scm
index e7e548b626..2aebbffd0a 100644
--- a/tests/lint.scm
+++ b/tests/lint.scm
@@ -112,265 +112,241 @@ requests."
       (thunk))
     (get-output-string port)))
 
+(define-syntax-rule (with-warnings body ...)
+  (call-with-warnings (lambda () body ...)))
+
 (test-assert "description: not empty"
   (->bool
-   (string-contains (call-with-warnings
-                      (lambda ()
-                        (let ((pkg (dummy-package "x"
-                                     (description ""))))
-                          (check-description-style pkg))))
+   (string-contains (with-warnings
+                      (let ((pkg (dummy-package "x"
+                                   (description ""))))
+                        (check-description-style pkg)))
                     "description should not be empty")))
 
 (test-assert "description: does not start with an upper-case letter"
   (->bool
-   (string-contains (call-with-warnings
-                      (lambda ()
-                        (let ((pkg (dummy-package "x"
-                                     (description "bad description."))))
-                          (check-description-style pkg))))
+   (string-contains (with-warnings
+                      (let ((pkg (dummy-package "x"
+                                   (description "bad description."))))
+                        (check-description-style pkg)))
                     "description should start with an upper-case letter")))
 
 (test-assert "description: may start with a digit"
   (string-null?
-   (call-with-warnings
-    (lambda ()
-      (let ((pkg (dummy-package "x"
-                                (description "2-component library."))))
-        (check-description-style pkg))))))
+   (with-warnings
+     (let ((pkg (dummy-package "x"
+                  (description "2-component library."))))
+       (check-description-style pkg)))))
 
 (test-assert "description: may start with lower-case package name"
   (string-null?
-   (call-with-warnings
-    (lambda ()
-      (let ((pkg (dummy-package "x"
-                   (description "x is a dummy package."))))
-        (check-description-style pkg))))))
+   (with-warnings
+     (let ((pkg (dummy-package "x"
+                  (description "x is a dummy package."))))
+       (check-description-style pkg)))))
 
 (test-assert "description: two spaces after end of sentence"
   (->bool
-   (string-contains (call-with-warnings
-                      (lambda ()
-                        (let ((pkg (dummy-package "x"
-                                     (description "Bad. Quite bad."))))
-                          (check-description-style pkg))))
+   (string-contains (with-warnings
+                      (let ((pkg (dummy-package "x"
+                                   (description "Bad. Quite bad."))))
+                        (check-description-style pkg)))
                     "sentences in description should be followed by two spaces")))
 
 (test-assert "description: end-of-sentence detection with abbreviations"
   (string-null?
-   (call-with-warnings
-    (lambda ()
-      (let ((pkg (dummy-package "x"
-                   (description
-                    "E.g. Foo, i.e. Bar resp. Baz (a.k.a. DVD)."))))
-        (check-description-style pkg))))))
+   (with-warnings
+     (let ((pkg (dummy-package "x"
+                  (description
+                   "E.g. Foo, i.e. Bar resp. Baz (a.k.a. DVD)."))))
+       (check-description-style pkg)))))
 
 (test-assert "synopsis: not empty"
   (->bool
-   (string-contains (call-with-warnings
-                      (lambda ()
-                        (let ((pkg (dummy-package "x"
-                                     (synopsis ""))))
-                          (check-synopsis-style pkg))))
+   (string-contains (with-warnings
+                      (let ((pkg (dummy-package "x"
+                                   (synopsis ""))))
+                        (check-synopsis-style pkg)))
                     "synopsis should not be empty")))
 
 (test-assert "synopsis: does not start with an upper-case letter"
   (->bool
-   (string-contains (call-with-warnings
-                      (lambda ()
-                        (let ((pkg (dummy-package "x"
-                                     (synopsis "bad synopsis."))))
-                          (check-synopsis-style pkg))))
+   (string-contains (with-warnings
+                      (let ((pkg (dummy-package "x"
+                                   (synopsis "bad synopsis."))))
+                        (check-synopsis-style pkg)))
                     "synopsis should start with an upper-case letter")))
 
 (test-assert "synopsis: may start with a digit"
   (string-null?
-   (call-with-warnings
-    (lambda ()
-      (let ((pkg (dummy-package "x"
-                   (synopsis "5-dimensional frobnicator"))))
-        (check-synopsis-style pkg))))))
+   (with-warnings
+     (let ((pkg (dummy-package "x"
+                  (synopsis "5-dimensional frobnicator"))))
+       (check-synopsis-style pkg)))))
 
 (test-assert "synopsis: ends with a period"
   (->bool
-   (string-contains (call-with-warnings
-                      (lambda ()
-                        (let ((pkg (dummy-package "x"
-                                     (synopsis "Bad synopsis."))))
-                          (check-synopsis-style pkg))))
+   (string-contains (with-warnings
+                      (let ((pkg (dummy-package "x"
+                                   (synopsis "Bad synopsis."))))
+                        (check-synopsis-style pkg)))
                     "no period allowed at the end of the synopsis")))
 
 (test-assert "synopsis: ends with 'etc.'"
-  (string-null? (call-with-warnings
-                 (lambda ()
-                   (let ((pkg (dummy-package "x"
-                                (synopsis "Foo, bar, etc."))))
-                     (check-synopsis-style pkg))))))
+  (string-null? (with-warnings
+                  (let ((pkg (dummy-package "x"
+                               (synopsis "Foo, bar, etc."))))
+                    (check-synopsis-style pkg)))))
 
 (test-assert "synopsis: starts with 'A'"
   (->bool
-   (string-contains (call-with-warnings
-                      (lambda ()
-                        (let ((pkg (dummy-package "x"
-                                     (synopsis "A bad synopŝis"))))
-                          (check-synopsis-style pkg))))
+   (string-contains (with-warnings
+                      (let ((pkg (dummy-package "x"
+                                   (synopsis "A bad synopŝis"))))
+                        (check-synopsis-style pkg)))
                     "no article allowed at the beginning of the synopsis")))
 
 (test-assert "synopsis: starts with 'An'"
   (->bool
-   (string-contains (call-with-warnings
-                      (lambda ()
-                        (let ((pkg (dummy-package "x"
-                                     (synopsis "An awful synopsis"))))
-                        (check-synopsis-style pkg))))
+   (string-contains (with-warnings
+                      (let ((pkg (dummy-package "x"
+                                   (synopsis "An awful synopsis"))))
+                        (check-synopsis-style pkg)))
                     "no article allowed at the beginning of the synopsis")))
 
 (test-assert "synopsis: starts with 'a'"
   (->bool
-   (string-contains (call-with-warnings
-                      (lambda ()
-                        (let ((pkg (dummy-package "x"
-                                     (synopsis "a bad synopsis"))))
-                        (check-synopsis-style pkg))))
+   (string-contains (with-warnings
+                      (let ((pkg (dummy-package "x"
+                                   (synopsis "a bad synopsis"))))
+                        (check-synopsis-style pkg)))
                     "no article allowed at the beginning of the synopsis")))
 
 (test-assert "synopsis: starts with 'an'"
   (->bool
-   (string-contains (call-with-warnings
-                      (lambda ()
-                        (let ((pkg (dummy-package "x"
-                                     (synopsis "an awful synopsis"))))
-                        (check-synopsis-style pkg))))
+   (string-contains (with-warnings
+                      (let ((pkg (dummy-package "x"
+                                   (synopsis "an awful synopsis"))))
+                        (check-synopsis-style pkg)))
                     "no article allowed at the beginning of the synopsis")))
 
 (test-assert "synopsis: too long"
   (->bool
-   (string-contains (call-with-warnings
-                      (lambda ()
-                        (let ((pkg (dummy-package "x"
-                                     (synopsis (make-string 80 #\x)))))
-                          (check-synopsis-style pkg))))
+   (string-contains (with-warnings
+                      (let ((pkg (dummy-package "x"
+                                   (synopsis (make-string 80 #\x)))))
+                        (check-synopsis-style pkg)))
                     "synopsis should be less than 80 characters long")))
 
 (test-assert "synopsis: start with package name"
   (->bool
-   (string-contains (call-with-warnings
-                      (lambda ()
-                        (let ((pkg (dummy-package "x"
-                                     (name "foo")
-                                     (synopsis "foo, a nice package"))))
-                          (check-synopsis-style pkg))))
+   (string-contains (with-warnings
+                      (let ((pkg (dummy-package "x"
+                                   (name "foo")
+                                   (synopsis "foo, a nice package"))))
+                        (check-synopsis-style pkg)))
                     "synopsis should not start with the package name")))
 
 (test-assert "synopsis: start with package name prefix"
   (string-null?
-   (call-with-warnings
-    (lambda ()
-      (let ((pkg (dummy-package "arb"
-                   (synopsis "Arbitrary precision"))))
-        (check-synopsis-style pkg))))))
+   (with-warnings
+     (let ((pkg (dummy-package "arb"
+                  (synopsis "Arbitrary precision"))))
+       (check-synopsis-style pkg)))))
 
 (test-assert "synopsis: start with abbreviation"
   (string-null?
-   (call-with-warnings
-    (lambda ()
-      (let ((pkg (dummy-package "uucp"
-                   ;; Same problem with "APL interpreter", etc.
-                   (synopsis "UUCP implementation")
-                   (description "Imagine this is Taylor UUCP."))))
-        (check-synopsis-style pkg))))))
+   (with-warnings
+     (let ((pkg (dummy-package "uucp"
+                  ;; Same problem with "APL interpreter", etc.
+                  (synopsis "UUCP implementation")
+                  (description "Imagine this is Taylor UUCP."))))
+       (check-synopsis-style pkg)))))
 
 (test-assert "inputs: pkg-config is probably a native input"
   (->bool
    (string-contains
-     (call-with-warnings
-       (lambda ()
-         (let ((pkg (dummy-package "x"
-                      (inputs `(("pkg-config" ,pkg-config))))))
-              (check-inputs-should-be-native pkg))))
+     (with-warnings
+       (let ((pkg (dummy-package "x"
+                    (inputs `(("pkg-config" ,pkg-config))))))
+         (check-inputs-should-be-native pkg)))
          "pkg-config should probably be a native input")))
 
 (test-assert "patches: file names"
   (->bool
    (string-contains
-     (call-with-warnings
-       (lambda ()
-         (let ((pkg (dummy-package "x"
-                      (source
-                       (origin
-                        (method url-fetch)
-                        (uri "someurl")
-                        (sha256 "somesha")
-                        (patches (list "/path/to/y.patch")))))))
-              (check-patches pkg))))
+     (with-warnings
+       (let ((pkg (dummy-package "x"
+                    (source
+                     (origin
+                       (method url-fetch)
+                       (uri "someurl")
+                       (sha256 "somesha")
+                       (patches (list "/path/to/y.patch")))))))
+         (check-patches pkg)))
      "file names of patches should start with the package name")))
 
 (test-assert "home-page: wrong home-page"
   (->bool
    (string-contains
-    (call-with-warnings
-     (lambda ()
-       (let ((pkg (package
-                    (inherit (dummy-package "x"))
-                    (home-page #f))))
-         (check-home-page pkg))))
+    (with-warnings
+      (let ((pkg (package
+                   (inherit (dummy-package "x"))
+                   (home-page #f))))
+        (check-home-page pkg)))
     "invalid")))
 
 (test-assert "home-page: invalid URI"
   (->bool
    (string-contains
-    (call-with-warnings
-     (lambda ()
-       (let ((pkg (package
-                    (inherit (dummy-package "x"))
-                    (home-page "foobar"))))
-         (check-home-page pkg))))
+    (with-warnings
+      (let ((pkg (package
+                   (inherit (dummy-package "x"))
+                   (home-page "foobar"))))
+        (check-home-page pkg)))
     "invalid home page URL")))
 
 (test-assert "home-page: host not found"
   (->bool
    (string-contains
-    (call-with-warnings
-     (lambda ()
-       (let ((pkg (package
-                    (inherit (dummy-package "x"))
-                    (home-page "http://does-not-exist"))))
-         (check-home-page pkg))))
+    (with-warnings
+      (let ((pkg (package
+                   (inherit (dummy-package "x"))
+                   (home-page "http://does-not-exist"))))
+        (check-home-page pkg)))
     "domain not found")))
 
 (test-skip (if %http-server-socket 0 1))
 (test-assert "home-page: Connection refused"
   (->bool
    (string-contains
-    (call-with-warnings
-     (lambda ()
-       (let ((pkg (package
-                    (inherit (dummy-package "x"))
-                    (home-page %local-url))))
-         (check-home-page pkg))))
+    (with-warnings
+      (let ((pkg (package
+                   (inherit (dummy-package "x"))
+                   (home-page %local-url))))
+        (check-home-page pkg)))
     "Connection refused")))
 
 (test-skip (if %http-server-socket 0 1))
 (test-equal "home-page: 200"
   ""
-  (call-with-warnings
-   (lambda ()
-     (with-http-server 200
-       (let ((pkg (package
-                    (inherit (dummy-package "x"))
-                    (home-page %local-url))))
-         (check-home-page pkg))))))
+  (with-warnings
+   (with-http-server 200
+     (let ((pkg (package
+                  (inherit (dummy-package "x"))
+                  (home-page %local-url))))
+       (check-home-page pkg)))))
 
 (test-skip (if %http-server-socket 0 1))
 (test-assert "home-page: 404"
   (->bool
    (string-contains
-    (call-with-warnings
-     (lambda ()
-       (with-http-server 404
-         (let ((pkg (package
-                      (inherit (dummy-package "x"))
-                      (home-page %local-url))))
-           (check-home-page pkg)))))
+    (with-warnings
+      (with-http-server 404
+        (let ((pkg (package
+                     (inherit (dummy-package "x"))
+                     (home-page %local-url))))
+          (check-home-page pkg))))
     "not reachable: 404")))
 
 (test-end "lint")
@@ -380,4 +356,5 @@ requests."
 
 ;; Local Variables:
 ;; eval: (put 'with-http-server 'scheme-indent-function 1)
+;; eval: (put 'with-warnings 'scheme-indent-function 0)
 ;; End:
-- 
cgit v1.2.3