Add unit roundtrip tests

src/Swarm/Language/Pipeline.hs

@@ -53,7 +53,7 @@ data ProcessedTerm
       -- ^ Capabilities required by the term
       CapCtx
       -- ^ Capability context for any definitions embedded in the term
-  deriving (Data, Show, Generic, ToJSON)
+  deriving (Data, Show, Eq, Generic)
 
 instance FromJSON ProcessedTerm where
   parseJSON = withText "Term" tryProcess
@@ -64,6 +64,9 @@ instance FromJSON ProcessedTerm where
       Right Nothing -> fail "Term was only whitespace"
       Right (Just pt) -> return pt
 
+instance ToJSON ProcessedTerm where
+  toJSON (ProcessedTerm t _ _ _) = String $ prettyText t
+
 -- | Given a 'Text' value representing a Swarm program,
 --
 --   1. Parse it (see "Swarm.Language.Parse")

swarm.cabal

@@ -154,6 +154,7 @@ test-suite swarm-unit
                       tasty-hunit                   >= 0.10 && < 0.11,
                       tasty-quickcheck              >= 0.10 && < 0.11,
                       -- Imports shared with the library don't need bounds
+                      aeson,
                       base,
                       filepath,
                       hashable,

test/unit/Main.hs

@@ -9,10 +9,14 @@ module Main where
 import Control.Lens ((&), (.~), (^.))
 import Control.Monad.Except
 import Control.Monad.State
+import Data.Aeson (eitherDecode, encode)
+import Data.Either
 import Data.Hashable
+import Data.Maybe
 import Data.String (fromString)
 import Data.Text (Text)
 import Data.Text qualified as T
+import Data.Text.Encoding qualified as T
 import Linear
 import Test.Tasty
 import Test.Tasty.HUnit
@@ -139,10 +143,22 @@ parser =
                 )
             )
         ]
+    , testGroup
+        "json encoding"
+        [ testCase "simple expr" (roundTrip "42 + 43")
+        , testCase "module def" (roundTrip "def x = 41 end; def y = 42 end")
+        ]
     ]
  where
   valid = flip process ""
 
+  roundTrip txt = assertEqual "rountrip" term (decodeThrow $ encode term)
+   where
+    decodeThrow v = case eitherDecode v of
+      Left e -> error $ "Decoding of " <> from (T.decodeUtf8 (from v)) <> " failed with: " <> from e
+      Right x -> x
+    term = fromMaybe (error "") $ fromRight (error "") $ processTerm txt
+
   process :: Text -> Text -> Assertion
   process code expect = case processTerm code of
     Left e