test: add scenarios for parsing basic schemata

Author: mstream

test/unit/Test/Spec/JsonSchema/Codec.purs

@@ -12,16 +12,19 @@ import Data.Argonaut.Gen as AGen
 import Data.Either (Either(..))
 import Data.Either.Nested (type (\/))
 import Data.Foldable (notElem)
+import Data.Map as Map
+import Data.Maybe (Maybe(..))
 import Data.String (Pattern(..))
 import Data.String as String
 import Data.String.Gen as StringGen
 import Data.Tuple.Nested ((/\))
 import Foreign.Object as Object
-import JsonSchema (JsonSchema)
+import JsonSchema (JsonSchema(..), ObjectFormJsonSchemaSpec(..))
 import JsonSchema as Schema
 import JsonSchema.Codec as Codec
 import Test.QuickCheck (Result(..), (===))
-import Test.Spec (describe)
+import Test.Spec (describe, it)
+import Test.Spec.Assertions (fail, shouldEqual)
 import Test.Types (TestSpec)
 import Test.Utils (TestLength(..), generativeTestCase)
 
@@ -99,6 +102,79 @@ spec = describe "Codec" do
           , pattern: "type"
           }
 
+    positiveParseTestCase
+      { description: "an empty object schema"
+      , expectedSchema: ObjectFormJsonSchema JsonEmptySchema
+      , json: A.jsonEmptyObject
+      }
+
+    positiveParseTestCase
+      { description: "a false boolean schema"
+      , expectedSchema: BooleanFormJsonSchema false
+      , json: A.fromBoolean false
+      }
+
+    positiveParseTestCase
+      { description: "a true boolean schema"
+      , expectedSchema: BooleanFormJsonSchema true
+      , json: A.fromBoolean true
+      }
+
+    positiveParseTestCase
+      { description: "a schema for an array"
+      , expectedSchema: ObjectFormJsonSchema
+          $ JsonArraySchema { itemsSchema: Nothing, uniqueItems: false }
+      , json: A.jsonSingletonObject "type" $ A.fromString "array"
+      }
+
+    positiveParseTestCase
+      { description: "a schema for a boolean"
+      , expectedSchema: ObjectFormJsonSchema JsonBooleanSchema
+      , json: A.jsonSingletonObject "type" $ A.fromString "boolean"
+      }
+
+    positiveParseTestCase
+      { description: "a schema for integer"
+      , expectedSchema: ObjectFormJsonSchema $ JsonIntegerSchema {}
+      , json: A.jsonSingletonObject "type" $ A.fromString "integer"
+      }
+
+    positiveParseTestCase
+      { description: "a schema for a null"
+      , expectedSchema: ObjectFormJsonSchema JsonNullSchema
+      , json: A.jsonSingletonObject "type" $ A.fromString "null"
+      }
+
+    positiveParseTestCase
+      { description: "a schema for a number"
+      , expectedSchema: ObjectFormJsonSchema $ JsonNumberSchema {}
+      , json: A.jsonSingletonObject "type" $ A.fromString "number"
+      }
+
+    positiveParseTestCase
+      { description: "a schema for an object"
+      , expectedSchema: ObjectFormJsonSchema
+          $ JsonObjectSchema { properties: Map.empty }
+      , json: A.jsonSingletonObject "type" $ A.fromString "object"
+      }
+
+    positiveParseTestCase
+      { description: "a schema for a string"
+      , expectedSchema: ObjectFormJsonSchema $ JsonStringSchema {}
+      , json: A.jsonSingletonObject "type" $ A.fromString "string"
+      }
+
+positiveParseTestCase
+  ∷ { description ∷ String, expectedSchema ∷ JsonSchema, json ∷ Json }
+  → TestSpec
+positiveParseTestCase { description, expectedSchema, json } = it
+  ("Should parse " <> description)
+  case Codec.parseSchema json of
+    Left parseErrorMessage →
+      fail $ "Could not parse JSON schema: " <> parseErrorMessage
+    Right parsedSchema →
+      parsedSchema `shouldEqual` expectedSchema
+
 errorMessageShouldMention
   ∷ { description ∷ String
     , parsingResult ∷ String \/ JsonSchema

test/unit/Test/Utils.purs

@@ -5,17 +5,12 @@ module Test.Utils
 
 import Prelude
 
-import Data.Array as Array
-import Data.Foldable (class Foldable, foldM)
 import Data.Maybe (maybe)
-import Data.String (Pattern(..), Replacement(..))
-import Data.String as String
 import Effect (Effect)
 import Effect.Class (liftEffect)
 import Node.Process as Process
 import Test.QuickCheck (Result, quickCheckGen')
 import Test.QuickCheck.Gen (Gen)
-import Test.QuickCheck.Gen as Gen
 import Test.Spec (it)
 import Test.Types (TestSpec)