Begin to implement unit tests using ERT

I said that I would do this a looooong time ago, but am only now
getting around to it (as a result of feeling envigorated to write
code lately).  This patch implements some basic unit tests for our
`php-runtime` library, and in particular the `php-runtime-expr`
part of the API.

The unit test code provides a `run-simple-php` function to help with
testing, allowing us to hand some short code to the PHP executable
for execution.  However, the `php-runtime` library provides this exact
functionality---obviously it must.  Therefore in the future we should
remove our utility from the unit test code and instead rely on the
relevant code from the `php-runtime` library itself.  The only reason
I did not use it in this first draft is because I wanted to re-examine
the code to see if I can simplify it in any meaningful and useful way.

Finally, this file of unit tests is incomplete and we will be adding
more tests in the future, particularly for such things as reading
standard-input into PHP code we wish to run.

GitHub-Issue: #2
Signed-off-by: Eric James Michael Ritz <[email protected]>

Author: Eric James Michael Ritz

php-runtime-test.el

@@ -1,8 +1,9 @@
 ;;; php-runtime-test.el --- Unit tests for php-runtime package.
 
 ;; Copyright (C) 2017 USAMI Kenta
+;; Copyright (C) 2018 Eric James Michael Ritz
 
-;; Author: USAMI Kenta <[email protected]>
+;; Authors: USAMI Kenta <[email protected]>
 ;; Created: 28 Aug 2017
 ;; Version: 0.0.1
 ;; Keywords: processes php
@@ -37,39 +38,47 @@
 (require 'php-runtime)
 (require 'ert)
 
-(ert-deftest php-runtime-test-eval-with-stdin ()
-  (dolist (v (list '("Input buffer as string"
-                     :expected "1 apple\n2 orange\n3 banana\n"
-                     :code "$i = 0;
-while (($line = fgets(STDIN)) !== false) {
-    echo ++$i, ' ', trim($line), \"\n\";
-}"
-                     :input-buf "apple\norange\nbanana")))
-    (let ((description (car v))
-          (expected (plist-get (cdr v) :expected))
-          (code (plist-get (cdr v) :code))
-          (input-buf (plist-get (cdr v) :input-buf)))
-      (should (string= expected (php-runtime-eval code input-buf))))))
-
-(ert-deftest php-runtime-test-eval-without-stdin ()
-  (dolist (v (list '("No input buffer"
-                     :expected ""
-                     :code "$i = 0;
-while (($line = fgets(STDIN)) !== false) {
-    echo ++$i, ' ', trim($line), \"\n\";
-}")))
-    (let ((description (car v))
-          (expected (plist-get (cdr v) :expected))
-          (code (plist-get (cdr v) :code)))
-      (should (string= expected (php-runtime-eval code))))))
-
-(ert-deftest php-runtime-test-expr ()
-  "Test that PHP expressions are evaluated and get results."
+(defun run-simple-php (code)
+  "Utility function to run CODE for simple PHP testing.
+
+This function accepts PHP code as a string and runs it using
+whichever PHP executable is available on the system.  In order to
+reduce sources of potential problems, we do not load any PHP INI
+or other configurations.
+
+The function returns the result of the code as a string."
+  ;; We call PHP with two options:
+  ;;
+  ;; 1. `-n` - Causes PHP to ignore any system-wide INI, because we
+  ;;    don't want any such configuration screwing up our tests.
+  ;;
+  ;; 2. `-r` - Tells PHP to run the code which follows, which we must
+  ;;    quote appropriately as a shell argument.
+  (shell-command-to-string (concat "php -n -r" (shell-quote-argument code))))
+
+(ert-deftest runtime-expressions ()
+  "Test using `php-runtime-expr'.
+
+We can make explicit invocations of the PHP executable to obtain
+the values of various runtime expressions.  These tests compare
+those to the values we obtain via `php-runtime-expr', which
+should always be the same."
+  ;; Testing simple constants.
+  (should (string= (php-runtime-expr "PHP_VERSION")
+		   (run-simple-php "echo PHP_VERSION;")))
+  ;; Testing simple function calls.
+  (should (string= (php-runtime-expr "strtoupper('foobar')")
+		   (run-simple-php "echo strtoupper('foobar');")))
+  ;; Testing basic math.
   (should (string= "200" (php-runtime-expr "(1+1)*100")))
-  (should (string= "foo" (php-runtime-expr "'f' . 'oo'"))))
+  ;; Testing string concatenation.
+  (should (string= "foo" (php-runtime-expr "'f' . 'oo'")))
+  ;; Converting output to numbers.
+  (should (= (string-to-number (php-runtime-expr "PHP_INT_MAX"))
+	     (string-to-number (run-simple-php "echo PHP_INT_MAX;")))))
 
-(ert-deftest php-runtime-test-expr-syntax-error ()
-  "Test that PHP code syntax errors are reported as errors in Emacs."
+(ert-deftest php-syntax-errors ()
+  "Test that PHP code with errors cause appropriate failures."
   (should-error (php-runtime-expr "a:b")))
 
 (provide 'php-runtime-test)