swagger-petstore-0.0.1.2: tests/Instances.hs

{-# OPTIONS_GHC -fno-warn-unused-imports #-}

module Instances where

import Data.Text (Text, pack)
import Data.Char (isSpace)
import Data.List (sort)
import qualified Data.Time as TI
import Test.QuickCheck
import qualified Data.HashMap.Strict as HM
import qualified Data.Set as Set
import qualified Data.ByteString.Lazy as BL

import ApproxEq
import SwaggerPetstore.Model

instance Arbitrary Text where
  arbitrary = pack <$> arbitrary

instance Arbitrary TI.Day where
  arbitrary = TI.ModifiedJulianDay . (2000 +) <$> arbitrary
  shrink = (TI.ModifiedJulianDay <$>) . shrink . TI.toModifiedJulianDay

instance Arbitrary TI.UTCTime where
  arbitrary =
    TI.UTCTime <$> arbitrary <*> (TI.secondsToDiffTime <$> choose (0, 86401))

instance Arbitrary BL.ByteString where
    arbitrary = BL.pack <$> arbitrary
    shrink xs = BL.pack <$> shrink (BL.unpack xs)

instance Arbitrary ByteArray where
    arbitrary = ByteArray <$> arbitrary
    shrink (ByteArray xs) = ByteArray <$> shrink xs

instance Arbitrary Binary where
    arbitrary = Binary <$> arbitrary
    shrink (Binary xs) = Binary <$> shrink xs

instance Arbitrary DateTime where
    arbitrary = DateTime <$> arbitrary
    shrink (DateTime xs) = DateTime <$> shrink xs

instance Arbitrary Date where
    arbitrary = Date <$> arbitrary
    shrink (Date xs) = Date <$> shrink xs

-- | Checks if a given list has no duplicates in _O(n log n)_.
hasNoDups
  :: (Ord a)
  => [a] -> Bool
hasNoDups = go Set.empty
  where
    go _ [] = True
    go s (x:xs)
      | s' <- Set.insert x s
      , Set.size s' > Set.size s = go s' xs
      | otherwise = False

instance ApproxEq TI.Day where
  (=~) = (==)

-- * Models
 
instance Arbitrary AdditionalPropertiesClass where
  arbitrary =
    AdditionalPropertiesClass
      <$> arbitrary -- additionalPropertiesClassMapProperty :: Maybe (Map.Map String Text)
      <*> arbitrary -- additionalPropertiesClassMapOfMapProperty :: Maybe (Map.Map String (Map.Map String Text))
    

instance Arbitrary Animal where
  arbitrary =
    Animal
      <$> arbitrary -- animalClassName :: Text
      <*> arbitrary -- animalColor :: Maybe Text
    

instance Arbitrary AnimalFarm where
  arbitrary =
    pure AnimalFarm
     

instance Arbitrary ApiResponse where
  arbitrary =
    ApiResponse
      <$> arbitrary -- apiResponseCode :: Maybe Int
      <*> arbitrary -- apiResponseType :: Maybe Text
      <*> arbitrary -- apiResponseMessage :: Maybe Text
    

instance Arbitrary ArrayOfArrayOfNumberOnly where
  arbitrary =
    ArrayOfArrayOfNumberOnly
      <$> arbitrary -- arrayOfArrayOfNumberOnlyArrayArrayNumber :: Maybe [[Double]]
    

instance Arbitrary ArrayOfNumberOnly where
  arbitrary =
    ArrayOfNumberOnly
      <$> arbitrary -- arrayOfNumberOnlyArrayNumber :: Maybe [Double]
    

instance Arbitrary ArrayTest where
  arbitrary =
    ArrayTest
      <$> arbitrary -- arrayTestArrayOfString :: Maybe [Text]
      <*> arbitrary -- arrayTestArrayArrayOfInteger :: Maybe [[Integer]]
      <*> arbitrary -- arrayTestArrayArrayOfModel :: Maybe [[ReadOnlyFirst]]
    

instance Arbitrary Capitalization where
  arbitrary =
    Capitalization
      <$> arbitrary -- capitalizationSmallCamel :: Maybe Text
      <*> arbitrary -- capitalizationCapitalCamel :: Maybe Text
      <*> arbitrary -- capitalizationSmallSnake :: Maybe Text
      <*> arbitrary -- capitalizationCapitalSnake :: Maybe Text
      <*> arbitrary -- capitalizationScaEthFlowPoints :: Maybe Text
      <*> arbitrary -- capitalizationAttName :: Maybe Text
    

instance Arbitrary Category where
  arbitrary =
    Category
      <$> arbitrary -- categoryId :: Maybe Integer
      <*> arbitrary -- categoryName :: Maybe Text
    

instance Arbitrary ClassModel where
  arbitrary =
    ClassModel
      <$> arbitrary -- classModelClass :: Maybe Text
    

instance Arbitrary Client where
  arbitrary =
    Client
      <$> arbitrary -- clientClient :: Maybe Text
    

instance Arbitrary EnumArrays where
  arbitrary =
    EnumArrays
      <$> arbitrary -- enumArraysJustSymbol :: Maybe Text
      <*> arbitrary -- enumArraysArrayEnum :: Maybe [Text]
    

instance Arbitrary EnumClass where
  arbitrary =
    pure EnumClass
     

instance Arbitrary EnumTest where
  arbitrary =
    EnumTest
      <$> arbitrary -- enumTestEnumString :: Maybe Text
      <*> arbitrary -- enumTestEnumInteger :: Maybe Int
      <*> arbitrary -- enumTestEnumNumber :: Maybe Double
      <*> arbitrary -- enumTestOuterEnum :: Maybe OuterEnum
    

instance Arbitrary FormatTest where
  arbitrary =
    FormatTest
      <$> arbitrary -- formatTestInteger :: Maybe Int
      <*> arbitrary -- formatTestInt32 :: Maybe Int
      <*> arbitrary -- formatTestInt64 :: Maybe Integer
      <*> arbitrary -- formatTestNumber :: Double
      <*> arbitrary -- formatTestFloat :: Maybe Float
      <*> arbitrary -- formatTestDouble :: Maybe Double
      <*> arbitrary -- formatTestString :: Maybe Text
      <*> arbitrary -- formatTestByte :: ByteArray
      <*> arbitrary -- formatTestBinary :: Maybe Binary
      <*> arbitrary -- formatTestDate :: Date
      <*> arbitrary -- formatTestDateTime :: Maybe DateTime
      <*> arbitrary -- formatTestUuid :: Maybe Text
      <*> arbitrary -- formatTestPassword :: Text
    

instance Arbitrary HasOnlyReadOnly where
  arbitrary =
    HasOnlyReadOnly
      <$> arbitrary -- hasOnlyReadOnlyBar :: Maybe Text
      <*> arbitrary -- hasOnlyReadOnlyFoo :: Maybe Text
    

instance Arbitrary MapTest where
  arbitrary =
    MapTest
      <$> arbitrary -- mapTestMapMapOfString :: Maybe (Map.Map String (Map.Map String Text))
      <*> arbitrary -- mapTestMapOfEnumString :: Maybe (Map.Map String Text)
    

instance Arbitrary MixedPropertiesAndAdditionalPropertiesClass where
  arbitrary =
    MixedPropertiesAndAdditionalPropertiesClass
      <$> arbitrary -- mixedPropertiesAndAdditionalPropertiesClassUuid :: Maybe Text
      <*> arbitrary -- mixedPropertiesAndAdditionalPropertiesClassDateTime :: Maybe DateTime
      <*> arbitrary -- mixedPropertiesAndAdditionalPropertiesClassMap :: Maybe (Map.Map String Animal)
    

instance Arbitrary Model200Response where
  arbitrary =
    Model200Response
      <$> arbitrary -- model200ResponseName :: Maybe Int
      <*> arbitrary -- model200ResponseClass :: Maybe Text
    

instance Arbitrary ModelList where
  arbitrary =
    ModelList
      <$> arbitrary -- modelList123List :: Maybe Text
    

instance Arbitrary ModelReturn where
  arbitrary =
    ModelReturn
      <$> arbitrary -- modelReturnReturn :: Maybe Int
    

instance Arbitrary Name where
  arbitrary =
    Name
      <$> arbitrary -- nameName :: Int
      <*> arbitrary -- nameSnakeCase :: Maybe Int
      <*> arbitrary -- nameProperty :: Maybe Text
      <*> arbitrary -- name123Number :: Maybe Int
    

instance Arbitrary NumberOnly where
  arbitrary =
    NumberOnly
      <$> arbitrary -- numberOnlyJustNumber :: Maybe Double
    

instance Arbitrary Order where
  arbitrary =
    Order
      <$> arbitrary -- orderId :: Maybe Integer
      <*> arbitrary -- orderPetId :: Maybe Integer
      <*> arbitrary -- orderQuantity :: Maybe Int
      <*> arbitrary -- orderShipDate :: Maybe DateTime
      <*> arbitrary -- orderStatus :: Maybe Text
      <*> arbitrary -- orderComplete :: Maybe Bool
    

instance Arbitrary OuterBoolean where
  arbitrary =
    pure OuterBoolean
     

instance Arbitrary OuterComposite where
  arbitrary =
    OuterComposite
      <$> arbitrary -- outerCompositeMyNumber :: Maybe OuterNumber
      <*> arbitrary -- outerCompositeMyString :: Maybe OuterString
      <*> arbitrary -- outerCompositeMyBoolean :: Maybe OuterBoolean
    

instance Arbitrary OuterEnum where
  arbitrary =
    pure OuterEnum
     

instance Arbitrary OuterNumber where
  arbitrary =
    pure OuterNumber
     

instance Arbitrary OuterString where
  arbitrary =
    pure OuterString
     

instance Arbitrary Pet where
  arbitrary =
    Pet
      <$> arbitrary -- petId :: Maybe Integer
      <*> arbitrary -- petCategory :: Maybe Category
      <*> arbitrary -- petName :: Text
      <*> arbitrary -- petPhotoUrls :: [Text]
      <*> arbitrary -- petTags :: Maybe [Tag]
      <*> arbitrary -- petStatus :: Maybe Text
    

instance Arbitrary ReadOnlyFirst where
  arbitrary =
    ReadOnlyFirst
      <$> arbitrary -- readOnlyFirstBar :: Maybe Text
      <*> arbitrary -- readOnlyFirstBaz :: Maybe Text
    

instance Arbitrary SpecialModelName where
  arbitrary =
    SpecialModelName
      <$> arbitrary -- specialModelNameSpecialPropertyName :: Maybe Integer
    

instance Arbitrary Tag where
  arbitrary =
    Tag
      <$> arbitrary -- tagId :: Maybe Integer
      <*> arbitrary -- tagName :: Maybe Text
    

instance Arbitrary User where
  arbitrary =
    User
      <$> arbitrary -- userId :: Maybe Integer
      <*> arbitrary -- userUsername :: Maybe Text
      <*> arbitrary -- userFirstName :: Maybe Text
      <*> arbitrary -- userLastName :: Maybe Text
      <*> arbitrary -- userEmail :: Maybe Text
      <*> arbitrary -- userPassword :: Maybe Text
      <*> arbitrary -- userPhone :: Maybe Text
      <*> arbitrary -- userUserStatus :: Maybe Int
    

instance Arbitrary Cat where
  arbitrary =
    Cat
      <$> arbitrary -- catClassName :: Text
      <*> arbitrary -- catColor :: Maybe Text
      <*> arbitrary -- catDeclawed :: Maybe Bool
    

instance Arbitrary Dog where
  arbitrary =
    Dog
      <$> arbitrary -- dogClassName :: Text
      <*> arbitrary -- dogColor :: Maybe Text
      <*> arbitrary -- dogBreed :: Maybe Text