add tests

Author: itchyny

test/FileSpec.hs

@@ -0,0 +1,107 @@
+module FileSpec (spec) where
+
+import Data.Char (isSpace)
+import System.IO
+import Test.Hspec (Spec, describe, it, shouldBe, shouldReturn)
+
+import File
+import Option
+
+spec :: Spec
+spec = do
+  readFromFileSpec
+  detectSplitterSpec
+  splitFixedSizeSpec
+
+readFromFileSpec :: Spec
+readFromFileSpec =
+  describe "readFromFile" $ do
+    let opts = Option { skipHeader = True,
+                        outputHeader = False,
+                        delimiter = Nothing,
+                        tabDelimited = False,
+                        outputDelimiter = Nothing,
+                        tabDelimitedOutput = False,
+                        keepLeadingWhiteSpace = False,
+                        gzipped = False,
+                        queryFile = Nothing,
+                        query = Nothing }
+
+    it "should read from a test file" $ do
+      handle <- openFile "test/tests/basic.csv" ReadMode
+      let expected = (["foo", "bar", "baz"], [["a0", "1", "a2"], ["b0", "3", "b2"], ["c0", "", "c2"]])
+      readFromFile opts handle `shouldReturn` expected
+      hClose handle
+
+    it "should read from a gzipped file" $ do
+      handle <- openFile "test/tests/basic.csv.gz" ReadMode
+      let expected = (["foo", "bar", "baz"], [["a0", "1", "a2"], ["b0", "3", "b2"], ["c0", "", "c2"]])
+      readFromFile (opts { gzipped = True }) handle `shouldReturn` expected
+      hClose handle
+
+    it "should read from a test file which contains a multiline cell" $ do
+      handle <- openFile "test/tests/multiline.csv" ReadMode
+      let expected = (["foo", "bar", "baz", "qux", "quux"], [["a0", "1", "a2\nb0\",3,\"b2\nc0", "", "c2"]])
+      readFromFile opts handle `shouldReturn` expected
+      hClose handle
+
+detectSplitterSpec :: Spec
+detectSplitterSpec =
+  describe "detectSplitter" $ do
+
+    it "should detect the column splitter space" $ do
+      let (headLine, secondLine) = ("c0 c1 c2 c3 c4", "0 1 2 3 4")
+      detectSplitter headLine secondLine ' ' `shouldBe` True
+      detectSplitter headLine secondLine '\t' `shouldBe` True
+
+    it "should detect the column splitter comma" $ do
+      let (headLine, secondLine) = ("c0,c1,c2,c3,c4", "0,1,2,3,4")
+      detectSplitter headLine secondLine ',' `shouldBe` True
+
+    it "should detect the column splitter comma even if the column title has spaces" $ do
+      let (headLine, secondLine) = ("foo bar baz,qux quux,hoge huga,cmd", "100,200,300,foo bar baz qux")
+      detectSplitter headLine secondLine ',' `shouldBe` True
+
+splitFixedSizeSpec :: Spec
+splitFixedSizeSpec =
+  describe "splitFixedSize" $ do
+
+    it "should split the String with isSpace" $ do
+      let (input, expected) = ("c0 c1 c2", [ "c0", "c1", "c2" ])
+      splitFixedSize isSpace 0 input `shouldBe` expected
+
+    it "should ignore the successive spaces when splitting with isSpace" $ do
+      let (input, expected) = ("c0 c1   c2   \t\t c3", [ "c0", "c1", "c2", "c3" ])
+      splitFixedSize isSpace 0 input `shouldBe` expected
+
+    it "should take the column size into account when splitting with isSpace" $ do
+      let (input, (n1, expected1), (n2, expected2), (n3, expected3), (n4, expected4))
+            = ("c0 c1   c2   \t\t c3  c4  c5  ",
+               (1, [ "c0 c1   c2   \t\t c3  c4  c5  " ]),
+               (4, [ "c0", "c1", "c2", "c3  c4  c5  " ]),
+               (6, [ "c0", "c1", "c2", "c3", "c4", "c5  " ]),
+               (9, [ "c0", "c1", "c2", "c3", "c4", "c5", "", "", "" ]))
+      splitFixedSize isSpace n1 input `shouldBe` expected1
+      splitFixedSize isSpace n2 input `shouldBe` expected2
+      splitFixedSize isSpace n3 input `shouldBe` expected3
+      splitFixedSize isSpace n4 input `shouldBe` expected4
+
+    it "should split the String with (==',')" $ do
+      let (input, expected) = ("c0,c1,c2", [ "c0", "c1", "c2" ])
+      splitFixedSize (==',') 0 input `shouldBe` expected
+
+    it "should not ignore the successive commas when splitting with (==',')" $ do
+      let (input, expected) = ("c0,c1,c2,,c3,,,c4", [ "c0", "c1", "c2", "", "c3", "", "", "c4" ])
+      splitFixedSize (==',') 0 input `shouldBe` expected
+
+    it "should take the column size into account when splitting with (==',')" $ do
+      let (input, (n1, expected1), (n2, expected2), (n3, expected3), (n4, expected4))
+            = ("c0,c1,,c2,foo bar baz,c4",
+               (1, [ "c0,c1,,c2,foo bar baz,c4" ]),
+               (4, [ "c0", "c1", "", "c2,foo bar baz,c4" ]),
+               (6, [ "c0", "c1", "", "c2", "foo bar baz", "c4" ]),
+               (9, [ "c0", "c1", "", "c2", "foo bar baz", "c4", "", "", "" ]))
+      splitFixedSize (==',') n1 input `shouldBe` expected1
+      splitFixedSize (==',') n2 input `shouldBe` expected2
+      splitFixedSize (==',') n3 input `shouldBe` expected3
+      splitFixedSize (==',') n4 input `shouldBe` expected4

test/MainSpec.hs

@@ -0,0 +1,38 @@
+module MainSpec (spec) where
+
+import Control.Applicative
+import Control.Monad
+import System.IO
+import System.Process
+import Test.Hspec (Spec, describe, it, shouldReturn)
+
+spec :: Spec
+spec = qhsSpec
+
+qhsSpec :: Spec
+qhsSpec =
+
+  describe "qhs" $ do
+
+    let tests = [
+          "basic", "columns", "stdin", "stdin_hyphen", "header", "where",
+          "count", "is_null", "not_null", "output_header", "tab", "tab2",
+          "spaces", "output_delimiter", "tab_delimited_output", "multiline",
+          "query_file", "gzip", "gzip_stdin", "avg", "sum", "avg_sum", "seq",
+          "group", "group_sum", "empty_query", "empty_query_file", "concat",
+          "join", "invalid", "version"
+          ]
+
+    forM_ tests $ \test -> do
+
+      it ("should be executed correctly: " ++ test) $ do
+        let cp = (shell ("bash " ++ test ++ ".sh")) {
+              cwd = Just "test/tests",
+              std_out = CreatePipe,
+              std_err = CreatePipe
+            }
+        (_, Just out, Just err, _) <- createProcess cp
+        hSetBuffering out NoBuffering
+        hSetBuffering err NoBuffering
+        outExpected <- readFile $ "test/tests/" ++ test ++ ".out"
+        liftA2 (++) (hGetContents out) (hGetContents err) `shouldReturn` outExpected

test/ParserSpec.hs

@@ -0,0 +1,72 @@
+module ParserSpec (spec) where
+
+import Data.Either
+import qualified Data.Map as Map
+import Test.Hspec (Spec, describe, it, shouldBe, shouldSatisfy)
+
+import Parser
+
+spec :: Spec
+spec = do
+  replaceTableNamesSpec
+  roughlyExtractTableNamesSpec
+  replaceBackTableNamesSpec
+  extractTableNamesSpec
+
+replaceTableNamesSpec :: Spec
+replaceTableNamesSpec =
+  describe "replaceTableNames" $ do
+
+    it "should replace the file names with table names" $ do
+      let query = "SELECT * FROM table0 WHERE c0 > 0"
+      let expected1 = ("SELECT * FROM ttable WHERE c0 > 0",
+                       Map.fromList [("table0", "ttable")])
+      replaceTableNames query `shouldBe` expected1
+
+    it "should replace multiple file names with table names" $ do
+      let query = "SELECT * FROM ./src/table0.csv\nJOIN /tmp/table1.csv\tON c1 = c2 WHERE c0 > 0"
+      let expected2 = ("SELECT * FROM tsrctable0csvWor\nJOIN ttmptable1csvWo\tON c1 = c2 WHERE c0 > 0",
+                       Map.fromList [("./src/table0.csv", "tsrctable0csvWor"),("/tmp/table1.csv", "ttmptable1csvWo")])
+      replaceTableNames query `shouldBe` expected2
+
+roughlyExtractTableNamesSpec :: Spec
+roughlyExtractTableNamesSpec =
+  describe "roughlyExtractTableNames" $ do
+
+    it "should roughly extract table name" $ do
+      roughlyExtractTableNames "SELECT * FROM table0 WHERE c0 > 0" `shouldBe` [ "table0" ]
+      roughlyExtractTableNames "select * from table0 where c0 > 0" `shouldBe` [ "table0" ]
+
+    it "should roughly extract multiple table names" $ do
+      roughlyExtractTableNames "SELECT * FROM table0 JOIN table1 ON c1 = c2 WHERE c0 > 0" `shouldBe` [ "table0", "table1" ]
+      roughlyExtractTableNames "select * from table0 join table1 on c1 = c2 where c0 > 0" `shouldBe` [ "table0", "table1" ]
+
+replaceBackTableNamesSpec :: Spec
+replaceBackTableNamesSpec =
+  describe "replaceBackTableNames" $ do
+
+    it "should replace back table names to the file names" $ do
+      let query = "SELECT * FROM table0 WHERE c0 > 0"
+      let (query', tableMap) = replaceTableNames query
+      replaceBackTableNames tableMap query' `shouldBe` query
+
+    it "should replace back multiple table names with the file names" $ do
+      let query = "SELECT * FROM ./src/table0.csv\nJOIN /tmp/table1.csv\tON c1 = c2 WHERE c0 > 0"
+      let (query', tableMap) = replaceTableNames query
+      replaceBackTableNames tableMap query' `shouldBe` query
+
+extractTableNamesSpec :: Spec
+extractTableNamesSpec =
+  describe "extractTableNames" $ do
+
+    it "should extract table name" $ do
+      extractTableNames "SELECT * FROM table0 WHERE c0 > 0" "" `shouldBe` Right [ "table0" ]
+      extractTableNames "select * from table0 where c0 > 0" "" `shouldBe` Right [ "table0" ]
+
+    it "should extract multiple table names" $ do
+      extractTableNames "SELECT * FROM table0 JOIN table1 ON c1 = c2 WHERE c0 > 0" "" `shouldBe` Right [ "table0", "table1" ]
+      extractTableNames "select * from table0 join table1 on c1 = c2 where c0 > 0" "" `shouldBe` Right [ "table0", "table1" ]
+
+    it "should return a parse error" $ do
+      extractTableNames "SELECT ** FROM table0 WHERE c0 > 0" "" `shouldSatisfy` isLeft
+      extractTableNames "SELECT * FROM table0 WHERE > 0" "" `shouldSatisfy` isLeft

test/SQLSpec.hs

@@ -0,0 +1,72 @@
+module SQLSpec (spec) where
+
+import Control.Monad
+import qualified Database.SQLite as SQLite
+import Test.Hspec (Spec, describe, it, shouldBe)
+
+import SQL
+
+spec :: Spec
+spec = do
+  openCloseSpec
+  tableSpec
+
+openCloseSpec :: Spec
+openCloseSpec =
+  describe "open, close" $ do
+
+    it "should not throw exception" $ do
+      conn <- SQL.open ":memory:"
+      SQL.close conn
+
+tableSpec :: Spec
+tableSpec =
+  describe "createTable, insertRow, execute" $ do
+
+    it "should create a table" $ do
+      conn <- SQL.open ":memory:"
+      let columns = ["foo", "bar", "baz", "qux"]
+      let types = repeat $ SQLite.SQLChar Nothing
+      _ <- SQL.createTable conn "test_table" columns types
+      let entries = [ ["c0", "c1", "c2", "c3"],
+                      ["d0", "d1", "d2", "d3"],
+                      ["f0", "f1", "f2", "f3"] ]
+      forM_ entries $ SQL.insertRow conn "test_table" columns types
+      ret <- SQL.execute conn "SELECT * FROM test_table"
+      ret `shouldBe` Right [map (zip columns) entries]
+      SQL.close conn
+
+    it "should take care of null values in a number column" $ do
+      conn <- SQL.open ":memory:"
+      let columns = ["foo", "num", "bar", "baz"]
+      let types = cycle [SQLite.SQLChar Nothing, SQLite.SQLInt SQLite.NORMAL False False]
+      _ <- SQL.createTable conn "test_table" columns types
+      let entries = [ ["c0", "2", "c2", "3"],
+                      ["d0", "", "d2", "2"],
+                      ["f0", "3", "f2", ""],
+                      ["e0", "", "e2", "4"] ]
+      forM_ entries $ SQL.insertRow conn "test_table" columns types
+      ret0 <- SQL.execute conn "SELECT * FROM test_table"
+      ret0 `shouldBe` Right [map (zip columns) entries]
+      ret1 <- SQL.execute conn "SELECT * FROM test_table WHERE num IS NOT NULL"
+      ret1 `shouldBe` Right [map (zip columns) [ e | e <- entries, e !! 1 /= ""]]
+      ret2 <- SQL.execute conn "SELECT avg(num) FROM test_table"
+      ret2 `shouldBe` Right [[[("avg(num)", "2.5")]]]
+      ret3 <- SQL.execute conn "SELECT avg(baz) FROM test_table"
+      ret3 `shouldBe` Right [[[("avg(baz)", "3.0")]]]
+      SQL.close conn
+
+    it "can create a table when name and column names contain spaces" $ do
+      conn <- SQL.open ":memory:"
+      let columns = ["foo bar", "baz qux"]
+      let types = repeat $ SQLite.SQLChar Nothing
+      _ <- SQL.createTable conn "test table" columns types
+      let entries = [ ["c0 c1", "c2 c3"],
+                      ["d0 d1", "d2 d3"],
+                      ["f0 f1", "f2 f3"] ]
+      forM_ entries $ SQL.insertRow conn "test table" columns types
+      ret0 <- SQL.execute conn "SELECT * FROM `test table`"
+      ret0 `shouldBe` Right [map (zip columns) entries]
+      ret1 <- SQL.execute conn "SELECT `foo bar` FROM `test table`"
+      ret1 `shouldBe` Right [map (zip columns) (map (take 1) entries)]
+      SQL.close conn

test/Spec.hs

@@ -0,0 +1 @@
+{-# OPTIONS_GHC -F -pgmF hspec-discover #-}

test/tests/avg.out

@@ -0,0 +1 @@
+2.0

test/tests/avg.sh

@@ -0,0 +1 @@
+qhs -H "SELECT avg(bar) FROM basic.csv"

test/tests/avg_sum.out

@@ -0,0 +1,2 @@
+avg(bar) sum(bar)
+2.0 4

test/tests/avg_sum.sh

@@ -0,0 +1 @@
+qhs -H -O "SELECT avg(bar),sum(bar) FROM basic.csv"

test/tests/basic.csv

@@ -0,0 +1,4 @@
+foo,bar,baz
+a0,1,a2
+b0,3,b2
+c0,,c2

test/tests/basic.csv.gz

@@ -0,0 +1,4 @@
+foo bar baz
+a0 1 a2
+b0 3 b2
+c0  c2

test/tests/basic.out

@@ -0,0 +1 @@
+qhs "SELECT * FROM basic.csv"

test/tests/basic.sh

@@ -0,0 +1,13 @@
+foo,bar,baz
+a0,1,a2
+b1,2,b1
+c1,,c1
+a0,2,a1
+b0,1,b2
+c1,,c2
+a0,3,a3
+c1,,c3
+c0,,c1
+b1,2,b3
+c0,,c2
+a0,2,a3

test/tests/big.csv

@@ -0,0 +1,4 @@
+foo baz
+a0 a2
+b0 b2
+c0 c2

test/tests/columns.out

@@ -0,0 +1 @@
+qhs "SELECT c1,c3 FROM basic.csv"

test/tests/columns.sh

@@ -0,0 +1,8 @@
+foo||baz
+a0a2
+b1b1
+a0a1
+b0b2
+a0a3
+b1b3
+a0a3

test/tests/concat.out

@@ -0,0 +1 @@
+qhs -H -O "SELECT foo||baz FROM big.csv WHERE bar IS NOT NULL"

test/tests/concat.sh

@@ -0,0 +1,2 @@
+COUNT(*)
+2

test/tests/count.out

@@ -0,0 +1 @@
+qhs -H -O "SELECT COUNT(*) FROM basic.csv WHERE baz <> 'b2'"

test/tests/count.sh

@@ -0,0 +1,2 @@
+Query cannot be empty.
+For basic information, try the `--help' option.

test/tests/empty.sql

@@ -0,0 +1 @@
+qhs ""

test/tests/empty_query.out

@@ -0,0 +1,2 @@
+Query cannot be empty.
+For basic information, try the `--help' option.

test/tests/empty_query.sh

@@ -0,0 +1 @@
+qhs -q empty.sql

test/tests/empty_query_file.out

@@ -0,0 +1,4 @@
+foo cnt
+a0 4
+c1 3
+b1 2

test/tests/empty_query_file.sh

@@ -0,0 +1 @@
+qhs -H -O "SELECT foo,COUNT(*) cnt FROM big.csv GROUP BY foo ORDER BY cnt DESC LIMIT 3"

test/tests/group.out

@@ -0,0 +1,4 @@
+foo sum(bar) cnt
+a0 8 4
+b1 4 2
+b0 1 1

test/tests/group.sh

@@ -0,0 +1 @@
+qhs -H -O "SELECT foo,sum(bar),COUNT(*) cnt FROM big.csv WHERE bar IS NOT NULL GROUP BY foo ORDER BY cnt DESC LIMIT 3"

test/tests/group_sum.out

@@ -0,0 +1,4 @@
+foo bar baz
+a0 1 a2
+b0 3 b2
+c0  c2

test/tests/group_sum.sh

@@ -0,0 +1 @@
+qhs "SELECT * FROM basic.csv.gz"

test/tests/gzip.out

@@ -0,0 +1,2 @@
+a0 a2
+b0 b2

test/tests/gzip.sh

@@ -0,0 +1 @@
+cat basic.csv.gz | qhs -H -z "SELECT foo,baz FROM - WHERE bar IS NOT NULL"

test/tests/gzip_stdin.out

@@ -0,0 +1,3 @@
+a0 a2
+b0 b2
+c0 c2

test/tests/gzip_stdin.sh

@@ -0,0 +1 @@
+qhs -H "SELECT foo,baz FROM basic.csv"