module Main where

import Control.Concurrent.STM
import Control.Lens
import Control.Monad.Morph
import Data.Foldable
import qualified Pipes as P
import qualified Pipes.Concurrent as PC
import qualified Pipes.Misc as PM
import qualified Pipes.Prelude as PP
import Test.Hspec

data1 :: [Int]
data1 = [1, 2..9]

sig1 :: Monad m => P.Producer Int m ()
sig1 = traverse_ P.yield data1

main :: IO ()
main = do
  hspec $ do
      describe "Misc" $ do
          it "Buffered" $ do
              let xs = PP.toList (sig1 P.>-> PM.buffer 2 [])
              xs `shouldBe` (pure $ head data1) : ((\(a, b) -> [a, b]) <$> zip (tail data1) data1)

          it "Locally +10 to second" $ do
              let xs = PP.toList
                       (sig1
                        P.>-> PP.map (\a -> (a, a))
                        P.>-> PM.locally (view _2) (set _2) (PP.map (+ 10)))
              xs `shouldBe` zip data1 ((+ 10) <$> data1)
          it "Filtering STM Producer blocks" $ do
              sig <- PM.mkProducerSTM (PC.bounded 1) sig1
              PP.toListM (hoist atomically (sig P.>-> PP.filter even)) `shouldThrow` anyException