Factor out some new libraries

	word64-map:
		Data.Word64Map
	network-addr:
		Network.Address
	tox-crypto:
		Crypto.Tox
	lifted-concurrent:
		Control.Concurrent.Lifted.Instrument
		Control.Concurrent.Async.Lifted.Instrument
	psq-wrap:
		Data.Wrapper.PSQInt
		Data.Wrapper.PSQ
	minmax-psq:
		Data.MinMaxPSQ
        tasks:
                Control.Concurrent.Tasks
	kad:
		Network.Kademlia
		Network.Kademlia.Bootstrap
		Network.Kademlia.Routing
		Network.Kademlia.CommonAPI
		Network.Kademlia.Persistence
		Network.Kademlia.Search

27 files changed, 2208 insertions, 0 deletions

diff --git a/dht/bittorrent/tests/Network/BitTorrent/Client/HandleSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/Client/HandleSpec.hs
new file mode 100644
index 00000000..d51bab02
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Client/HandleSpec.hs
@@ -0,0 +1,19 @@
+module Network.BitTorrent.Client.HandleSpec (spec) where
+import Data.Default
+import Test.Hspec
+
+import Data.Torrent
+import Network.BitTorrent.Client
+import Network.BitTorrent.Client.Handle
+
+data_dir :: FilePath
+data_dir = "data"
+
+spec :: Spec
+spec = do
+  describe "openMagnet" $ do
+    it "should add new infohash to index" $ do
+      simpleClient $ do
+        _ <- openMagnet data_dir (nullMagnet def)
+        _ <- getHandle def
+        return ()
diff --git a/dht/bittorrent/tests/Network/BitTorrent/CoreSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/CoreSpec.hs
new file mode 100644
index 00000000..e9b17a42
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/CoreSpec.hs
@@ -0,0 +1,309 @@
+{-# LANGUAGE FlexibleInstances    #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+module Network.BitTorrent.CoreSpec (spec) where
+import Control.Applicative
+import Data.BEncode as BE
+import Data.ByteString.Lazy as BL
+#if MIN_VERSION_iproute(1,7,4)
+import Data.IP hiding (fromSockAddr)
+#else
+import Data.IP
+#endif
+import Data.Serialize as S
+import Data.String
+import Data.Text.Encoding as T
+import Data.Word
+import Network
+import Test.Hspec
+import Test.QuickCheck
+import Test.QuickCheck.Instances ()
+
+import Network.BitTorrent.Address
+
+
+instance Arbitrary IPv4 where
+  arbitrary = do
+    a <- choose (0, 255)
+    b <- choose (0, 255)
+    c <- choose (0, 255)
+    d <- choose (0, 255)
+    return $ toIPv4 [a, b, c, d]
+
+instance Arbitrary IPv6 where
+  arbitrary = do
+    a <- choose (0, fromIntegral (maxBound :: Word16))
+    b <- choose (0, fromIntegral (maxBound :: Word16))
+    c <- choose (0, fromIntegral (maxBound :: Word16))
+    d <- choose (0, fromIntegral (maxBound :: Word16))
+    e <- choose (0, fromIntegral (maxBound :: Word16))
+    f <- choose (0, fromIntegral (maxBound :: Word16))
+    g <- choose (0, fromIntegral (maxBound :: Word16))
+    h <- choose (0, fromIntegral (maxBound :: Word16))
+    return $ toIPv6 [a, b, c, d, e, f, g, h]
+
+instance Arbitrary IP where
+  arbitrary = frequency
+    [ (1, IPv4 <$> arbitrary)
+    , (1, IPv6 <$> arbitrary)
+    ]
+
+instance Arbitrary PortNumber where
+  arbitrary = fromIntegral <$> (arbitrary :: Gen Word16)
+
+instance Arbitrary PeerId where
+  arbitrary = oneof
+    [ azureusStyle defaultClientId defaultVersionNumber
+        <$> (T.encodeUtf8 <$> arbitrary)
+    , shadowStyle  'X'             defaultVersionNumber
+        <$> (T.encodeUtf8 <$> arbitrary)
+    ]
+
+instance Arbitrary a => Arbitrary (PeerAddr a) where
+  arbitrary = PeerAddr <$> arbitrary <*> arbitrary <*> arbitrary
+
+instance Arbitrary NodeId where
+  arbitrary = fromString <$> vector 20
+
+instance Arbitrary a => Arbitrary (NodeAddr a) where
+  arbitrary = NodeAddr <$> arbitrary <*> arbitrary
+
+instance Arbitrary a => Arbitrary (NodeInfo a) where
+  arbitrary = NodeInfo <$> arbitrary <*> arbitrary
+
+spec :: Spec
+spec = do
+  describe "PeerId" $ do
+    it "properly bencoded" $ do
+      BE.decode "20:01234567890123456789"
+        `shouldBe` Right ("01234567890123456789" :: PeerId)
+
+  describe "PortNumber" $ do
+    it "properly serialized" $ do
+      S.decode "\x1\x2" `shouldBe` Right (258 :: PortNumber)
+      S.encode (258 :: PortNumber) `shouldBe` "\x1\x2"
+
+    it "properly bencoded" $ do
+      BE.decode "i80e" `shouldBe` Right (80 :: PortNumber)
+
+    it "fail if port number is invalid" $ do
+      (BE.decode "i-10e" :: BE.Result PortNumber)
+        `shouldBe`
+        Left "fromBEncode: unable to decode PortNumber: -10"
+
+      (BE.decode "i70000e" :: BE.Result PortNumber)
+        `shouldBe`
+        Left "fromBEncode: unable to decode PortNumber: 70000"
+
+  describe "Peer IPv4" $ do
+    it "properly serialized" $ do
+      S.decode "\x1\x2\x3\x4" `shouldBe` Right (toIPv4 [1, 2, 3, 4])
+      S.encode (toIPv4 [1, 2, 3, 4]) `shouldBe` "\x1\x2\x3\x4"
+
+    it "properly serialized (iso)" $ property $ \ ip -> do
+      S.decode (S.encode ip) `shouldBe` Right (ip :: IPv4)
+
+    it "properly bencoded" $ do
+      BE.decode "11:168.192.0.1" `shouldBe` Right (toIPv4 [168, 192, 0, 1])
+      BE.encode (toIPv4 [168, 192, 0, 1]) `shouldBe` "11:168.192.0.1"
+
+    it "properly bencoded (iso)" $ property $ \ ip ->
+      BE.decode (BL.toStrict (BE.encode ip)) `shouldBe` Right (ip :: IPv4)
+
+    it "fail gracefully on invalid strings" $ do
+      BE.decode "3:1.1" `shouldBe`
+        (Left "fromBEncode: unable to decode IP: 1.1" :: BE.Result IPv4)
+
+    it "fail gracefully on invalid bencode" $ do
+      BE.decode "i10e" `shouldBe`
+        (Left "fromBEncode: unable to decode IP: addr should be a bstring"
+         :: BE.Result IPv4)
+
+  describe "Peer IPv6" $ do
+    it "properly serialized" $ do
+      S.decode "\x1\x2\x3\x4\x5\x6\x7\x8\x9\xa\xb\xc\xd\xe\xf\x10"
+        `shouldBe`
+        Right ("102:304:506:708:90a:b0c:d0e:f10" :: IPv6)
+
+      S.encode ("102:304:506:708:90a:b0c:d0e:f10" :: IPv6)
+        `shouldBe`
+        "\x1\x2\x3\x4\x5\x6\x7\x8\x9\xa\xb\xc\xd\xe\xf\x10"
+
+    it "properly serialized (iso)" $ property $ \ ip ->
+      S.decode (S.encode ip) `shouldBe` Right (ip :: IPv6)
+
+    it "properly bencoded" $ do
+      BE.decode "3:::1" `shouldBe` Right (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1])
+      BE.encode (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1]) `shouldBe`
+        "23:00:00:00:00:00:00:00:01"
+
+      BE.decode "23:00:00:00:00:00:00:00:01"
+        `shouldBe`
+        Right (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1])
+
+    it "properly bencoded iso" $ property $ \ ip ->
+      BE.decode (BL.toStrict (BE.encode ip)) `shouldBe` Right (ip :: IPv4)
+
+    it "fail gracefully on invalid strings" $ do
+      BE.decode "4:g::1" `shouldBe`
+        (Left "fromBEncode: unable to decode IP: g::1" :: BE.Result IPv6)
+
+    it "fail gracefully on invalid bencode" $ do
+      BE.decode "i10e" `shouldBe`
+        (Left "fromBEncode: unable to decode IP: addr should be a bstring"
+         :: BE.Result IPv6)
+
+
+  describe "Peer IP" $ do
+    it "properly serialized IPv6" $ do
+      S.decode "\x1\x2\x3\x4\x5\x6\x7\x8\x9\xa\xb\xc\xd\xe\xf\x10"
+        `shouldBe`
+        Right ("102:304:506:708:90a:b0c:d0e:f10" :: IP)
+
+      S.encode ("102:304:506:708:90a:b0c:d0e:f10" :: IP)
+        `shouldBe`
+        "\x1\x2\x3\x4\x5\x6\x7\x8\x9\xa\xb\xc\xd\xe\xf\x10"
+
+    it "properly serialized (iso) IPv6" $ property $ \ ip ->
+      S.decode (S.encode ip) `shouldBe` Right (ip :: IP)
+
+    it "properly serialized IPv4" $ do
+      S.decode "\x1\x2\x3\x4" `shouldBe` Right (IPv4 $ toIPv4 [1, 2, 3, 4])
+      S.encode (toIPv4 [1, 2, 3, 4]) `shouldBe` "\x1\x2\x3\x4"
+
+    it "properly serialized (iso) IPv4" $ property $ \ ip -> do
+      S.decode (S.encode ip) `shouldBe` Right (ip :: IP)
+
+    it "properly bencoded" $ do
+      BE.decode "11:168.192.0.1" `shouldBe`
+        Right (IPv4 (toIPv4 [168, 192, 0, 1]))
+
+      BE.decode "3:::1" `shouldBe` Right
+         (IPv6 (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1]))
+
+      BE.encode (IPv6 (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1])) `shouldBe`
+        "23:00:00:00:00:00:00:00:01"
+
+      BE.decode "23:00:00:00:00:00:00:00:01"
+        `shouldBe`
+        Right (IPv6 (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1]))
+
+    it "properly bencoded iso" $ property $ \ ip ->
+      BE.decode (BL.toStrict (BE.encode ip)) `shouldBe` Right (ip :: IP)
+
+    it "fail gracefully on invalid strings" $ do
+      BE.decode "4:g::1" `shouldBe`
+        (Left "fromBEncode: unable to decode IP: g::1" :: BE.Result IP)
+
+    it "fail gracefully on invalid bencode" $ do
+      BE.decode "i10e" `shouldBe`
+        (Left "fromBEncode: unable to decode IP: addr should be a bstring"
+         :: BE.Result IP)
+
+  describe "PeerAddr" $ do
+    it "IsString" $ do
+      ("127.0.0.1:80" :: PeerAddr IP)
+        `shouldBe` PeerAddr Nothing "127.0.0.1" 80
+
+      ("127.0.0.1:80" :: PeerAddr IPv4)
+        `shouldBe` PeerAddr Nothing "127.0.0.1" 80
+
+      ("[::1]:80"     :: PeerAddr IP)
+        `shouldBe` PeerAddr Nothing "::1"       80
+
+      ("[::1]:80"     :: PeerAddr IPv6)
+        `shouldBe` PeerAddr Nothing "::1"       80
+
+    it "properly bencoded (iso)" $ property $ \ addr ->
+      BE.decode (BL.toStrict (BE.encode addr))
+        `shouldBe` Right (addr :: PeerAddr IP)
+
+
+    it "properly bencoded (ipv4)" $ do
+      BE.decode "d2:ip11:168.192.0.1\
+                 \7:peer id20:01234567890123456789\
+                 \4:porti6881e\
+                 \e"
+        `shouldBe`
+        Right (PeerAddr (Just "01234567890123456789")
+                        (IPv4 (toIPv4 [168, 192, 0, 1]))
+                        6881)
+
+    it "properly bencoded (ipv6)" $ do
+      BE.decode "d2:ip3:::1\
+                 \7:peer id20:01234567890123456789\
+                 \4:porti6881e\
+                 \e"
+        `shouldBe`
+        Right (PeerAddr (Just "01234567890123456789")
+                        (IPv6 (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1]))
+                        6881)
+
+    it "peer id is optional" $ do
+      BE.decode "d2:ip11:168.192.0.1\
+                 \4:porti6881e\
+                 \e"
+        `shouldBe`
+        Right (PeerAddr Nothing (IPv4 (toIPv4 [168, 192, 0, 1])) 6881)
+
+    it "has sock addr for both ipv4 and ipv6" $ do
+      show (peerSockAddr "128.0.0.1:80") `shouldBe` "128.0.0.1:80"
+      show (peerSockAddr "[::1]:8080"  ) `shouldBe` "[::1]:8080"
+
+  describe "NodeId" $ do
+    it "properly serialized" $ do
+      S.decode "mnopqrstuvwxyz123456"
+        `shouldBe` Right ("mnopqrstuvwxyz123456" :: NodeId)
+
+      S.encode ("mnopqrstuvwxyz123456" :: NodeId)
+        `shouldBe` "mnopqrstuvwxyz123456"
+
+    it "properly serialized (iso)" $ property $ \ nid ->
+      S.decode (S.encode nid) `shouldBe`
+        Right (nid :: NodeId)
+
+  describe "NodeAddr" $ do
+    it "properly serialized" $ do
+      S.decode "\127\0\0\1\1\2" `shouldBe`
+        Right ("127.0.0.1:258" :: NodeAddr IPv4)
+
+    it "properly serialized (iso)" $ property $ \ nid ->
+      S.decode (S.encode nid) `shouldBe`
+        Right (nid :: NodeAddr IPv4)
+
+  describe "NodeInfo" $ do
+    it "properly serialized" $ do
+      S.decode "mnopqrstuvwxyz123456\
+               \\127\0\0\1\1\2" `shouldBe` Right
+       (NodeInfo "mnopqrstuvwxyz123456" "127.0.0.1:258" :: NodeInfo IPv4)
+
+    it "properly serialized (iso)" $ property $ \ nid ->
+      S.decode (S.encode nid) `shouldBe`
+        Right (nid :: NodeInfo IPv4)
+
+  --  see <http://bittorrent.org/beps/bep_0020.html>
+  describe "Fingerprint" $ do
+    it "decode mainline encoded peer id" $ do
+      fingerprint "M4-3-6--xxxxxxxxxxxx" `shouldBe` "Mainline-4.3.6"
+      fingerprint "M4-20-8-xxxxxxxxxxxx" `shouldBe` "Mainline-4.20.8"
+
+    it "decode azureus encoded peer id" $ do
+      fingerprint "-AZ2060-xxxxxxxxxxxx" `shouldBe` "Azureus-2060"
+      fingerprint "-BS0000-xxxxxxxxxxxx" `shouldBe` "BTSlave-0"
+
+    it "decode Shad0w style peer id" $ do
+      fingerprint "S58B-----xxxxxxxxxxx" `shouldBe` "Shadow-5.8.11"
+      fingerprint "T58B-----xxxxxxxxxxx" `shouldBe` "BitTornado-5.8.11"
+
+    it "decode bitcomet style peer id" $ do
+      fingerprint "exbc01xxxxxxxxxxxxxx" `shouldBe` "BitComet-48.49"
+      fingerprint "FUTB01xxxxxxxxxxxxxx" `shouldBe` "BitComet-48.49"
+      fingerprint "exbc01LORDxxxxxxxxxx" `shouldBe` "BitLord-48.49"
+
+    it "decode opera style peer id" $ do
+      fingerprint "OP0123xxxxxxxxxxxxxx" `shouldBe` "Opera-123"
+
+    it "decode ML donkey style peer id" $ do
+      fingerprint "-ML2.7.2-xxxxxxxxxxx" `shouldBe` "MLdonkey-0"
+
+-- TODO XBT, Bits on Wheels, Queen Bee, BitTyrant, TorrenTopia,
+-- BitSpirit, Rufus, G3 Torrent, FlashGet
diff --git a/dht/bittorrent/tests/Network/BitTorrent/DHT/MessageSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/DHT/MessageSpec.hs
new file mode 100644
index 00000000..6f3c7489
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/DHT/MessageSpec.hs
@@ -0,0 +1,221 @@
+{-# LANGUAGE RecordWildCards #-}
+module Network.BitTorrent.DHT.MessageSpec (spec) where
+import Control.Monad.Reader
+import Control.Monad.Logger
+import Control.Concurrent
+import Data.BEncode as BE
+import Data.ByteString.Lazy as BL
+import Data.Default
+import Data.List as L
+import Data.Maybe
+import Network.BitTorrent.Address
+import Network.BitTorrent.DHT.Message
+import qualified Network.KRPC as KRPC (def)
+import Network.KRPC hiding (def)
+import Network.Socket (PortNumber)
+import Test.Hspec
+import Test.QuickCheck
+import System.Timeout
+
+import Data.TorrentSpec                 ()
+import Network.BitTorrent.CoreSpec      ()
+import Network.BitTorrent.DHT.TokenSpec ()
+
+-- Arbitrary queries and responses.
+instance Arbitrary Ping where arbitrary = pure Ping
+instance Arbitrary FindNode where arbitrary = FindNode <$> arbitrary
+instance Arbitrary ip => Arbitrary (NodeFound ip) where arbitrary = NodeFound <$> arbitrary
+instance Arbitrary GetPeers where arbitrary = GetPeers <$> arbitrary
+instance Arbitrary ip => Arbitrary (GotPeers ip) where arbitrary =  GotPeers <$> arbitrary <*> arbitrary
+instance Arbitrary Announce where arbitrary = Announce <$> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary
+instance Arbitrary Announced where arbitrary = pure Announced
+instance Arbitrary x => Arbitrary (Query x) where arbitrary = Query <$> arbitrary <*> arbitrary <*> arbitrary
+instance Arbitrary x => Arbitrary (Response x) where arbitrary = Response <$> arbitrary <*> arbitrary
+
+instance MonadLogger IO where
+  monadLoggerLog _ _ _ _ = return ()
+
+remoteAddr :: SockAddr
+remoteAddr = SockAddrInet 6881 (256 * 256 * 256 + 127)
+
+thisAddr :: SockAddr
+thisAddr = SockAddrInet 60000 (256 * 256 * 256 + 127)
+
+thisPort :: PortNumber
+thisPort = 60001
+
+rpc :: ReaderT (Manager IO) IO a -> IO a
+rpc action = do
+  withManager KRPC.def thisAddr [] $ runReaderT $ do
+    listen
+    action
+
+isQueryError :: QueryFailure -> Bool
+isQueryError _ = True
+
+prop_bencode :: Eq a => Show a => BEncode a => a -> Expectation
+prop_bencode x = BE.decode (BL.toStrict (BE.encode x)) `shouldBe` Right x
+
+retry :: Int -> IO (Maybe a) -> IO (Maybe a)
+retry 0 _ = return Nothing
+retry n a = do
+  res <- a
+  case res of
+    Just _ -> return res
+    Nothing -> threadDelay (100 * 1000) >> retry (n-1) a
+
+spec :: Spec
+spec = do
+ context ("you need running DHT node at " ++ show remoteAddr) $ do
+  it "is running" $ do
+         running <- retry 5 $ timeout (100 * 1000) $ do
+                      nid <- genNodeId
+                      Response _remoteAddr Ping <-
+                          rpc (query remoteAddr (Query nid False Ping))
+                      return ()
+         running `shouldSatisfy` isJust
+
+  describe "ping" $ do
+    it "properly bencoded" $ do
+      BE.decode "d2:id20:abcdefghij0123456789e"
+        `shouldBe` Right (Query "abcdefghij0123456789" False Ping)
+
+      BE.encode (Query "abcdefghij0123456789" False Ping)
+        `shouldBe` "d2:id20:abcdefghij0123456789e"
+
+      BE.decode "d2:id20:mnopqrstuvwxyz123456e"
+        `shouldBe` Right (Response "mnopqrstuvwxyz123456" Ping)
+
+      BE.encode (Response "mnopqrstuvwxyz123456" Ping)
+        `shouldBe` "d2:id20:mnopqrstuvwxyz123456e"
+
+    it "properly bencoded (iso)" $ property $ \ nid -> do
+      prop_bencode (Query    nid False Ping)
+      prop_bencode (Response nid Ping)
+
+    it "does compatible with existing DHT" $ do
+      nid <- genNodeId
+      Response _remoteAddr Ping <- rpc (query remoteAddr (Query nid False Ping))
+      return ()
+
+  describe "find_node" $ do
+    it "properly bencoded" $ do
+      BE.decode "d2:id20:abcdefghij0123456789\
+                 \6:target20:mnopqrstuvwxyz123456e"
+        `shouldBe` Right (Query "abcdefghij0123456789" False
+                      (FindNode "mnopqrstuvwxyz123456"))
+
+      BE.encode (Query "abcdefghij0123456789" False
+                 (FindNode "mnopqrstuvwxyz123456"))
+        `shouldBe`
+         "d2:id20:abcdefghij01234567896:target20:mnopqrstuvwxyz123456e"
+
+      let naddr = "127.0.0.1:258" :: NodeAddr IPv4
+      let nid  = "0123456789abcdefghij"
+      let nid' = "mnopqrstuvwxyz123456"
+      BE.decode "d2:id20:0123456789abcdefghij\
+                 \5:nodes26:mnopqrstuvwxyz123456\127\0\0\1\1\2\
+                \e"
+       `shouldBe` Right (Response nid (NodeFound [NodeInfo nid' naddr]))
+
+    it "properly bencoded (iso)" $ property $ \ nid x xs -> do
+      prop_bencode (Query    nid False (FindNode  x))
+      prop_bencode (Response nid (NodeFound (xs :: [NodeInfo IPv4] )))
+
+    it "does compatible with existing DHT" $ do
+      nid <- genNodeId
+      Response _remoteAddr (NodeFound xs) <- rpc $ do
+        query remoteAddr (Query nid False (FindNode nid))
+      L.length (xs :: [NodeInfo IPv4]) `shouldSatisfy` (> 0)
+
+  describe "get_peers" $ do
+    it "properly bencoded" $ do
+       BE.decode "d2:id20:abcdefghij0123456789\
+                  \9:info_hash20:mnopqrstuvwxyz123456\
+                  \e"
+         `shouldBe` Right (Query "abcdefghij0123456789" False
+                           (GetPeers "mnopqrstuvwxyz123456"))
+
+       BE.decode "d2:id20:abcdefghij0123456789\
+                  \5:token8:aoeusnth\
+                  \6:valuesl6:\127\0\0\1\1\2\&6:\192\168\1\100\1\2e\
+                 \e"
+         `shouldBe` Right (Response "abcdefghij0123456789"
+             (GotPeers (Right [ "127.0.0.1:258" :: PeerAddr IPv4
+                              , "192.168.1.100:258"
+                              ]) "aoeusnth"))
+
+       BE.decode "d2:id20:abcdefghij0123456789\
+                  \5:nodes26:mnopqrstuvwxyz123456\127\0\0\1\1\2\
+                  \5:token8:aoeusnth\
+                 \e"
+         `shouldBe` Right (Response "abcdefghij0123456789"
+            (GotPeers
+             { peers = Left [NodeInfo "mnopqrstuvwxyz123456" "127.0.0.1:258"
+                                 :: NodeInfo IPv4]
+             , grantedToken = "aoeusnth"
+             }))
+
+    it "properly bencoded (iso)" $ property $ \ nid topic exs token -> do
+      prop_bencode (Query    nid False (GetPeers topic))
+      let _ = exs :: Either [NodeInfo IPv4] [PeerAddr IPv4]
+      let nullPeerId paddr = paddr {peerId = Nothing}
+      let nullPeerIds      = either Left (Right . L.map nullPeerId)
+      prop_bencode (Response nid (GotPeers (nullPeerIds exs) token))
+
+    it "does compatible with existing DHT" $ do
+      nid <- genNodeId
+      Response _remoteId (GotPeers {..})
+        <- rpc $ query remoteAddr (Query nid False (GetPeers def))
+      let _ = peers :: Either [NodeInfo IPv4] [PeerAddr IPv4]
+      either L.length L.length peers `shouldSatisfy` (> 0)
+
+  describe "announce" $ do
+    it "properly bencoded" $ do
+      BE.decode "d2:id20:abcdefghij0123456789\
+                 \9:info_hash20:mnopqrstuvwxyz123456\
+                 \4:porti6881e\
+                 \5:token8:aoeusnth\
+                \e" `shouldBe` Right
+        (Query "abcdefghij0123456789" False
+                   (Announce False "mnopqrstuvwxyz123456" Nothing 6881 "aoeusnth"))
+
+      BE.decode "d2:id20:abcdefghij0123456789\
+                 \12:implied_porti1e\
+                 \9:info_hash20:mnopqrstuvwxyz123456\
+                 \4:porti6881e\
+                 \5:token8:aoeusnth\
+                \e" `shouldBe` Right
+        (Query "abcdefghij0123456789" False
+                   (Announce True "mnopqrstuvwxyz123456" Nothing 6881 "aoeusnth"))
+
+
+      BE.decode "d2:id20:mnopqrstuvwxyz123456e"
+        `shouldBe` Right
+        (Response "mnopqrstuvwxyz123456" Announced)
+
+    it "properly bencoded (iso)" $ property $ \ nid flag topic port token -> do
+      prop_bencode (Query    nid False (Announce flag topic Nothing port token))
+      prop_bencode (Response nid (Announced))
+
+
+    it "does compatible with existing DHT" $ do
+      nid <- genNodeId
+      Response _remoteId Announced <- rpc $ do
+        Response _ GotPeers {..} <- query remoteAddr (Query nid False (GetPeers def))
+        let _ = peers :: Either [NodeInfo IPv4] [PeerAddr IPv4]
+        query remoteAddr (Query nid False (Announce False def Nothing thisPort grantedToken))
+      return ()
+
+    it "does fail on invalid token" $ do
+      nid <- genNodeId
+      (rpc $ do
+        Response _ GotPeers {..} <- query remoteAddr (Query nid False (GetPeers def))
+        let _ = peers :: Either [NodeInfo IPv4] [PeerAddr IPv4]
+        let invalidToken = ""
+        let q :: MonadKRPC h m => SockAddr -> Query Announce
+              -> m (Response Announced)
+            q = query
+        q remoteAddr (Query nid False (Announce False def Nothing thisPort invalidToken)))
+          `shouldThrow` isQueryError
+      return ()
diff --git a/dht/bittorrent/tests/Network/BitTorrent/DHT/QuerySpec.hs b/dht/bittorrent/tests/Network/BitTorrent/DHT/QuerySpec.hs
new file mode 100644
index 00000000..93f78263
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/DHT/QuerySpec.hs
@@ -0,0 +1,105 @@
+{-# LANGUAGE RecordWildCards #-}
+module Network.BitTorrent.DHT.QuerySpec (spec) where
+import Control.Applicative
+import Control.Exception
+import Control.Monad.Reader
+import Data.Conduit as C
+import Data.Conduit.List as CL
+import Data.Default
+import Data.List as L
+import Test.Hspec
+
+import Network.BitTorrent.Address
+import Network.BitTorrent.DHT
+import Network.BitTorrent.DHT.Session
+import Network.BitTorrent.DHT.Query
+
+import Network.BitTorrent.DHT.TestData
+
+
+myAddr :: NodeAddr IPv4
+myAddr = "0.0.0.0:0"
+
+nullLogger :: LogFun
+nullLogger _ _ _ _ = return ()
+
+--simpleLogger :: LogFun
+--simpleLogger _ t _ _ = print t
+
+simpleDHT :: [NodeHandler IPv4] -> DHT IPv4 a -> IO a
+simpleDHT hs m =
+  bracket (newNode hs def myAddr nullLogger Nothing) closeNode $ \ node ->
+    runDHT node m
+
+getBootInfo :: IO (NodeInfo IPv4)
+getBootInfo = do
+  startAddr <- resolveHostName (L.head defaultBootstrapNodes)
+  simpleDHT [] $ fmap fst (pingQ startAddr)
+
+spec :: Spec
+spec = parallel $ do
+  describe "environment" $ do
+    describe "test node" $ do
+      it "is alive" $ do
+         _ <- getBootInfo
+         return ()
+
+  describe "handlers" $ do
+    it "" $ pendingWith "need to setup 2 DHT locally"
+
+  describe "basic queries" $ do
+    it "ping" $ do
+      _ <- getBootInfo
+      return ()
+
+    it "findNode" $ do
+      startInfo <- getBootInfo
+      _ <- simpleDHT [] $ do
+        nid <- myNodeIdAccordingTo (read "8.8.8.8:6881")
+        findNodeQ nid startInfo
+      return ()
+
+    it "getPeers" $ do
+      startInfo <- getBootInfo
+      peers <- simpleDHT [] $ do
+        nid <- myNodeIdAccordingTo (read "8.8.8.8:6881")
+
+        -- we should not run getPeers query on boot node, because
+        -- it may not support it
+        Right infos <- findNodeQ nid startInfo
+
+        when (L.null infos) $
+          error "boot node malfunction"
+
+        -- at least one node should reply
+        queryParallel $ do
+          getPeersQ (entryHash (L.head testTorrents)) <$> infos
+
+      peers `shouldSatisfy` (not . L.null)
+
+    it "announce" $ do
+      bootNode <- getBootInfo
+      _ <- simpleDHT [] $ do
+        let ih = entryHash (L.head testTorrents)
+        Right nodes <- findNodeQ ih bootNode
+
+        when (L.null nodes) $
+          error "boot node malfunction"
+
+        queryParallel $ do
+          announceQ ih (nodePort myAddr) <$> nodes
+
+      return ()
+
+  describe "iterative queries" $ do
+    forM_ testTorrents $ \ TestEntry {..} -> do
+      context entryName $ do
+
+        it "get at least 10 unique peers for each infohash" $ do
+          bootNode <- getBootInfo
+          peers <- simpleDHT [] $ do
+            Right startNodes <- findNodeQ entryHash bootNode
+            sourceList [startNodes] $=
+              search entryHash (getPeersQ entryHash) $=
+                CL.concat $$ CL.take 10
+          L.length peers `shouldBe` 10
diff --git a/dht/bittorrent/tests/Network/BitTorrent/DHT/RoutingSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/DHT/RoutingSpec.hs
new file mode 100644
index 00000000..07a906ba
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/DHT/RoutingSpec.hs
@@ -0,0 +1,77 @@
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE FlexibleContexts    #-}
+module Network.BitTorrent.DHT.RoutingSpec (spec) where
+import Control.Applicative
+import Control.Monad.State
+import Data.Default
+import Data.List as L
+import Data.Maybe
+import Test.Hspec
+import Test.QuickCheck
+
+import Network.BitTorrent.Address
+import Network.BitTorrent.DHT.Routing as T
+
+import Network.BitTorrent.CoreSpec hiding (spec)
+
+
+type Network ip = [NodeAddr ip]
+
+data Env ip = Env
+  { currentTime :: Timestamp
+  , network     :: Network ip
+  } deriving Show
+
+type Simulation ip = State (Env ip)
+
+runSimulation :: Eq ip => Env ip -> Routing ip a -> Maybe a
+runSimulation e m = evalState (runRouting ping closest timestamp m) e
+  where
+    ping    addr = gets (L.elem addr . network)
+    closest nid  = error "runSimulation"
+    timestamp    = gets currentTime
+
+instance Arbitrary ip => Arbitrary (Env ip) where
+  arbitrary = Env <$> arbitrary <*> (vector nodeCount)
+    where
+      nodeCount = 1000
+
+instance (Arbitrary ip, Eq ip) => Arbitrary (Table ip) where
+  arbitrary = do
+    thisId  <- arbitrary
+    bucketN <- choose (1, 20)
+    let table = nullTable thisId bucketN
+
+--    nodeN   <- (`mod` bucketN) <$> arbitrary
+--    nodes   <- vector nodeN
+
+    node    <- arbitrary
+    mt <- do
+        env <- arbitrary
+        return $ runSimulation env $ do
+            (_,t') <- T.insert (currentTime env) (TryInsert node) table
+            return t' :: Routing ip (Table ip)
+          --(foldM (flip fillTable) table nodes)
+    return (fromJust mt)
+--    where
+--     fillTable x t = do
+--       t' <- T.insert x t
+--       return $ if T.full t' then t else t'
+
+spec :: Spec
+spec = do
+  describe "size" $ do
+    it "null table is empty" $ do
+      T.size (nullTable def 2 :: Table IPv4) `shouldBe` 0
+
+    it "the same node never appear in different buckets" $ property $ \ t -> do
+      let xss = T.toList (t :: Table Int)
+      let justOnce x = L.length (L.filter (L.elem x) xss) == 1
+      L.all justOnce (L.concat xss)
+
+    it "insert is idemponent" $ property $ \ (e :: Env Int) n t -> do
+      let ins :: NodeInfo Int -> Table Int -> Routing Int (Table Int)
+          ins n t = snd <$> T.insert (currentTime e) (TryInsert n) t
+      let t1 = runSimulation e (ins n t)
+      let t2 = runSimulation e (ins n t >>= ins n)
+      t1 `shouldBe` t2
diff --git a/dht/bittorrent/tests/Network/BitTorrent/DHT/SessionSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/DHT/SessionSpec.hs
new file mode 100644
index 00000000..32e4c158
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/DHT/SessionSpec.hs
@@ -0,0 +1,110 @@
+{-# LANGUAGE ScopedTypeVariables #-}
+module Network.BitTorrent.DHT.SessionSpec (spec) where
+import Control.Applicative
+import Control.Concurrent
+import Control.Exception
+import Control.Monad.Reader
+import Control.Monad.Trans.Resource
+import Data.Conduit.Lazy
+import Data.Default
+import Data.List as L
+import Test.Hspec
+import Test.QuickCheck
+
+import Network.BitTorrent.Address
+import Network.BitTorrent.DHT
+import Network.BitTorrent.DHT.Message
+import Network.BitTorrent.DHT.Session
+import Network.BitTorrent.DHT.Query
+
+import Data.TorrentSpec ()
+import Network.BitTorrent.CoreSpec ()
+import Network.BitTorrent.DHT.TokenSpec ()
+
+
+myAddr :: NodeAddr IPv4
+myAddr = "127.0.0.1:60000"
+
+simpleDHT :: DHT IPv4 a -> IO a
+simpleDHT m =
+  bracket (newNode defaultHandlers def myAddr nullLogger Nothing) closeNode $ \ node ->
+    runDHT node m
+
+isRight :: Either a b -> Bool
+isRight (Left  _) = False
+isRight (Right _) = True
+
+isLeft :: Either a b -> Bool
+isLeft = not . isRight
+
+nullLogger :: LogFun
+nullLogger _ _ _ _ = return ()
+
+spec :: Spec
+spec = do
+  describe "session" $ do
+    it "is active until closeNode called" $ do
+      node <- newNode [] def myAddr nullLogger Nothing
+      runDHT node monadActive `shouldReturn` True
+      runDHT node monadActive `shouldReturn` True
+      closeNode node
+      runDHT node monadActive `shouldReturn` False
+
+  describe "tokens" $ do
+    it "should not complain about valid token" $
+      property $ \ (addrs :: [NodeAddr IPv4]) -> do
+        isOks <- simpleDHT $ do
+          forM addrs $ \ addr -> do
+            token <- grantToken addr
+            checkToken addr token
+        L.and isOks `shouldBe` True
+
+    it "should complain about invalid token" $
+      property $ \ (addr :: NodeAddr IPv4) token -> do
+        isOk <- simpleDHT (checkToken addr token)
+        isOk `shouldBe` False
+
+  describe "routing table" $
+    it "accept any node entry when table is empty" $
+      property $ \ (nid :: NodeId) -> do
+        let info = NodeInfo nid myAddr
+        closest <- simpleDHT $ do
+           _ <- insertNode info Nothing
+           liftIO $ yield
+           getClosest nid
+        closest `shouldSatisfy` L.elem info
+
+  describe "peer storage" $ do
+    it "should return nodes, if there are no peers" $ property $ \ ih -> do
+      res <- simpleDHT $ do getPeerList ih
+      res `shouldSatisfy` isLeft
+
+    it "should return peers, if any" $ property $ \ ih addr -> do
+      res <- simpleDHT $ do
+                 insertPeer ih addr
+                 getPeerList ih
+      res `shouldSatisfy` isRight
+
+  describe "topic storage" $ do
+    it "should not grow indefinitely" $ do
+      pending
+
+  describe "messaging" $ do
+    describe "queryNode" $ do
+      it "should always ping this node" $ do
+        (rid, tid) <- simpleDHT $ do
+          (remoteId, Ping) <- queryNode myAddr Ping
+          thisId <- myNodeIdAccordingTo (read "8.8.8.8:6881")
+          return (remoteId, thisId)
+        rid `shouldBe` tid
+
+    describe "queryParallel" $ do
+      it "should handle parallel requests" $ do
+        (nid, resps) <- simpleDHT $ do
+          me <- myNodeIdAccordingTo (read "8.8.8.8:6881")
+          ( (,) me ) <$> queryParallel (L.replicate 100 $ queryNode myAddr Ping)
+        resps `shouldSatisfy` L.all (== (nid, Ping))
+
+    describe "(<@>) operator" $ do
+      it "" $
+         pending
diff --git a/dht/bittorrent/tests/Network/BitTorrent/DHT/TestData.hs b/dht/bittorrent/tests/Network/BitTorrent/DHT/TestData.hs
new file mode 100644
index 00000000..e9473cbb
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/DHT/TestData.hs
@@ -0,0 +1,45 @@
+module Network.BitTorrent.DHT.TestData
+       ( TestEntry (..)
+       , testTorrents
+       ) where
+
+import Data.Torrent
+
+data TestEntry = TestEntry
+  { entryName  :: String
+  , entryHash  :: InfoHash
+  , entryPeers :: Int -- ^ approximate number of peers, may change with time
+  }
+
+testTorrents :: [TestEntry]
+testTorrents =
+  [ TestEntry
+    { entryName  = "Automate with Arduino, Android..."
+    , entryHash  = "8c0433e541dc5d1cfc095799cef171cd4eb586f7"
+    , entryPeers = 300
+    }
+
+  , TestEntry
+    { entryName  = "Beginning Programming with Java For Dummies"
+    , entryHash  = "fd8967721731cc16c8b203a03e49ce839cecf184"
+    , entryPeers = 200
+    }
+
+  , TestEntry
+    { entryName  = "The C Programming Language"
+    , entryHash  = "146d13f090e50e97091dbbe5b37678dd1471cfad"
+    , entryPeers = 100
+    }
+
+  , TestEntry
+    { entryName  = "The C++ Programming Language"
+    , entryHash  = "8e8e8e6319031a22cff26d895afe050085c84a7f"
+    , entryPeers = 50
+    }
+
+  , TestEntry
+    { entryName  = "Game and Graphics Programming for iOS..."
+    , entryHash  = "703d0595b727fccbfaa3d03be25f57347ccfd6de"
+    , entryPeers = 30
+    }
+  ]
diff --git a/dht/bittorrent/tests/Network/BitTorrent/DHT/TokenSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/DHT/TokenSpec.hs
new file mode 100644
index 00000000..a45d2212
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/DHT/TokenSpec.hs
@@ -0,0 +1,42 @@
+{-# LANGUAGE ScopedTypeVariables  #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+module Network.BitTorrent.DHT.TokenSpec (spec) where
+import Control.Applicative
+import Data.List as L
+import Data.String
+import Test.Hspec
+import Test.QuickCheck
+
+import Network.BitTorrent.Address
+import Network.BitTorrent.CoreSpec ()
+import Network.BitTorrent.DHT.Token as T
+
+
+instance Arbitrary Token where
+  arbitrary = fromString <$> arbitrary
+
+instance Arbitrary TokenMap where
+  arbitrary = tokens <$> arbitrary
+
+repeatN :: Int -> (a -> a) -> (a -> a)
+repeatN n f = L.foldr (.) id $ L.replicate n f
+
+spec :: Spec
+spec = do
+  describe "Token" $ do
+    return ()
+
+  describe "TokenMap" $ do
+    it "is keeping any granted token in current session" $
+      property $ \ (addr :: NodeAddr IPv4) m ->
+        T.member addr (T.lookup addr m) m
+
+    it "is keeping any granted token in next session" $
+      property $ \ (addr :: NodeAddr IPv4) m ->
+        T.member addr (T.lookup addr m) (T.update m)
+
+    -- can fail with some small probability
+    it "is rejecting any outdated tokens" $
+      property $ \ (addr :: NodeAddr IPv4) m k -> not $
+        let n = min 100 (abs k + 2) in
+        T.member addr (T.lookup addr m) (repeatN n T.update m)
\ No newline at end of file
diff --git a/dht/bittorrent/tests/Network/BitTorrent/DHTSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/DHTSpec.hs
new file mode 100644
index 00000000..77160eb5
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/DHTSpec.hs
@@ -0,0 +1,60 @@
+module Network.BitTorrent.DHTSpec (spec) where
+import Control.Exception
+import Control.Monad
+import Data.Default
+import Data.List as L
+import Test.Hspec
+import System.Timeout
+
+import Data.Torrent
+import Network.BitTorrent.DHT
+
+
+partialBootstrapTimeout :: Int
+partialBootstrapTimeout = 10 * 1000000
+
+opts :: Options
+opts = def { optBucketCount = 1 }
+
+-- NOTE to shorten test cases run time include only "good" infohashes
+-- with many nodes
+existingInfoHashes :: [InfoHash]
+existingInfoHashes =
+  [
+  ]
+
+-- TODO use Test.Hspec.parallel
+
+spec :: Spec
+spec = do
+  describe "bootstrapping" $ do
+    it "should resolve all default bootstrap nodes" $ do
+      nodes <- forM defaultBootstrapNodes resolveHostName
+      _     <- evaluate nodes
+      return ()
+
+    it "partial bootstrapping should finish in less than 10 seconds" $ do
+      node <- resolveHostName (L.head defaultBootstrapNodes)
+      res  <- timeout partialBootstrapTimeout $ do
+                dht opts def fullLogging $ do
+                  bootstrap Nothing [node]
+                  isBootstrapped
+      res `shouldBe` Just True
+
+  describe "initialization" $ do
+    it "should be bootstrapped after restore process" $ do
+      pending
+
+  describe "lookup" $ do
+    describe "for any existing infohash" $ do
+      forM_ existingInfoHashes $ \ ih -> do
+        context (show ih) $ do
+          it "should find peers" $ do
+            pending
+
+  describe "insert" $ do
+    it "should return this peer if announced" $ do
+      pending
+
+  describe "delete" $ do
+    return ()
diff --git a/dht/bittorrent/tests/Network/BitTorrent/Exchange/BitfieldSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/Exchange/BitfieldSpec.hs
new file mode 100644
index 00000000..1ba772f6
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Exchange/BitfieldSpec.hs
@@ -0,0 +1,14 @@
+{-# OPTIONS -fno-warn-orphans #-}
+module Network.BitTorrent.Exchange.BitfieldSpec (spec) where
+import Control.Applicative
+import Data.ByteString.Arbitrary
+import Test.Hspec
+import Test.QuickCheck
+
+import Network.BitTorrent.Exchange.Bitfield
+
+instance Arbitrary Bitfield where
+  arbitrary = fromBitmap . fromABS <$> arbitrary
+
+spec :: Spec
+spec = return ()
diff --git a/dht/bittorrent/tests/Network/BitTorrent/Exchange/BlockSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/Exchange/BlockSpec.hs
new file mode 100644
index 00000000..2dc8e0b8
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Exchange/BlockSpec.hs
@@ -0,0 +1,35 @@
+module Network.BitTorrent.Exchange.BlockSpec (spec) where
+import Control.Applicative
+import Control.Exception
+import Data.Maybe
+import Test.Hspec
+import Test.QuickCheck
+import Test.QuickCheck.Instances ()
+
+import Network.BitTorrent.Exchange.Block as Block
+
+
+instance Arbitrary a => Arbitrary (Block a) where
+  arbitrary = Block <$> arbitrary <*> arbitrary <*> arbitrary
+
+instance Arbitrary BlockIx where
+  arbitrary = BlockIx <$> arbitrary <*> arbitrary <*> arbitrary
+
+instance Arbitrary Bucket where
+  arbitrary = do
+    s      <- arbitrary `suchThat` (> 0)
+    chunks <- arbitrary
+    return $ Block.fromList s chunks
+
+isSomeException :: SomeException -> Bool
+isSomeException = const True
+
+spec :: Spec
+spec = do
+  describe "empty" $ do
+    it "should fail on bad size" $ do
+      evaluate (Block.empty (-1)) `shouldThrow` isSomeException
+
+  describe "toPiece" $ do
+    it "render to piece when it is full" $ property $ \ bkt ->
+      full bkt == isJust (toPiece bkt)
\ No newline at end of file
diff --git a/dht/bittorrent/tests/Network/BitTorrent/Exchange/ConnectionSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/Exchange/ConnectionSpec.hs
new file mode 100644
index 00000000..d654cda1
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Exchange/ConnectionSpec.hs
@@ -0,0 +1,58 @@
+{-# LANGUAGE RecordWildCards      #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+module Network.BitTorrent.Exchange.ConnectionSpec (spec) where
+import Control.Applicative
+import Control.Monad.Trans
+import Data.Default
+import Test.Hspec
+import Test.QuickCheck
+
+import Data.Torrent
+import Network.BitTorrent.Address
+import Network.BitTorrent.Exchange.Connection
+import Network.BitTorrent.Exchange.Message
+
+import Config
+import Network.BitTorrent.Exchange.MessageSpec ()
+
+nullSession :: InfoHash -> PeerId -> SessionLink ()
+nullSession ih pid = SessionLink ih pid Nothing Nothing ()
+
+instance Arbitrary Options where
+  arbitrary = return def
+
+instance Arbitrary ConnectionPrefs where
+  arbitrary = ConnectionPrefs <$> arbitrary <*> pure def
+                              <*> arbitrary <*> arbitrary
+
+withWire :: ConnectionPrefs -> Wire () () -> IO ()
+withWire prefs wire =
+  withRemote $ \ ClientOpts {..} -> do
+    pid <- genPeerId
+    t   <- getTestTorrent
+    let ih  = idInfoHash (tInfoDict t)
+    let cfg = ConnectionConfig prefs (nullSession ih pid) (wire)
+    let addr = PeerAddr Nothing "127.0.0.1" peerPort
+    connectWire addr cfg
+
+spec :: Spec
+spec = do
+  describe "connectWire" $ do
+    it "can establish connection with all possible preferences" $
+      property $ \ prefs -> do
+        withWire prefs (return ())
+
+    it "must not connect with invalid topic" $ do
+      pending
+
+  describe "acceptWire" $ do
+    it "" $ do
+      pending
+
+  describe "messaging" $ do
+    it "first message is bitfield" $ do
+      withWire def $ do
+        msg <- recvMessage
+        let isBitfield (Available (Bitfield _)) = True
+            isBitfield  _                       = False
+        liftIO $ msg `shouldSatisfy` isBitfield
diff --git a/dht/bittorrent/tests/Network/BitTorrent/Exchange/DownloadSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/Exchange/DownloadSpec.hs
new file mode 100644
index 00000000..d46f2034
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Exchange/DownloadSpec.hs
@@ -0,0 +1,59 @@
+{-# LANGUAGE RecordWildCards #-}
+module Network.BitTorrent.Exchange.DownloadSpec (spec) where
+import Control.Concurrent
+import Data.ByteString as BS
+import Data.ByteString.Lazy as BL
+import Test.Hspec
+import Test.QuickCheck
+
+import Data.BEncode as BE
+import Data.Torrent as Torrent
+import Network.BitTorrent.Address
+import Network.BitTorrent.Exchange.Download
+import Network.BitTorrent.Exchange.Message
+
+import Config
+import Network.BitTorrent.CoreSpec ()
+
+
+placeholderAddr :: PeerAddr IP
+placeholderAddr = "0.0.0.0:0"
+
+chunkBy :: Int -> BS.ByteString -> [BS.ByteString]
+chunkBy s bs
+  | BS.null bs = []
+  | otherwise  = BS.take s bs : chunkBy s (BS.drop s bs)
+
+withUpdates :: Updates s a -> IO a
+withUpdates m = do
+  Torrent {..} <- getTestTorrent
+  let infoDictLen = fromIntegral $ BL.length $ BE.encode tInfoDict
+  --mvar <- newMVar (nullStatus infoDictLen)
+  --runUpdates mvar placeholderAddr m
+  undefined
+
+simulateFetch :: InfoDict -> Updates s (Maybe InfoDict)
+simulateFetch dict = undefined
+
+spec :: Spec
+spec = do
+  describe "scheduleBlock" $ do
+    it "never schedule the same index twice" $ do
+      pending
+
+  describe "resetPending" $ do
+    it "" $ do
+      pending
+
+  describe "cancelPending" $ do
+    it "must not throw an exception if cancel the same piece twice" $ do
+      pending
+
+  describe "pushBlock" $ do
+    it "assemble infodict from chunks" $ do
+      Torrent {..} <- getTestTorrent
+      mdict <- withUpdates $ simulateFetch tInfoDict
+      mdict `shouldBe` Just tInfoDict
+
+    it "must throw an exception if block if not requested" $ do
+      pending
\ No newline at end of file
diff --git a/dht/bittorrent/tests/Network/BitTorrent/Exchange/MessageSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/Exchange/MessageSpec.hs
new file mode 100644
index 00000000..d615b1ff
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Exchange/MessageSpec.hs
@@ -0,0 +1,102 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+module Network.BitTorrent.Exchange.MessageSpec (spec) where
+import Control.Applicative
+import Control.Exception
+import Data.ByteString as BS
+import Data.List as L
+import Data.Set as S
+import Data.Serialize as S
+import Data.String
+import Test.Hspec
+import Test.QuickCheck
+
+import Data.TorrentSpec ()
+import Network.BitTorrent.Exchange.BitfieldSpec ()
+import Network.BitTorrent.CoreSpec ()
+import Network.BitTorrent.Address ()
+import Network.BitTorrent.Exchange.BlockSpec ()
+import Network.BitTorrent.Exchange.Message
+
+instance Arbitrary Extension where
+  arbitrary = elements [minBound .. maxBound]
+
+instance Arbitrary Caps where
+  arbitrary = toCaps <$> arbitrary
+
+instance Arbitrary ExtendedExtension where
+  arbitrary = elements [minBound .. maxBound]
+
+instance Arbitrary ExtendedCaps where
+  arbitrary = toCaps <$> arbitrary
+
+instance Arbitrary ProtocolName where
+  arbitrary = fromString <$> (arbitrary `suchThat` ((200 <) . L.length))
+
+instance Arbitrary Handshake where
+  arbitrary = Handshake <$> arbitrary <*> arbitrary
+                        <*> arbitrary <*> arbitrary
+
+instance Arbitrary StatusUpdate where
+  arbitrary = frequency
+    [ (1, Choking    <$> arbitrary)
+    , (1, Interested <$> arbitrary)
+    ]
+
+instance Arbitrary Available where
+  arbitrary = frequency
+    [ (1, Have     <$> arbitrary)
+    , (1, Bitfield <$> arbitrary)
+    ]
+
+instance Arbitrary Transfer where
+  arbitrary = frequency
+    [ (1, Request <$> arbitrary)
+    , (1, Piece   <$> arbitrary)
+    , (1, Cancel  <$> arbitrary)
+    ]
+
+instance Arbitrary FastMessage where
+  arbitrary = frequency
+    [ (1, pure HaveAll)
+    , (1, pure HaveNone)
+    , (1, SuggestPiece  <$> arbitrary)
+    , (1, RejectRequest <$> arbitrary)
+    , (1, AllowedFast   <$> arbitrary)
+    ]
+
+instance Arbitrary Message where
+  arbitrary = frequency
+    [ (1, pure KeepAlive)
+    , (1, Status    <$> arbitrary)
+    , (1, Available <$> arbitrary)
+    , (1, Transfer  <$> arbitrary)
+    , (1, Fast      <$> arbitrary)
+    ]
+
+-- TODO test extension protocol
+
+spec :: Spec
+spec = do
+  describe "Caps" $ do
+    it "set-like container" $ property $ \ exts ->
+      L.all (`allowed` (toCaps exts :: Caps)) exts
+
+    it "preserve items" $ property $ \ extSet ->
+      S.fromList (fromCaps (toCaps (S.toList extSet) :: Caps))
+        `shouldBe` extSet
+
+  describe "ByteStats" $ do
+    it "preserve size" $ property $ \ msg ->
+      byteLength (stats msg) `shouldBe`
+        fromIntegral (BS.length (S.encode (msg :: Message)))
+
+  describe "ProtocolName" $ do
+    it "fail to construct invalid string" $ do
+      let str = L.replicate 500 'x'
+      evaluate (fromString str :: ProtocolName)
+        `shouldThrow`
+        errorCall ("fromString: ProtocolName too long: " ++ str)
+
+  describe "Handshake" $ do
+    it "properly serialized" $ property $ \ hs ->
+      S.decode (S.encode hs ) `shouldBe` Right (hs :: Handshake)
diff --git a/dht/bittorrent/tests/Network/BitTorrent/Exchange/SessionSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/Exchange/SessionSpec.hs
new file mode 100644
index 00000000..bf5b95a1
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Exchange/SessionSpec.hs
@@ -0,0 +1,64 @@
+{-# LANGUAGE RecordWildCards #-}
+module Network.BitTorrent.Exchange.SessionSpec (spec) where
+import Test.Hspec
+
+import Data.Torrent
+import Network.BitTorrent.Address
+import Network.BitTorrent.Exchange.Session
+
+import Config
+
+
+nullLogger :: LogFun
+nullLogger _ _ x _ = print x
+
+simpleSession :: InfoDict -> (Session -> IO ()) -> IO ()
+simpleSession dict action = do
+  withRemoteAddr $ \ addr -> do
+    myAddr <- getMyAddr
+    ses  <- newSession nullLogger myAddr "" (Right dict)
+    connect addr ses
+    action ses
+    closeSession ses
+
+spec :: Spec
+spec = do
+  describe "construction" $ do
+    describe "newSession" $ do
+      it "" $ do
+        pending
+
+    describe "closeSession" $ do
+      it "" $ do
+        pending
+
+  describe "connection set" $ do
+    describe "connect" $ do
+      it "" $ do
+        pending
+
+    describe "establish" $ do
+      it "" $ do
+        pending
+
+  describe "exchange" $ do
+    describe "metadata" $ do
+      it "should fetch info dictionary" $ do
+        Torrent {..} <- getTestTorrent
+        simpleSession tInfoDict $ \ ses -> do
+          dict <- waitMetadata ses
+          dict `shouldBe` tInfoDict
+
+      it "should serve info dictionary" $ do
+        pending
+
+    describe "content" $ do
+      it "should fetch torrent content" $ do
+        Torrent {..} <- getTestTorrent
+        simpleSession tInfoDict $ \ ses -> do
+          pending
+--        st <- waitData ses
+--        verifyStorage st (idPieceInfo tInfoDict)
+
+      it "should serve torrent content" $ do
+        pending
diff --git a/dht/bittorrent/tests/Network/BitTorrent/Internal/CacheSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/Internal/CacheSpec.hs
new file mode 100644
index 00000000..337e7add
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Internal/CacheSpec.hs
@@ -0,0 +1,7 @@
+module Network.BitTorrent.Internal.CacheSpec (spec) where
+import Test.Hspec
+
+spec :: Spec
+spec = do
+  describe "Cached" $ do
+    return ()
diff --git a/dht/bittorrent/tests/Network/BitTorrent/Internal/ProgressSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/Internal/ProgressSpec.hs
new file mode 100644
index 00000000..acbfd84c
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Internal/ProgressSpec.hs
@@ -0,0 +1,13 @@
+{-# OPTIONS -fno-warn-orphans #-}
+module Network.BitTorrent.Internal.ProgressSpec (spec) where
+import Control.Applicative
+import Test.Hspec
+import Test.QuickCheck
+import Network.BitTorrent.Internal.Progress
+
+
+instance Arbitrary Progress where
+  arbitrary = Progress <$> arbitrary <*> arbitrary <*> arbitrary
+
+spec :: Spec
+spec = return ()
diff --git a/dht/bittorrent/tests/Network/BitTorrent/Tracker/ListSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/Tracker/ListSpec.hs
new file mode 100644
index 00000000..bba9d0e2
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Tracker/ListSpec.hs
@@ -0,0 +1,40 @@
+module Network.BitTorrent.Tracker.ListSpec (spec) where
+import Control.Exception
+import Data.Default
+import Data.Foldable as F
+import Data.List as L
+import Data.Maybe
+import Network.URI
+import Test.Hspec
+
+import Data.Torrent
+import Network.BitTorrent.Tracker.List
+import Network.BitTorrent.Tracker.RPC
+
+
+uris :: [URI]
+uris = fmap (fromJust . parseURI . renderURI) [1..10 :: Int]
+  where
+    renderURI n = "http://" ++ show n ++ ".org"
+
+list :: TrackerList ()
+list = trackerList def { tAnnounceList = Just [uris] }
+
+spec :: Spec
+spec = do
+  describe "TrackerList" $ do
+    it "shuffleTiers (may fail with very small probability)" $ do
+      list' <- shuffleTiers list
+      list' `shouldSatisfy` (/= list)
+
+    it "traverseAll" $ do
+      xs <- traverseAll (\ (uri, _) -> if uri == L.last uris
+               then throwIO (GenericException "")
+               else return ()) list
+      return ()
+
+    it "traverseTiers" $ do
+      xs' <- traverseTiers (\ (uri, _) -> if uri == L.last uris then return ()
+                              else throwIO (GenericException "")) list
+
+      return ()
diff --git a/dht/bittorrent/tests/Network/BitTorrent/Tracker/MessageSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/Tracker/MessageSpec.hs
new file mode 100644
index 00000000..29854d58
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Tracker/MessageSpec.hs
@@ -0,0 +1,173 @@
+{-# LANGUAGE RecordWildCards   #-}
+{-# LANGUAGE ViewPatterns      #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# OPTIONS -fno-warn-orphans  #-}
+module Network.BitTorrent.Tracker.MessageSpec
+       ( spec
+       , arbitrarySample
+       ) where
+
+import Control.Applicative
+import Control.Exception
+import Data.BEncode as BE
+import Data.ByteString.Lazy as BL
+import Data.List as L
+import Data.Maybe
+import Test.Hspec
+import Test.QuickCheck
+
+import Data.TorrentSpec ()
+import Network.BitTorrent.Internal.ProgressSpec ()
+import Network.BitTorrent.Address ()
+import Network.BitTorrent.Address ()
+
+import Network.BitTorrent.Tracker.Message as Message
+import Network.BitTorrent.Address
+
+
+--prop_bencode :: Eq a => BEncode a => a -> Bool
+--prop_bencode a = BE.decode (BL.toStrict (BE.encode a)) == return a
+
+--prop_urlencode :: Eq a => URLDecoded a => URLEncoded a => a -> Bool
+--prop_urlencode a = urlDecode (T.pack (urlEncode a)) == a
+
+instance Arbitrary AnnounceEvent where
+  arbitrary = elements [minBound..maxBound]
+
+instance Arbitrary AnnounceQuery where
+  arbitrary = AnnounceQuery
+    <$> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary
+    <*> arbitrary <*> arbitrary <*> arbitrary
+
+instance Arbitrary (PeerList IP) where
+  arbitrary = frequency
+    [ (1,        (PeerList . maybeToList) <$> arbitrary)
+    , (1, (CompactPeerList . maybeToList . fmap zeroPeerId) <$> arbitrary)
+    ]
+
+  shrink (       PeerList xs) =        PeerList <$> shrink xs
+  shrink (CompactPeerList xs) = CompactPeerList <$> shrink xs
+
+instance Arbitrary AnnounceInfo where
+  arbitrary = AnnounceInfo
+    <$> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary
+    <*> arbitrary <*> arbitrary
+
+arbitrarySample :: Arbitrary a => IO a
+arbitrarySample = L.head <$> sample' arbitrary
+
+zeroPeerId :: PeerAddr a -> PeerAddr a
+zeroPeerId addr = addr { peerId = Nothing }
+
+spec :: Spec
+spec = do
+  describe "AnnounceQuery" $ do
+    it "properly url encoded" $ property $ \ q ->
+      parseAnnounceQuery (renderAnnounceQuery q)
+        `shouldBe` Right q
+
+  describe "PeerList" $ do
+    context "Non compact" $ do
+      it "properly encoded (both ipv4 and ipv6)" $ do
+        BE.decode "ld2:ip7:1.2.3.44:porti80eed2:ip3:::14:porti8080eee"
+          `shouldBe` Right
+          (PeerList ["1.2.3.4:80", "[::1]:8080"] :: PeerList IPv4)
+
+      it "properly encoded (iso)" $ property $ \ xs ->
+        BE.decode (BL.toStrict (BE.encode (PeerList xs :: PeerList IPv4)))
+          `shouldBe` Right (PeerList xs :: PeerList IPv4)
+
+    context "Compact" $ do
+      it "properly encodes (ipv4)" $ do
+        BE.decode "12:\x1\x2\x3\x4\x1\x2\x9\x8\x7\x6\x1\x2"
+          `shouldBe` Right
+          (CompactPeerList ["1.2.3.4:258", "9.8.7.6:258"] :: PeerList IPv4)
+
+      it "properly encodes (ipv6)" $ do
+        BE.decode "18:\x1\x2\x3\x4\x5\x6\x7\x8\x1\x2\x3\x4\x5\x6\x7\x8\x1\x2"
+          `shouldBe` Right
+          (CompactPeerList ["[102:304:506:708:102:304:506:708]:258"]
+           :: PeerList IPv6)
+
+      it "properly encoded (ipv4, iso)" $
+        property $ \ (fmap zeroPeerId -> xs) ->
+          BE.decode (BL.toStrict (BE.encode (CompactPeerList xs)))
+            `shouldBe` Right (CompactPeerList xs :: PeerList IPv4)
+
+      it "properly encoded (ipv6, iso)" $
+        property $ \ (fmap zeroPeerId -> xs) ->
+          BE.decode (BL.toStrict (BE.encode (CompactPeerList xs)))
+            `shouldBe` Right (CompactPeerList xs :: PeerList IPv6)
+
+  describe "AnnounceInfo" $ do
+    it "parses minimal sample" $ do
+      "d8:intervali0e5:peerslee"
+        `shouldBe`
+        AnnounceInfo Nothing Nothing 0 Nothing (PeerList []) Nothing
+
+    it "parses optional fields" $ do
+      "d8:completei1e\
+       \10:incompletei2e\
+       \8:intervali3e\
+       \12:min intervali4e\
+       \5:peersle\
+       \15:warning message3:str\
+       \e"
+        `shouldBe`
+        AnnounceInfo (Just 1) (Just 2) 3 (Just 4) (PeerList []) (Just "str")
+
+    it "parses failed response" $ do
+      "d14:failure reason10:any reasone"
+                 `shouldBe`
+        Message.Failure "any reason"
+
+    it "fail if no peer list present" $ do
+      evaluate ("d8:intervali0ee" :: AnnounceInfo)
+        `shouldThrow`
+         errorCall "fromString: unable to decode AnnounceInfo: \
+                   \required field `peers' not found"
+
+    it "parses `peer' list" $ do -- TODO
+      "d8:intervali0e\
+       \5:peersl\
+               \d2:ip7:1.2.3.4\
+                \4:porti80e\
+               \e\
+               \d2:ip3:::1\
+                \4:porti80e\
+               \e\
+              \e\
+       \e" `shouldBe`
+        let xs = PeerList ["1.2.3.4:80", "[::1]:80"] in
+        AnnounceInfo Nothing Nothing 0 Nothing xs Nothing
+
+    it "parses `peers6' list" $ do
+      "d8:intervali0e\
+       \5:peers0:\
+       \6:peers60:\
+      \e" `shouldBe`
+        AnnounceInfo Nothing Nothing 0 Nothing (CompactPeerList []) Nothing
+
+    it "fails on invalid combinations of the peer lists" $ do
+      BE.decode "d8:intervali0e\
+                 \5:peers0:\
+                 \6:peers6le\
+                \e"
+        `shouldBe` (Left
+        "PeerList: the `peers6' field value should contain \
+                  \*compact* peer list" :: BE.Result AnnounceInfo)
+
+      BE.decode "d8:intervali0e\
+                 \5:peersle\
+                 \6:peers60:\
+                \e"
+        `shouldBe` (Left
+        "PeerList: non-compact peer list provided, \
+                  \but the `peers6' field present" :: BE.Result AnnounceInfo)
+
+    it "properly bencoded (iso)" $ property $ \ info ->
+      BE.decode (BL.toStrict (BE.encode info))
+        `shouldBe` Right (info :: AnnounceInfo)
+
+  describe "Scrape" $ do
+    return ()
diff --git a/dht/bittorrent/tests/Network/BitTorrent/Tracker/RPC/HTTPSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/Tracker/RPC/HTTPSpec.hs
new file mode 100644
index 00000000..e928f917
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Tracker/RPC/HTTPSpec.hs
@@ -0,0 +1,95 @@
+{-# LANGUAGE RecordWildCards #-}
+module Network.BitTorrent.Tracker.RPC.HTTPSpec (spec) where
+import Control.Monad
+import Data.Default
+import Data.List as L
+import Test.Hspec
+
+import Network.BitTorrent.Internal.Progress
+import Network.BitTorrent.Tracker.Message as Message
+import Network.BitTorrent.Tracker.RPC.HTTP
+
+import Network.BitTorrent.Tracker.TestData
+import Network.BitTorrent.Tracker.MessageSpec hiding (spec)
+
+
+validateInfo :: AnnounceQuery -> AnnounceInfo -> Expectation
+validateInfo _ (Message.Failure reason) = do
+  error $ "validateInfo: " ++ show reason
+validateInfo AnnounceQuery {..}  AnnounceInfo {..} = do
+  return ()
+--  case respComplete <|> respIncomplete of
+--    Nothing -> return ()
+--    Just n  -> n  `shouldBe` L.length (getPeerList respPeers)
+
+isUnrecognizedScheme :: RpcException -> Bool
+isUnrecognizedScheme (RequestFailed _) = True
+isUnrecognizedScheme  _                = False
+
+isNotResponding :: RpcException -> Bool
+isNotResponding (RequestFailed _) = True
+isNotResponding  _                = False
+
+spec :: Spec
+spec = parallel $ do
+  describe "Manager" $ do
+    describe "newManager" $ do
+      it "" $ pending
+
+    describe "closeManager" $ do
+      it "" $ pending
+
+    describe "withManager" $ do
+      it "" $ pending
+
+  describe "RPC" $ do
+    describe "announce" $ do
+      it "must fail on bad uri scheme" $ do
+        withManager def $ \ mgr -> do
+          q    <- arbitrarySample
+          announce mgr "magnet://foo.bar" q
+            `shouldThrow` isUnrecognizedScheme
+
+    describe "scrape" $ do
+      it "must fail on bad uri scheme" $ do
+        withManager def $ \ mgr -> do
+          scrape mgr "magnet://foo.bar" []
+            `shouldThrow` isUnrecognizedScheme
+
+    forM_ (L.filter isHttpTracker trackers) $ \ TrackerEntry {..} ->
+      context trackerName $ do
+
+        describe "announce" $ do
+          if tryAnnounce
+            then do
+              it "have valid response" $ do
+                withManager def $ \ mgr -> do
+--                  q    <- arbitrarySample
+                  let ih = maybe def L.head hashList
+                  let q = AnnounceQuery ih "-HS0003-203534.37420" 6000
+                          (Progress 0 0 0) Nothing Nothing (Just Started)
+                  info <- announce mgr trackerURI q
+                  validateInfo q info
+            else do
+              it "should fail with RequestFailed" $ do
+                withManager def $ \ mgr -> do
+                  q <- arbitrarySample
+                  announce mgr trackerURI q
+                    `shouldThrow` isNotResponding
+
+        describe "scrape" $ do
+          if tryScraping
+            then do
+              it "have valid response" $ do
+                withManager def $ \ mgr -> do
+                  xs <- scrape mgr trackerURI [def]
+                  L.length xs `shouldSatisfy` (>= 1)
+            else do
+              it "should fail with ScrapelessTracker" $ do
+                pending
+
+          when (not tryAnnounce) $ do
+            it "should fail with RequestFailed" $ do
+              withManager def $ \ mgr -> do
+                scrape mgr trackerURI [def]
+                  `shouldThrow` isNotResponding
diff --git a/dht/bittorrent/tests/Network/BitTorrent/Tracker/RPC/UDPSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/Tracker/RPC/UDPSpec.hs
new file mode 100644
index 00000000..73acb3fa
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Tracker/RPC/UDPSpec.hs
@@ -0,0 +1,144 @@
+{-# LANGUAGE RecordWildCards #-}
+module Network.BitTorrent.Tracker.RPC.UDPSpec (spec, rpcOpts) where
+import Control.Concurrent
+import Control.Concurrent.Async
+import Control.Exception
+import Control.Monad
+import Data.Default
+import Data.List as L
+import Data.Maybe
+import Test.Hspec
+
+import Network.BitTorrent.Address
+import Network.BitTorrent.Tracker.Message as Message
+
+import Network.BitTorrent.Tracker.TestData
+import Network.BitTorrent.Tracker.MessageSpec hiding (spec)
+import Network.BitTorrent.Tracker.RPC.UDP
+
+
+validateInfo :: AnnounceQuery -> AnnounceInfo -> Expectation
+validateInfo _ Message.Failure {} = error "validateInfo: failure"
+validateInfo AnnounceQuery {..}  AnnounceInfo {..} = do
+    respComplete    `shouldSatisfy` isJust
+    respIncomplete  `shouldSatisfy` isJust
+    respMinInterval `shouldSatisfy` isNothing
+    respWarning     `shouldSatisfy` isNothing
+    peerList `shouldSatisfy` L.all (isNothing . peerId)
+  where
+    peerList = getPeerList respPeers
+
+-- | Number of concurrent calls.
+rpcCount :: Int
+rpcCount = 100
+
+rpcOpts :: Options
+rpcOpts = def
+  { optMinTimeout = 1
+  , optMaxTimeout = 10
+  }
+
+isTimeoutExpired :: RpcException -> Bool
+isTimeoutExpired (TimeoutExpired _) = True
+isTimeoutExpired  _                 = False
+
+isSomeException :: SomeException -> Bool
+isSomeException _ = True
+
+isIOException :: IOException -> Bool
+isIOException _ = True
+
+spec :: Spec
+spec = parallel $ do
+  describe "newManager" $ do
+    it "should throw exception on zero optMaxPacketSize" $ do
+      let opts = def { optMaxPacketSize = 0 }
+      newManager opts `shouldThrow` isSomeException
+
+    it "should throw exception on zero optMinTimout" $ do
+      let opts = def { optMinTimeout = 0 }
+      newManager opts `shouldThrow` isSomeException
+
+    it "should throw exception on zero optMaxTimeout" $ do
+      let opts = def { optMaxTimeout = 0 }
+      newManager opts `shouldThrow` isSomeException
+
+    it "should throw exception on maxTimeout < minTimeout" $ do
+      let opts = def { optMinTimeout = 2, optMaxTimeout = 1 }
+      newManager opts `shouldThrow` isSomeException
+
+    it "should throw exception on zero optMultiplier" $ do
+      let opts = def { optMultiplier = 0 }
+      newManager opts `shouldThrow` isSomeException
+
+  describe "closeManager" $ do
+    it "unblock rpc calls" $ do
+      mgr <- newManager rpcOpts
+      _   <- forkIO $ do
+        threadDelay 10000000
+        closeManager mgr
+      q <- arbitrarySample
+      announce mgr (trackerURI badTracker) q `shouldThrow` (== ManagerClosed)
+
+    it "announce throw exception after manager closed" $ do
+      mgr <- newManager rpcOpts
+      closeManager mgr
+      q <- arbitrarySample
+      announce mgr (trackerURI badTracker) q `shouldThrow` isIOException
+
+    it "scrape throw exception after manager closed" $ do
+      mgr <- newManager rpcOpts
+      closeManager mgr
+      scrape mgr (trackerURI badTracker) [def] `shouldThrow` isIOException
+
+  describe "withManager" $ do
+    it "closesManager at exit" $ do
+      mgr <- withManager rpcOpts return
+      scrape mgr (trackerURI badTracker) [def] `shouldThrow` isSomeException
+
+  describe "RPC" $ do
+    describe "announce" $ do
+      it "must fail on bad scheme" $ do
+        withManager rpcOpts $ \ mgr -> do
+          q <- arbitrarySample
+          announce mgr "magnet://a.com" q
+            `shouldThrow` (== UnrecognizedScheme "magnet:")
+
+    describe "scrape" $ do
+      it "must fail on bad scheme" $ do
+        withManager rpcOpts $ \ mgr -> do
+          scrape mgr "magnet://a.com" []
+            `shouldThrow` (== UnrecognizedScheme "magnet:")
+
+    forM_ (L.filter isUdpTracker trackers) $ \ TrackerEntry {..} ->
+      context trackerName $ do
+
+        describe "announce" $ do
+          if tryAnnounce then do
+            it "have valid response" $ do
+              withManager rpcOpts $ \ mgr -> do
+                q <- arbitrarySample
+                announce mgr trackerURI q >>= validateInfo q
+          else do
+            it "should throw TimeoutExpired" $ do
+              withManager rpcOpts $ \ mgr -> do
+                q <- arbitrarySample
+                announce mgr trackerURI q `shouldThrow` isTimeoutExpired
+
+        describe "scrape" $ do
+          if tryScraping then do
+            it "have valid response" $ do
+              withManager rpcOpts $ \ mgr -> do
+                xs <- scrape mgr trackerURI [def]
+                L.length xs `shouldSatisfy` (>= 1)
+          else do
+            it "should throw TimeoutExpired" $ do
+              withManager rpcOpts $ \ mgr -> do
+                scrape mgr trackerURI [def] `shouldThrow` isTimeoutExpired
+
+        describe "Manager" $ do
+          when tryScraping $ do
+            it "should handle arbitrary intermixed concurrent queries" $ do
+              withManager rpcOpts $ \ mgr -> do
+                _ <- mapConcurrently (\ _ -> scrape mgr trackerURI [def]) [1..rpcCount]
+                return ()
diff --git a/dht/bittorrent/tests/Network/BitTorrent/Tracker/RPCSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/Tracker/RPCSpec.hs
new file mode 100644
index 00000000..dfc13a1e
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Tracker/RPCSpec.hs
@@ -0,0 +1,79 @@
+{-# LANGUAGE RecordWildCards #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+module Network.BitTorrent.Tracker.RPCSpec (spec) where
+import Control.Applicative
+import Control.Monad
+import Data.Default
+import Data.List as L
+import Test.Hspec
+import Test.QuickCheck
+
+import Network.BitTorrent.Tracker.RPC as RPC
+
+import           Network.BitTorrent.Tracker.TestData
+import           Network.BitTorrent.Tracker.MessageSpec hiding (spec)
+import qualified Network.BitTorrent.Tracker.RPC.UDPSpec as UDP (rpcOpts)
+
+
+instance Arbitrary SAnnounceQuery where
+  arbitrary = SAnnounceQuery <$> arbitrary <*> arbitrary
+                             <*> arbitrary <*> arbitrary
+
+rpcOpts :: Options
+rpcOpts = def
+  { optUdpRPC = UDP.rpcOpts
+  }
+
+matchUnrecognizedScheme :: String -> RpcException -> Bool
+matchUnrecognizedScheme x (UnrecognizedScheme scheme) = x == scheme
+matchUnrecognizedScheme _  _                          = False
+
+spec :: Spec
+spec = parallel $ do
+  describe "Manager" $ do
+    describe "newManager" $ do
+      it "" $ pending
+
+    describe "closeManager" $ do
+      it "" $ pending
+
+    describe "withManager" $ do
+      it "" $ pending
+
+  describe "RPC" $ do
+    describe "announce" $ do
+      it "must fail on bad uri scheme" $ do
+        withManager rpcOpts def $ \ mgr -> do
+          q    <- arbitrarySample
+          announce mgr "magnet://foo.bar" q
+            `shouldThrow` matchUnrecognizedScheme "magnet:"
+
+    describe "scrape" $ do
+      it "must fail on bad uri scheme" $ do
+        withManager rpcOpts def $ \ mgr -> do
+          scrape mgr "magnet://foo.bar" []
+            `shouldThrow` matchUnrecognizedScheme "magnet:"
+
+    forM_ trackers $ \ TrackerEntry {..} ->
+      context trackerName $ do
+
+        describe "announce" $ do
+          if tryAnnounce then do
+            it "have valid response" $ do
+              withManager rpcOpts def $ \ mgr -> do
+                q    <- arbitrarySample
+                _    <- announce mgr trackerURI q
+                return ()
+          else do
+            it "should throw exception" $ do
+              pending
+
+        describe "scrape" $ do
+          if tryScraping then do
+            it "have valid response" $ do
+              withManager rpcOpts def $ \ mgr -> do
+                xs <- scrape mgr trackerURI [def]
+                L.length xs `shouldSatisfy` (>= 1)
+          else do
+            it "should throw exception" $ do
+              pending
diff --git a/dht/bittorrent/tests/Network/BitTorrent/Tracker/SessionSpec.hs b/dht/bittorrent/tests/Network/BitTorrent/Tracker/SessionSpec.hs
new file mode 100644
index 00000000..72936ee7
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Tracker/SessionSpec.hs
@@ -0,0 +1,61 @@
+module Network.BitTorrent.Tracker.SessionSpec (spec) where
+import Control.Monad
+import Data.Default
+import Data.List as L
+import Test.Hspec
+
+import Data.Torrent
+import Network.BitTorrent.Tracker.Message
+import Network.BitTorrent.Tracker.List
+import Network.BitTorrent.Tracker.RPC
+import Network.BitTorrent.Tracker.Session
+
+import Config
+
+testSession :: Bool -> (Manager -> Session -> IO ()) -> IO ()
+testSession runEmpty action = do
+  t <- getTestTorrent
+  withManager def def $ \ m -> do
+    withSession m (idInfoHash (tInfoDict t)) (trackerList t) $ \ s ->
+      action m s
+
+    when runEmpty $ do
+      withSession m (idInfoHash (tInfoDict t)) def $ \ s ->
+        action m s
+
+spec :: Spec
+spec = do
+  describe "Session" $ do
+    it "start new session in paused state" $ do
+      testSession True $ \ _ s -> do
+        status <- getStatus s
+        status `shouldBe` Paused
+
+  describe "Query" $ do
+    it "change status after notify" $ do
+      testSession True $ \ m s -> do
+        notify m s Started
+        status <- getStatus s
+        status `shouldBe` Running
+
+        notify m s Stopped
+        stopped <- getStatus s
+        stopped `shouldBe` Paused
+
+    it "completed event do not change status" $ do
+      testSession True $ \ m s -> do
+        notify m s Completed
+        status <- getStatus s
+        status `shouldBe` Paused
+
+      testSession True $ \ m s -> do
+        notify m s Started
+        notify m s Completed
+        status <- getStatus s
+        status `shouldBe` Running
+
+    it "return non-empty list of peers" $ do
+      testSession False $ \ m s -> do
+        notify m s Started
+        peers <- askPeers m s
+        peers `shouldSatisfy` (not . L.null)
diff --git a/dht/bittorrent/tests/Network/BitTorrent/Tracker/TestData.hs b/dht/bittorrent/tests/Network/BitTorrent/Tracker/TestData.hs
new file mode 100644
index 00000000..b95e2df4
--- /dev/null
+++ b/dht/bittorrent/tests/Network/BitTorrent/Tracker/TestData.hs
@@ -0,0 +1,93 @@
+{-# LANGUAGE RecordWildCards #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+module Network.BitTorrent.Tracker.TestData
+       ( TrackerEntry (..)
+       , isUdpTracker
+       , isHttpTracker
+       , trackers
+       , badTracker
+       ) where
+
+import Data.Maybe
+import Data.String
+import Network.URI
+
+import Data.Torrent
+
+
+data TrackerEntry = TrackerEntry
+  { -- | May be used to show tracker name in test suite report.
+    trackerName :: String
+
+    -- | Announce uri of the tracker.
+  , trackerURI  :: URI
+
+    -- | Some trackers abadoned, so don't even try to announce.
+  , tryAnnounce :: Bool
+
+    -- | Some trackers do not support scraping, so we should not even
+    -- try to scrape them.
+  , tryScraping :: Bool
+
+    -- | Some trackers allow
+  , hashList    :: Maybe [InfoHash]
+  }
+
+isUdpTracker :: TrackerEntry -> Bool
+isUdpTracker TrackerEntry {..} = uriScheme trackerURI == "udp:"
+
+isHttpTracker :: TrackerEntry -> Bool
+isHttpTracker TrackerEntry {..} = uriScheme trackerURI == "http:"
+                               || uriScheme trackerURI == "https:"
+
+instance IsString URI where
+  fromString str = fromMaybe err $ parseURI str
+    where
+      err = error $ "fromString: bad URI " ++ show str
+
+trackerEntry :: URI -> TrackerEntry
+trackerEntry uri = TrackerEntry
+  { trackerName = maybe "<unknown>" uriRegName (uriAuthority uri)
+  , trackerURI  = uri
+  , tryAnnounce = False
+  , tryScraping = False
+  , hashList    = Nothing
+  }
+
+announceOnly :: String -> URI -> TrackerEntry
+announceOnly name uri = (trackerEntry uri)
+  { trackerName = name
+  , tryAnnounce = True
+  }
+
+announceScrape :: String -> URI -> TrackerEntry
+announceScrape name uri = (announceOnly name uri)
+  { tryScraping = True
+  }
+
+notWorking :: String -> URI -> TrackerEntry
+notWorking name uri = (trackerEntry uri)
+  { trackerName = name
+  }
+
+trackers :: [TrackerEntry]
+trackers =
+  [ (announceOnly "LinuxTracker"
+    "http://linuxtracker.org:2710/00000000000000000000000000000000/announce")
+    { hashList = Just ["1c82a95b9e02bf3db4183da072ad3ef656aacf0e"] -- debian 7
+    }
+
+  , (announceScrape "Arch" "http://tracker.archlinux.org:6969/announce")
+    { hashList = Just ["bc9ae647a3e6c3636de58535dd3f6360ce9f4621"]
+    }
+
+  , notWorking     "rarbg" "udp://9.rarbg.com:2710/announce"
+
+  , announceScrape "OpenBitTorrent" "udp://tracker.openbittorrent.com:80/announce"
+  , announceScrape "PublicBT"       "udp://tracker.publicbt.com:80/announce"
+  , notWorking     "OpenBitTorrent" "http://tracker.openbittorrent.com:80/announce"
+  , notWorking     "PublicBT"       "http://tracker.publicbt.com:80/announce"
+  ]
+
+badTracker :: TrackerEntry
+badTracker = notWorking "rarbg" "udp://9.rarbg.com:2710/announce"
\ No newline at end of file
diff --git a/dht/bittorrent/tests/Network/KRPC/MessageSpec.hs b/dht/bittorrent/tests/Network/KRPC/MessageSpec.hs
new file mode 100644
index 00000000..498ef679
--- /dev/null
+++ b/dht/bittorrent/tests/Network/KRPC/MessageSpec.hs
@@ -0,0 +1,72 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+module Network.KRPC.MessageSpec (spec) where
+import Control.Applicative
+import Data.ByteString.Lazy as BL
+import Test.Hspec
+import Test.QuickCheck
+import Test.QuickCheck.Instances ()
+
+import Data.BEncode as BE
+import Network.KRPC.Message
+
+instance Arbitrary ErrorCode where
+  arbitrary = arbitraryBoundedEnum
+
+instance Arbitrary KError where
+  arbitrary = KError <$> arbitrary <*> arbitrary <*> arbitrary
+
+instance Arbitrary KQuery where
+  arbitrary = KQuery <$> pure (BInteger 0) <*> arbitrary <*> arbitrary
+
+instance Arbitrary KResponse where
+  -- TODO: Abitrary instance for ReflectedIP
+  arbitrary = KResponse <$> pure (BList []) <*> arbitrary <*> pure Nothing
+
+instance Arbitrary KMessage where
+  arbitrary = frequency
+    [ (1, Q <$> arbitrary)
+    , (1, R <$> arbitrary)
+    , (1, E <$> arbitrary)
+    ]
+
+spec :: Spec
+spec = do
+  describe "error message" $ do
+    it "properly bencoded (iso)" $ property $ \ ke ->
+      BE.decode (BL.toStrict (BE.encode ke)) `shouldBe` Right (ke :: KError)
+
+    it "properly bencoded" $ do
+      BE.decode "d1:eli201e23:A Generic Error Ocurrede1:t2:aa1:y1:ee"
+        `shouldBe` Right (KError GenericError "A Generic Error Ocurred" "aa")
+
+      BE.decode "d1:eli202e22:A Server Error Ocurrede1:t2:bb1:y1:ee"
+        `shouldBe` Right (KError ServerError "A Server Error Ocurred" "bb")
+
+      BE.decode "d1:eli203e24:A Protocol Error Ocurrede1:t2:cc1:y1:ee"
+        `shouldBe` Right (KError ProtocolError "A Protocol Error Ocurred" "cc")
+
+      BE.decode "d1:eli204e30:Attempt to call unknown methode1:t2:dd1:y1:ee"
+        `shouldBe` Right
+          (KError MethodUnknown "Attempt to call unknown method" "dd")
+
+  describe "query message" $ do
+    it "properly bencoded (iso)" $ property $ \ kq ->
+      BE.decode (BL.toStrict (BE.encode kq)) `shouldBe` Right (kq :: KQuery)
+
+    it "properly bencoded" $ do
+      BE.decode "d1:ale1:q4:ping1:t2:aa1:y1:qe" `shouldBe`
+        Right (KQuery (BList []) "ping" "aa")
+
+
+  describe "response message" $ do
+    it "properly bencoded (iso)" $ property $ \ kr ->
+      BE.decode (BL.toStrict (BE.encode kr)) `shouldBe` Right (kr :: KResponse)
+
+    it "properly bencoded" $ do
+      BE.decode "d1:rle1:t2:aa1:y1:re" `shouldBe`
+        Right (KResponse (BList []) "aa" Nothing)
+
+  describe "generic message" $ do
+    it "properly bencoded (iso)" $ property $ \ km ->
+      BE.decode (BL.toStrict (BE.encode km)) `shouldBe` Right (km :: KMessage)
diff --git a/dht/bittorrent/tests/Network/KRPC/MethodSpec.hs b/dht/bittorrent/tests/Network/KRPC/MethodSpec.hs
new file mode 100644
index 00000000..c1c58282
--- /dev/null
+++ b/dht/bittorrent/tests/Network/KRPC/MethodSpec.hs
@@ -0,0 +1,52 @@
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE FlexibleInstances     #-}
+{-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE DeriveDataTypeable    #-}
+{-# OPTIONS_GHC -fno-warn-orphans  #-}
+module Network.KRPC.MethodSpec where
+import Control.Applicative
+import Data.BEncode
+import Data.ByteString as BS
+import Data.Typeable
+import Network.KRPC
+import Test.Hspec
+
+
+data Ping = Ping
+  deriving (Show, Eq, Typeable)
+
+instance BEncode Ping where
+  toBEncode Ping = toBEncode ()
+  fromBEncode b  = Ping <$ (fromBEncode b :: Result ())
+
+instance KRPC Ping Ping
+
+ping :: Monad h => Handler h
+ping = handler $ \ _ Ping -> return Ping
+
+newtype Echo a = Echo a
+  deriving (Show, Eq, BEncode, Typeable)
+
+echo :: Monad h => Handler h
+echo = handler $ \ _ (Echo a) -> return (Echo (a :: ByteString))
+
+instance (Typeable a, BEncode a) => KRPC (Echo a) (Echo a)
+
+spec :: Spec
+spec = do
+  describe "ping method" $ do
+    it "name is ping" $ do
+      (method :: Method Ping Ping) `shouldBe` "ping"
+
+    it "has pretty Show instance" $ do
+      show (method :: Method Ping Ping) `shouldBe` "ping :: Ping -> Ping"
+
+  describe "echo method" $ do
+    it "is overloadable" $ do
+      (method :: Method (Echo Int ) (Echo Int )) `shouldBe` "echo int"
+      (method :: Method (Echo Bool) (Echo Bool)) `shouldBe` "echo bool"
+
+    it "has pretty Show instance" $ do
+      show (method :: Method (Echo Int) (Echo Int))
+        `shouldBe` "echo int :: Echo Int -> Echo Int"
\ No newline at end of file
diff --git a/dht/bittorrent/tests/Network/KRPCSpec.hs b/dht/bittorrent/tests/Network/KRPCSpec.hs
new file mode 100644
index 00000000..eabcc817
--- /dev/null
+++ b/dht/bittorrent/tests/Network/KRPCSpec.hs
@@ -0,0 +1,59 @@
+{-# LANGUAGE OverloadedStrings    #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+module Network.KRPCSpec (spec) where
+import Control.Monad.Logger
+import Control.Monad.Reader
+import Network.KRPC
+import Network.KRPC.MethodSpec hiding (spec)
+import Test.Hspec
+
+servAddr :: SockAddr
+servAddr = SockAddrInet 6000 (256 * 256 * 256 + 127)
+
+handlers :: [Handler IO]
+handlers =
+ [ handler $ \ _ Ping     -> return Ping
+ , handler $ \ _ (Echo a) -> return (Echo (a :: Bool))
+ , handler $ \ _ (Echo a) -> return (Echo (a :: Int))
+ ]
+
+instance MonadLogger IO where
+  monadLoggerLog _ _ _ _ = return ()
+
+opts :: Options
+opts = def { optQueryTimeout = 1 }
+
+spec :: Spec
+spec = do
+  let qr :: MonadKRPC h m => SockAddr -> Echo Int -> m (Echo Int)
+      qr = query
+
+  describe "manager" $ do
+    it "is active until closeManager called" $ do
+      m <- newManager opts servAddr []
+      isActive m `shouldReturn` True
+      closeManager m
+      isActive m `shouldReturn` False
+
+  describe "query" $ do
+    it "run handlers" $ do
+      let int = 0xabcd :: Int
+      (withManager opts servAddr handlers $ runReaderT $ do
+         listen
+         query servAddr (Echo int))
+       `shouldReturn` Echo int
+
+    it "count transactions properly" $ do
+      (withManager opts servAddr handlers $ runReaderT $ do
+         listen
+         _ <- qr servAddr (Echo 0xabcd)
+         _ <- qr servAddr (Echo 0xabcd)
+         getQueryCount
+       )
+        `shouldReturn` 2
+
+    it "throw timeout exception" $ do
+      (withManager opts servAddr handlers $ runReaderT $ do
+         qr servAddr (Echo 0xabcd)
+       )
+        `shouldThrow` (== TimeoutExpired)