postgres-haskell
diff --git a/‎src/Database/PostgreSQL/Driver/Error.hs
Lines changed: 9 additions & 1 deletion b/‎src/Database/PostgreSQL/Driver/Error.hs
Lines changed: 9 additions & 1 deletion
diff --git a/‎src/Database/PostgreSQL/Driver/Query.hs
Lines changed: 10 additions & 11 deletions b/‎src/Database/PostgreSQL/Driver/Query.hs
Lines changed: 10 additions & 11 deletions
diff --git a/‎tests/Protocol.hs
Lines changed: 2 additions & 2 deletions b/‎tests/Protocol.hs
Lines changed: 2 additions & 2 deletions
@@ -13,7 +13,12 @@ import Database.PostgreSQL.Protocol.Types (ErrorDesc)
 --   ProtocolException
 --   IncorrectUsage.
 
-data IncorrectUsage = IncorrectUsage
+newtype IncorrectUsage = IncorrectUsage ByteString
+    deriving (Show)
+
+instance Exception IncorrectUsage where
+    displayException (IncorrectUsage msg) =
+        "Incorrect usage: " ++ BS.unpack msg
 
 newtype ProtocolException = ProtocolException ByteString
     deriving (Show)
@@ -22,6 +27,9 @@ instance Exception ProtocolException where
     displayException (ProtocolException msg) =
         "Exception in protocol, " ++ BS.unpack msg
 
+throwIncorrectUsage :: ByteString -> IO a
+throwIncorrectUsage = throwIO . IncorrectUsage
+
 throwProtocolEx :: ByteString -> IO a
 throwProtocolEx = throwIO . ProtocolException
 
 
@@ -40,11 +40,10 @@ sendSync conn = sendEncode conn $ encodeClientMessage Sync
 sendSimpleQuery :: ConnectionCommon -> B.ByteString -> IO (Either Error ())
 sendSimpleQuery conn q = do
     sendMessage (connRawConnection conn) $ SimpleQuery (StatementSQL q)
-    checkErrors <$> collectUntilReadyForQuery conn
+    (checkErrors =<<) <$> collectUntilReadyForQuery conn
   where
-    checkErrors = either
-        (Left . ReceiverError)
-        (maybe (Right ()) (Left . PostgresError) . findFirstError)
+    checkErrors = 
+        maybe (Right ()) (Left . PostgresError) . findFirstError
 
 waitReadyForQuery :: Connection -> IO (Either Error ())
 waitReadyForQuery conn =
@@ -56,8 +55,8 @@ waitReadyForQuery conn =
             -- We should wait for ReadyForQuery anyway.
             waitReadyForQuery conn
             pure . Left $ PostgresError e
-            -- TODO
-        (DataMessage _) -> error "incorrect usage waitReadyForQuery"
+        (DataMessage _)   -> throwIncorrectUsage
+            "Expected ReadyForQuery, but got DataRow message"
         DataReady        -> pure $ Right ()
 
 -- | Public
@@ -69,8 +68,8 @@ readNextData conn =
     handleDataMessage msg = case msg of
         (DataError e)      -> pure . Left $ PostgresError e
         (DataMessage rows) -> pure . Right $ rows
-        -- TODO
-        DataReady           -> error "incorrect usage readNextData"
+        DataReady          -> throwIncorrectUsage
+            "Expected DataRow message, but got ReadyForQuery"
 
 -- Helper
 sendBatchEndBy :: ClientMessage -> Connection -> [Query] -> IO ()
@@ -115,7 +114,7 @@ describeStatement conn stmt = do
            encodeClientMessage (Parse sname (StatementSQL stmt) V.empty)
         <> encodeClientMessage (DescribeStatement sname)
         <> encodeClientMessage Sync
-    msgs <- first ReceiverError <$> collectUntilReadyForQuery conn
+    msgs <-  collectUntilReadyForQuery conn
     either (pure . Left) parseMessages msgs
   where
     sname = StatementName ""
@@ -132,11 +131,11 @@ describeStatement conn stmt = do
 -- Collects all messages preceding `ReadyForQuery`
 collectUntilReadyForQuery
     :: ConnectionCommon
-    -> IO (Either ReceiverException [ServerMessage])
+    -> IO (Either Error [ServerMessage])
 collectUntilReadyForQuery conn = do
     msg <- readChan $ connOutChan conn
     case msg of
-        Left e                -> pure $ Left e
+        Left e                -> pure $ Left $ ReceiverError e
         Right ReadyForQuery{} -> pure $ Right []
         Right m               -> fmap (m:) <$> collectUntilReadyForQuery conn
 
 
@@ -124,15 +124,15 @@ testExtendedQueryNoData = withConnectionCommonAll $ \c -> do
 
 -- | Assert that list contains element satisfies predicat.
 assertContains
-    :: Either ReceiverException [ServerMessage]
+    :: Either Error [ServerMessage]
     -> (ServerMessage -> Bool)
     -> String -> Assertion
 assertContains (Left e) _ _ = assertFailure $ "Got Error" ++ show e
 assertContains (Right msgs) f name =
         assertBool ("Does not contain" ++ name) $ any f msgs
 
 -- | Assert there are on `ErrorResponse` in the list.
-assertNoErrorResponse :: Either ReceiverException [ServerMessage] -> Assertion
+assertNoErrorResponse :: Either Error [ServerMessage] -> Assertion
 assertNoErrorResponse (Left e) = assertFailure $ "Got Error" ++ show e
 assertNoErrorResponse (Right msgs) =
     assertBool "Occured ErrorResponse" $ all (not . isError) msgs