refactored tests

Author: zohl

tests/Main.hs

@@ -1,5 +1,4 @@
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE NamedFieldPuns    #-}
 
 import Test.Hspec
 import Database.PostgreSQL.Simple.Bind.Representation
@@ -10,124 +9,203 @@ main = hspec spec
 
 spec :: Spec
 spec = do
+  let test = \declaration result -> parsePGFunction declaration >>= shouldBe result
+
   describe "parsePGFunction" $ do
     it "works with simple signatures" $ do
-      (parsePGFunction "function f(x bigint) returns bigint") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "bigint" False] (PGSingle "bigint"))
-
-      (parsePGFunction "function g(x bigint, y varchar) returns void") >>= shouldBe
-        (PGFunction "" "g" [PGArgument "x" "bigint" False, PGArgument "y" "varchar" False]
-          (PGSingle "void"))
-
-      (parsePGFunction "function h() returns varchar") >>= shouldBe
-        (PGFunction "" "h" [] (PGSingle "varchar"))
-
-      (parsePGFunction "FUNCTION H(Z VARCHAR) RETURNS BIGINT") >>= shouldBe
-        (PGFunction "" "h" [PGArgument "z" "varchar" False] (PGSingle "bigint"))
+      let r = PGFunction {
+          pgfSchema    = ""
+        , pgfName      = ""
+        , pgfArguments = []
+        , pgfResult    = PGSingle ""
+        }
+
+      test "function f(x bigint) returns bigint" r {
+          pgfName = "f"
+        , pgfResult = PGSingle "bigint"
+        , pgfArguments = [
+              PGArgument { pgaName = "x", pgaType = "bigint", pgaOptional = False }
+            ]
+        }
+
+      test "function g(x bigint, y varchar) returns void" r {
+          pgfName = "g"
+        , pgfArguments = [
+              PGArgument { pgaName = "x", pgaType = "bigint", pgaOptional = False }
+            , PGArgument { pgaName = "y", pgaType = "varchar", pgaOptional = False }
+            ]
+        , pgfResult = PGSingle "void"
+        }
+
+      test "function h() returns varchar" r {
+          pgfName = "h"
+        , pgfArguments = []
+        , pgfResult = PGSingle "varchar"
+        }
+
+      test "FUNCTION H(Z VARCHAR) RETURNS BIGINT" r {
+          pgfName = "h"
+        , pgfArguments = [
+              PGArgument { pgaName = "z", pgaType = "varchar", pgaOptional = False }
+            ]
+        , pgfResult = PGSingle "bigint"
+        }
 
 
     it "works with default values" $ do
-      (parsePGFunction "function f(x bigint default 0::bigint) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "bigint" True] (PGSingle "void"))
-
-      (parsePGFunction "function f(x bigint, y bigint default 0::bigint) returns void") >>= shouldBe
-        (PGFunction "" "f"
-          [PGArgument "x" "bigint" False, PGArgument "y" "bigint" True] (PGSingle "void"))
-
-      (parsePGFunction
-        "function f(x bigint, y bigint = 0::bigint, z bigint = 0::bigint) returns void") >>= shouldBe
-        (PGFunction "" "f" [
-            PGArgument "x" "bigint" False
-          , PGArgument "y" "bigint" True
-          , PGArgument "z" "bigint" True
-          ] (PGSingle "void"))
-
+      let r = PGFunction {
+          pgfSchema    = ""
+        , pgfName      = "f"
+        , pgfArguments = []
+        , pgfResult    = PGSingle "void"
+        }
+
+      test "function f(x bigint default 0::bigint) returns void" r {
+          pgfArguments = [
+              PGArgument { pgaName = "x", pgaType = "bigint", pgaOptional = True }
+            ]
+        }
+
+      test "function f(x bigint, y bigint default 0::bigint) returns void" r {
+          pgfArguments = [
+              PGArgument { pgaName = "x", pgaType = "bigint", pgaOptional = False }
+            , PGArgument { pgaName = "y", pgaType = "bigint", pgaOptional = True }
+            ]
+        }
+
+      test "function f(x bigint, y bigint = 0::bigint, z bigint = 0::bigint) returns void" r {
+          pgfArguments = [
+              PGArgument { pgaName = "x", pgaType = "bigint", pgaOptional = False }
+            , PGArgument { pgaName = "y", pgaType = "bigint", pgaOptional = True }
+            , PGArgument { pgaName = "z", pgaType = "bigint", pgaOptional = True }
+            ]
+        }
 
     it "works with return value types" $ do
-      (parsePGFunction "function f() returns setof bigint") >>= shouldBe
-        (PGFunction "" "f" [] (PGSetOf "bigint"))
+      let r = PGFunction {
+          pgfSchema = ""
+        , pgfName = "f"
+        , pgfArguments = []
+        , pgfResult = PGSetOf ""
+        }
 
-      (parsePGFunction "function f() returns SETOF bigint") >>= shouldBe
-        (PGFunction "" "f" [] (PGSetOf "bigint"))
+      test "function f() returns setof bigint" r { pgfResult = PGSetOf "bigint" }
 
-      (parsePGFunction "function f() returns table (x bigint, y varchar)") >>= shouldBe
-        (PGFunction "" "f" [] (PGTable [PGColumn "x" "bigint", PGColumn "y" "varchar"]))
+      test "function f() returns SETOF bigint" r { pgfResult = PGSetOf "bigint" }
 
+      test "function f() returns table (x bigint, y varchar)" r {
+          pgfResult = PGTable [
+              PGColumn { pgcName = "x", pgcType = "bigint" }
+            , PGColumn { pgcName = "y", pgcType = "varchar" }
+            ]
+        }
 
     it "works with schema names" $ do
-      (parsePGFunction "function public.f() returns bigint") >>= shouldBe
-        (PGFunction "public" "f" [] (PGSingle "bigint"))
+      let r = PGFunction {
+          pgfSchema = ""
+        , pgfName = "f"
+        , pgfArguments = []
+        , pgfResult = PGSingle "bigint"
+        }
 
-      (parsePGFunction "function Test.f() returns bigint") >>= shouldBe
-        (PGFunction "test" "f" [] (PGSingle "bigint"))
+      test "function public.f() returns bigint" r { pgfSchema = "public" }
 
+      test "function Test.f() returns bigint" r { pgfSchema = "test" }
 
 
   describe "parsing a function with specific type" $ do
-    it "works for multiple word types" $ do
-      (parsePGFunction "function f(x double precision) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "double precision" False] (PGSingle "void"))
+    let r = PGFunction {
+        pgfSchema = ""
+      , pgfName = "f"
+      , pgfArguments = []
+      , pgfResult = PGSingle "void"
+      }
 
+    let x = PGArgument { pgaName = "x", pgaType = "", pgaOptional = False }
+
+    it "works for multiple word types" $ do
+      test "function f(x double precision) returns void" r {
+          pgfArguments = [ x { pgaType = "double precision" } ]
+        }
 
     it "works for types with precisions" $ do
-      (parsePGFunction "function f(x bit) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "bit" False] (PGSingle "void"))
+      test "function f(x bit) returns void" r {
+          pgfArguments = [ x { pgaType = "bit" } ]
+        }
 
-      (parsePGFunction "function f(x bit (32)) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "bit" False] (PGSingle "void"))
+      test "function f(x bit (32)) returns void" r {
+          pgfArguments = [ x { pgaType = "bit" } ]
+        }
 
 
     it "works for types with precisions and multiple words" $ do
-      (parsePGFunction "function f(x character varying) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "character varying" False] (PGSingle "void"))
-      (parsePGFunction "function f(x character varying (256)) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "character varying" False] (PGSingle "void"))
+      test "function f(x character varying) returns void" r {
+          pgfArguments = [ x { pgaType = "character varying" } ]
+        }
+
+      test "function f(x character varying (256)) returns void" r {
+          pgfArguments = [ x { pgaType = "character varying" } ]
+        }
 
 
     it "works for types with multiple precisions" $ do
-      (parsePGFunction "function f(x numeric) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "numeric" False] (PGSingle "void"))
+      test "function f(x numeric) returns void" r {
+          pgfArguments = [ x { pgaType = "numeric" } ]
+        }
 
-      (parsePGFunction "function f(x numeric(10)) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "numeric" False] (PGSingle "void"))
+      test "function f(x numeric(10)) returns void" r {
+          pgfArguments = [ x { pgaType = "numeric" } ]
+        }
 
-      (parsePGFunction "function f(x numeric(10,3)) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "numeric" False] (PGSingle "void"))
+      test "function f(x numeric(10,3)) returns void" r {
+          pgfArguments = [ x { pgaType = "numeric" } ]
+        }
 
-      (parsePGFunction "function f(x user_defined_type(1,2,3,4)) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "user_defined_type" False] (PGSingle "void"))
+      test "function f(x user_defined_type(1,2,3,4)) returns void" r {
+          pgfArguments = [ x { pgaType = "user_defined_type" } ]
+        }
 
 
     it "works for time types" $ do
-      (parsePGFunction "function f(x time) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "time" False] (PGSingle "void"))
+      test "function f(x time) returns void" r {
+          pgfArguments = [ x { pgaType = "time" } ]
+        }
 
-      (parsePGFunction "function f(x time (6)) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "time" False] (PGSingle "void"))
+      test "function f(x time (6)) returns void" r {
+          pgfArguments = [ x { pgaType = "time" } ]
+        }
 
-      (parsePGFunction "function f(x time (6) with time zone) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "time with time zone" False] (PGSingle "void"))
+      test "function f(x time (6) with time zone) returns void" r {
+          pgfArguments = [ x { pgaType = "time with time zone" } ]
+        }
 
-      (parsePGFunction "function f(x time with time zone) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "time with time zone" False] (PGSingle "void"))
+      test "function f(x time with time zone) returns void" r {
+          pgfArguments = [ x { pgaType = "time with time zone" } ]
+        }
 
-      (parsePGFunction "function f(x time without time zone) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "time without time zone" False] (PGSingle "void"))
+      test "function f(x time without time zone) returns void" r {
+          pgfArguments = [ x { pgaType = "time without time zone" } ]
+        }
 
-      (parsePGFunction "function f(x timestamp with time zone) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "timestamp with time zone" False] (PGSingle "void"))
+      test "function f(x timestamp with time zone) returns void" r {
+          pgfArguments = [ x { pgaType = "timestamp with time zone" } ]
+        }
 
-      (parsePGFunction "function f(x timestamptz) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "timestamptz" False] (PGSingle "void"))
+      test "function f(x timestamptz) returns void" r {
+          pgfArguments = [ x { pgaType = "timestamptz" } ]
+        }
 
 
     it "works for intervals" $ do
-      (parsePGFunction "function f(x interval) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "interval" False] (PGSingle "void"))
+      test "function f(x interval) returns void" r {
+          pgfArguments = [ x { pgaType = "interval" } ]
+        }
 
-      (parsePGFunction "function f(x interval month) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "interval month" False] (PGSingle "void"))
+      test "function f(x interval month) returns void" r {
+          pgfArguments = [ x { pgaType = "interval month" } ]
+        }
 
-      (parsePGFunction "function f(x interval minute to second (4)) returns void") >>= shouldBe
-        (PGFunction "" "f" [PGArgument "x" "interval minute to second" False] (PGSingle "void"))
+      test "function f(x interval minute to second (4)) returns void" r {
+          pgfArguments = [ x { pgaType = "interval minute to second" } ]
+        }