Changeset 10 for trunk/epic

Timestamp:

08/18/08 17:21:15 (4 years ago)

Author:

fumanchu

Message:

Changed assert_values to assert_column. Changed record_asserter(varname1 text, varname2 text, colnames text) to assert_rows(source text, expected text). Added pass, fail, todo, skip and finish functions.

Location:

trunk/epic

Files:

• epic.sql (modified) (12 diffs)
• test/test_asserts.sql (modified) (2 diffs)

trunk/epic/epic.sql

@@ -48 +48 @@
     
     1. ALWAYS RAISE EXCEPTION at the end of test procs to rollback! Even if
-        the test passes, RAISE EXCEPTION '[OK]'.
+        the test passes, RAISE EXCEPTION '[OK]'. You may instead PERFORM the
+        Epic functions test.pass(), test.fail(errmsg), test.todo(msg) and
+        test.skip(msg).
     2. Put your test in the "test" schema.
     3. Start the name of your test with "test_".
@@ -80 +82 @@
 
   -- ALWAYS RAISE EXCEPTION at the end of test procs to rollback!
-  RAISE EXCEPTION '[OK]';
-END;
-$$ LANGUAGE plpgsql;
-
-
-Test helper functions
----------------------
+  PERFORM test.pass();
+END;
+$$ LANGUAGE plpgsql;
+
+
+Assertion functions
+-------------------
 
 Epic.sql includes some functions to make tests easier to write (and shorter).
@@ -102 +104 @@
     * test.assert_less_than(elem_1 anyelement, elem_2 anyelement)
     * test.assert_less_than_or_equal(elem_1 anyelement, elem_2 anyelement)
-    * test.assert_values(source text, expected anyarray, colname text):
-        Raises an exception if SELECT column FROM source != expected.
+    * test.assert_rows(row_1 text, row_2 text):
+        Raises an exception if the SELECT statement row_1 != the SELECT statement row_2.
+    * test.assert_column(call text, expected anyarray[, colname text]):
+        Raises an exception if SELECT colname FROM call != expected.
     
-    * test.assert_raises(call text, errm text, state text): Raises an
-        exception if 'SELECT * FROM [call];' does not raise errm
+    * test.assert_raises(call text, errm text, state text): 
+        Raises an exception if 'SELECT * FROM [call];' does not raise errm
         (if provided) or state (if provided).
-
-Some return dynamic SQL:
-    
-    * test.record_asserter(varname1 text, varname2 text, colnames text):
-        Returns EXECUTE-able SQL to assert equal fields for the two records.
-        LOOP over its results and PERFORM each one.
 
 
@@ -217 +215 @@
   modulename      text;
   output_record   test.results%ROWTYPE;
+  splitpoint      int;
 BEGIN
   SELECT module INTO modulename FROM test.testnames WHERE name = testname;
@@ -224 +223 @@
     EXECUTE 'SELECT * FROM test.' || testname || '();';
   EXCEPTION WHEN OTHERS THEN
-    IF SQLERRM LIKE '[%]' THEN
-      INSERT INTO test.results (name, module, result)
-        VALUES (testname, modulename, SQLERRM)
+    IF SQLSTATE = 'P0001' AND SQLERRM LIKE '[%]%' THEN
+      splitpoint := position(']' in SQLERRM);
+      INSERT INTO test.results (name, module, result, errcode, errmsg)
+        VALUES (testname, modulename, substr(SQLERRM, 1, splitpoint),
+                CASE WHEN SQLERRM LIKE '[FAIL]%' THEN SQLSTATE ELSE '' END,
+                btrim(substr(SQLERRM, splitpoint + 1)))
         RETURNING * INTO output_record;
       RETURN output_record;
@@ -272 +274 @@
     END LOOP;
   END LOOP;
+END;
+$$ LANGUAGE plpgsql;
+
+
+CREATE OR REPLACE FUNCTION test.finish(result text, errmsg text) RETURNS VOID AS $$
+-- Use this to finish a test. Raises the given result as an exception (for rollback).
+DECLARE
+  msg        text;
+BEGIN
+  msg := '[' || result || ']';
+  IF errmsg IS NOT NULL THEN
+    msg := msg || ' ' || errmsg;
+  END IF;
+  RAISE EXCEPTION '%', msg;
+END;
+$$ LANGUAGE plpgsql;
+
+
+CREATE OR REPLACE FUNCTION test.pass(msg text) RETURNS VOID AS $$
+-- Use this to finish a successful test. Raises exception '[OK] msg'.
+BEGIN
+  PERFORM test.finish('OK', msg);
+END;
+$$ LANGUAGE plpgsql;
+CREATE OR REPLACE FUNCTION test.pass() RETURNS VOID AS $$
+-- Use this to finish a successful test. Raises exception '[OK]'.
+BEGIN
+  PERFORM test.finish('OK', NULL);
+END;
+$$ LANGUAGE plpgsql;
+
+
+CREATE OR REPLACE FUNCTION test.fail(msg text) RETURNS VOID AS $$
+-- Use this to finish a failed test. Raises exception '[FAIL] msg'.
+BEGIN
+  PERFORM test.finish('FAIL', msg);
+END;
+$$ LANGUAGE plpgsql;
+CREATE OR REPLACE FUNCTION test.fail() RETURNS VOID AS $$
+-- Use this to finish a failed test. Raises exception '[FAIL]'.
+BEGIN
+  PERFORM test.finish('FAIL', NULL);
+END;
+$$ LANGUAGE plpgsql;
+
+
+CREATE OR REPLACE FUNCTION test.todo(msg text) RETURNS VOID AS $$
+-- Use this to abort a test as 'todo'. Raises exception '[TODO] msg'.
+BEGIN
+  PERFORM test.finish('TODO', msg);
+END;
+$$ LANGUAGE plpgsql;
+CREATE OR REPLACE FUNCTION test.todo() RETURNS VOID AS $$
+-- Use this to abort a test as 'todo'. Raises exception '[TODO]'.
+BEGIN
+  PERFORM test.finish('TODO', NULL);
+END;
+$$ LANGUAGE plpgsql;
+
+
+CREATE OR REPLACE FUNCTION test.skip(msg text) RETURNS VOID AS $$
+-- Use this to skip a test. Raises exception '[SKIP] msg'.
+BEGIN
+  PERFORM test.finish('SKIP', msg);
+END;
+$$ LANGUAGE plpgsql;
+CREATE OR REPLACE FUNCTION test.skip() RETURNS VOID AS $$
+-- Use this to skip a test. Raises exception '[SKIP]'.
+BEGIN
+  PERFORM test.finish('SKIP', NULL);
 END;
 $$ LANGUAGE plpgsql;
@@ -444 +516 @@
 
 
-
-CREATE OR REPLACE FUNCTION test.record_asserter(varname1 text, varname2 text, colnames text) RETURNS SETOF text AS $$
--- Returns EXECUTE-able SQL to assert equal fields for the two records.
+CREATE OR REPLACE FUNCTION test.assert_rows(source text, expected text) RETURNS VOID AS $$
+-- Asserts that two sets of rows have equal values.
 --
--- Pass the variable *names* (not the records themselves) as the first
--- two arguments, and a comma-delimited list of column names to compare.
+-- Both arguments should be SELECT statements yielding a single row or a set of rows.
+-- Neither source nor expected need to be sorted. Either may include a trailing semicolon.
 --
 -- Example:
 -- 
---    SELECT INTO old * FROM table WHERE id = 1;
---    SELECT INTO new * FROM table WHERE id = 2;
---    FOR assertion in
---      SELECT * FROM test.record_asserter('old', 'new', 'first, last, city')
---    LOOP
---      PERFORM assertion;
---    END LOOP;
+--    PERFORM test.assert_row('SELECT first, last, city FROM table1',
+--                            'SELECT ROW(''Davy'', ''Crockett'', NULL)');
+DECLARE
+  rec     record;
+BEGIN
+  FOR rec in EXECUTE rtrim(source, ';') || ' EXCEPT ' || rtrim(expected, ';')
+  LOOP
+    RAISE EXCEPTION 'Record: % from: % not found in: %', rec, source, expected;
+  END LOOP;
+  
+  FOR rec in EXECUTE rtrim(expected, ';') || ' EXCEPT ' || rtrim(source, ';')
+  LOOP
+    RAISE EXCEPTION 'Record: % from: % not found in: %', rec, expected, source;
+  END LOOP;
+END;
+$$ LANGUAGE plpgsql IMMUTABLE;
+
+
+CREATE OR REPLACE FUNCTION test.assert_column(call text, expected anyarray, colname text) RETURNS VOID AS $$
+-- Raises an exception if SELECT colname FROM call != expected.
 --
-DECLARE
-  i             integer:=1;
-  colname       text;
-  colnames_arr  text[];
-BEGIN
-  --TODO: IF colnames IS NULL grab colnames from type
-  
-  colnames_arr := string_to_array(colnames, ',');
-  FOR i IN array_lower(colnames_arr, 1)..array_upper(colnames_arr, 1)
-  LOOP
-    colname := quote_ident(trim(both ' ' from colnames_arr[i]));
-    RETURN NEXT 'PERFORM test.assert_equal(' ||
-                 quote_ident(varname1) || '.' || colname || ', ' ||
-                 quote_ident(varname2) || '.' || colname || ');';
-  END LOOP;
-  RETURN;
-END;
-$$ LANGUAGE plpgsql IMMUTABLE;
-
-
-CREATE OR REPLACE FUNCTION test.assert_values(source text, expected anyarray, colname text) RETURNS VOID AS $$
--- Raises an exception if SELECT column FROM source != expected.
+-- If colname is NULL or omitted, the first column of call's output will be used.
 --
--- colname should be the name of the column in source to compare.
--- If NULL, it will be taken from the first column of source's output.
---
--- source can be any table, view, or procedure that returns records.
--- 
--- expected MUST be an array of the same type as colname.
--- Neither source nor expected need to be sorted.
+-- 'call' can be any table, view, or procedure that returns records.
+-- 
+-- 'expected' MUST be an array of the same type as colname.
+-- Neither call nor expected need to be sorted.
 -- 
 -- Example:
---    PERFORM test.assert_values(
+--    PERFORM test.assert_column(
 --      'get_favorite_user_ids(' || user_id || ');',
 --      ARRAY[24, 10074, 87321], 'user_id');
@@ -502 +562 @@
   firstname     text;
 BEGIN
-  -- Dump the source into a temp table
+  -- Dump the call output into a temp table
   IF colname IS NULL THEN
     EXECUTE 'CREATE TEMPORARY TABLE _test_assert_values_base AS ' ||
-      'SELECT * FROM ' || source || ';';
+      'SELECT * FROM ' || call || ';';
     SELECT INTO firstname a.attname
       FROM pg_class c LEFT JOIN pg_attribute a ON c.oid = a.attrelid
@@ -513 +573 @@
       AND a.attnum >= 1
       ORDER BY a.attnum;
-    EXECUTE 'ALTER TABLE _test_assert_values_base RENAME ' || firstname || ' TO result;';
+    EXECUTE 'ALTER TABLE _test_assert_values_base RENAME ' || firstname || ' TO _assert_values_result;';
   ELSE
     EXECUTE 'CREATE TEMPORARY TABLE _test_assert_values_base AS ' ||
-      'SELECT ' || colname || ' AS result FROM ' || source || ';';
+      'SELECT ' || colname || ' AS _assert_values_result FROM ' || call || ';';
   END IF;
   
@@ -525 +585 @@
   FOR i IN array_lower(expected, 1)..array_upper(expected, 1)
   LOOP
-    EXECUTE 'INSERT INTO _test_assert_values_expected (result) VALUES (' || quote_literal(expected[i]) || ');';
+    IF expected[i] IS NULL THEN
+      EXECUTE 'INSERT INTO _test_assert_values_expected (_assert_values_result) VALUES (NULL);';
+    ELSE
+      EXECUTE 'INSERT INTO _test_assert_values_expected (_assert_values_result) VALUES ('
+              || quote_literal(expected[i]) || ');';
+    END IF;
   END LOOP;
   
@@ -532 +597 @@
   BEGIN
     FOR record IN EXECUTE '(SELECT * FROM _test_assert_values_base EXCEPT ALL
-                     SELECT * FROM _test_assert_values_expected)'
+                            SELECT * FROM _test_assert_values_expected)'
     LOOP
-      RAISE EXCEPTION 'result: % not in array: %', record.result, expected;
+      RAISE EXCEPTION 'result: % not in array: %', record._assert_values_result, expected;
     END LOOP;
     
     FOR record IN EXECUTE '(SELECT * FROM _test_assert_values_expected EXCEPT ALL
-                     SELECT * FROM _test_assert_values_base)'
+                            SELECT * FROM _test_assert_values_base)'
     LOOP
-      RAISE EXCEPTION 'element: % not in source: %', record.result, source;
+      RAISE EXCEPTION 'element: % not in call: %', record._assert_values_result, call;
     END LOOP;
   EXCEPTION WHEN OTHERS THEN
@@ -553 +618 @@
 $$ LANGUAGE plpgsql;
 
-CREATE OR REPLACE FUNCTION test.assert_values(source text, expected anyarray) RETURNS VOID AS $$
--- Implicit column version of assert_values
-BEGIN
-  PERFORM test.assert_values(source, expected, NULL);
-END;
-$$ LANGUAGE plpgsql;
+CREATE OR REPLACE FUNCTION test.assert_column(call text, expected anyarray) RETURNS VOID AS $$
+-- Implicit column version of assert_column
+BEGIN
+  PERFORM test.assert_column(call, expected, NULL);
+END;
+$$ LANGUAGE plpgsql;

trunk/epic/test/test_asserts.sql

@@ -300 +300 @@
 
 
-CREATE OR REPLACE FUNCTION test.test_record_asserter() RETURNS VOID AS $$
--- Assert the correct operation of test.record_asserter
--- module: test_asserts
-DECLARE
-  assertion    text;
-  assertions   text[];
-  old          record;
-  new          record;
-BEGIN
-  FOR assertion in
-    SELECT * FROM test.record_asserter('old', 'new', 'first, last, city')
-  LOOP
-    assertions := assertions || assertion;
-  END LOOP;
-  
-  IF assertions <> ARRAY['PERFORM test.assert_equal("old"."first", "new"."first");',
-                         'PERFORM test.assert_equal("old"."last", "new"."last");',
-                         'PERFORM test.assert_equal("old".city, "new".city);'] THEN
-    RAISE EXCEPTION 'record_asserter did not return the proper SQL. %', assertions;
-  END IF;
-  
-  -- Now just for fun, execute the returned SQL.
-  CREATE TEMPORARY TABLE _test_user (first text, last text, city text);
-  INSERT INTO _test_user VALUES ('Michael', 'Stonebraker', 'New York');
-  SELECT INTO old * FROM _test_user WHERE city = 'New York';
-  SELECT INTO new * FROM _test_user WHERE city = 'New York';
-  FOR i IN array_lower(assertions, 1)..array_upper(assertions, 1)
-  LOOP
-    PERFORM assertions[i];
-  END LOOP;
-  
-  RAISE EXCEPTION '[OK]';
-END;
-$$ LANGUAGE plpgsql;
-
-
-CREATE OR REPLACE FUNCTION test.test_assert_values() RETURNS VOID AS $$
--- Assert the correct operation of test.assert_values
+CREATE OR REPLACE FUNCTION test.test_assert_rows() RETURNS VOID AS $$
+-- Assert the correct operation of test.assert_rows
 -- module: test_asserts
 DECLARE
   failed     bool;
 BEGIN
-  PERFORM test.assert_values(
+  -- Tautology
+  PERFORM test.assert_rows(
+    'SELECT oid, proname FROM pg_proc',
+    'SELECT oid, proname FROM pg_proc');
+  -- Almost a tautology ;)
+  -- Note the trailing semicolon in the first arg.
+  PERFORM test.assert_rows(
+    'SELECT tablename FROM pg_tables;',
+    'SELECT relname FROM pg_class where relkind = ''r''');
+  
+  -- ...and an assertion that should fail
+  failed := false;
+  BEGIN
+    PERFORM test.assert_rows(
+      'SELECT * FROM generate_series(1, 10)', 
+      'SELECT * FROM generate_series(1, 5)');
+  EXCEPTION WHEN OTHERS THEN
+    failed := true;
+    IF SQLERRM = 'Record: (6) from: SELECT * FROM generate_series(1, 10) not found in: SELECT * FROM generate_series(1, 5)' THEN
+      NULL;
+    ELSE
+      RAISE EXCEPTION 'test.assert_rows() did not raise the correct error. Raised: %', SQLERRM;
+    END IF;
+  END;
+  IF NOT failed THEN
+    PERFORM test.fail('test.assert_rows() did not fail.');
+  END IF;
+  
+  PERFORM test.pass();
+END;
+$$ LANGUAGE plpgsql;
+
+
+CREATE OR REPLACE FUNCTION test.test_assert_column() RETURNS VOID AS $$
+-- Assert the correct operation of test.assert_column
+-- module: test_asserts
+DECLARE
+  failed     bool;
+BEGIN
+  -- Test an assertion that should pass
+  PERFORM test.assert_column(
     'generate_series(1, 10);',
     ARRAY[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-  
+  -- explicit colname version
+  PERFORM test.assert_column(
+    'generate_series(1, 10);',
+    ARRAY[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+    'generate_series');
+  
+  -- ...and an assertion that should fail
   failed := false;
   BEGIN
-    PERFORM test.assert_values('generate_series(1, 10);', ARRAY[1, 2]);
+    PERFORM test.assert_column('generate_series(1, 10);', ARRAY[1, 2]);
   EXCEPTION WHEN OTHERS THEN
     failed := true;
@@ -354 +364 @@
       NULL;
     ELSE
-      RAISE EXCEPTION 'test.assert_values() did not raise the correct error. Raised: %', SQLERRM;
+      RAISE EXCEPTION 'test.assert_column() did not raise the correct error. Raised: %', SQLERRM;
     END IF;
   END;
   IF NOT failed THEN
-    RAISE EXCEPTION 'test.assert_values() did not fail.';
-  END IF;
-  
-  RAISE EXCEPTION '[OK]';
-END;
-$$ LANGUAGE plpgsql;
+    PERFORM test.fail('test.assert_column() did not fail.');
+  END IF;
+  
+  RAISE EXCEPTION '[OK]';
+END;
+$$ LANGUAGE plpgsql;