fakedata-0.5.0: test/AddressSpec.hs
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE OverloadedStrings #-}
module AddressSpec where
import qualified Data.Map as M
import Data.Text hiding (all, map)
import qualified Data.Text as T
import qualified Data.Vector as V
import Faker hiding (defaultFakerSettings)
import Faker.Address
import Faker.Internal
-- import Faker.Provider.Address
import Test.Hspec
import TestImport
fakerException :: Selector FakerException
fakerException = const True
spec :: Spec
spec = do
describe "Address" $ do
-- it "parses countries for defaultSettings" $ do
-- ctries <- countryProvider defaultFakerSettings
-- ctries `shouldSatisfy` (\x -> V.length x >= 40)
-- it "parses countryByCode for defaultSettings" $ do
-- ctries <- countryByCodeProvider defaultFakerSettings
-- ctries `shouldSatisfy` (\x -> Prelude.length (M.toList x) >= 40)
-- it "parses countries for other locales" $ do
-- locales <- populateLocales
-- let settings :: [FakerSettings] =
-- map (\l -> setLocale l defaultFakerSettings) locales
-- ctries :: IO [V.Vector Text] = mapM countryProvider settings
-- ctries' :: [V.Vector Text] <- ctries
-- let exp :: [Bool] = map (\x -> V.length x >= 10) ctries'
-- True `shouldBe` (all (\x -> x == True) exp)
it "produces random integer text" $ do
let txt = interpolateNumbers defaultFakerSettings "#####"
let num :: Int = read (unpack txt)
num `shouldSatisfy` (\x -> x >= 0 && T.length txt == 5)
it "produces random integer only for hash" $ do
let txt = interpolateNumbers defaultFakerSettings "ab-##"
txt `shouldSatisfy` (\x -> T.length x == 5 && (T.take 3 x == "ab-"))
it "produces random alphabets" $ do
let txt = interpolateString defaultFakerSettings "????"
txt `shouldBe` "XJZS"
it "preserves unwanted things" $ do
let txt = interpolateString defaultFakerSettings "32-????"
txt `shouldBe` "32-XJZS"
it "preserves unwanted things and works with numbers" $ do
txt <-
resolveUnresolved
defaultFakerSettings
(pure $ pure $ "32-????-####")
(\s t -> pure t)
txt `shouldBe` "32-XJZS-1534"
it "doesn't get confused with garbage" $ do
txt <-
resolveUnresolved
defaultFakerSettings
(pure $ pure $ "abjakf-324jak")
(\s t -> pure t)
txt `shouldBe` "abjakf-324jak"
it "resolve field" $ do
let field = resolveFields "#{community_prefix} #{community_suffix}"
field `shouldBe` ["community_prefix", "community_suffix"]
it "resolve field with dot" $ do
let field =
resolveFields "#{city_prefix} #{Name.first_name}#{city_suffix}"
field `shouldBe` ["city_prefix", "Name.first_name", "city_suffix"]
it "resolve field with dot (2)" $ do
let field = resolveFields "#{Name.last_name} #{street_suffix}"
field `shouldBe` ["Name.last_name", "street_suffix"]
it "resolve field with commas" $ do
let field =
resolveFields
"#{secondary_address} #{street_address}, #{city}, #{state_abbr} #{zip_code}"
field `shouldBe`
[ "secondary_address"
, "street_address"
, "city"
, "state_abbr"
, "zip_code"
]
-- it "resolveAddressField" $ do
-- item <- resolveAddressField defaultFakerSettings "community_suffix"
-- item `shouldSatisfy` (\x -> T.length x > 0)
it "uncons2" $ do
let item = uncons2 "hello"
item `shouldBe` Just ("he" :: String, "llo" :: Text)
describe "operateField" $ do
it "sample example" $ do
let item = operateField "#{hello} #{world}" "jam"
item `shouldBe` "jam #{world}"
it "leading space example" $ do
let item = operateField " #{hello} #{world}" "jam"
item `shouldBe` " jam #{world}"
it "trailing chars" $ do
let item = operateField " #{hello} #{world} kool" "jam"
item `shouldBe` " jam #{world} kool"
it "edge case" $ do
let item = operateField "this is" "jam"
item `shouldBe` "this is"
describe "operateFields" $ do
it "sample example" $ do
let item = operateFields "#{hello} #{world}" ["jam", "cream"]
item `shouldBe` "jam cream"
it "leading space example" $ do
let item = operateFields " #{hello} #{world}" ["jam", "cream"]
item `shouldBe` " jam cream"
it "extra arguments" $ do
let item =
operateFields " #{hello} #{world} kool" ["jam", "kool", "name"]
item `shouldBe` " jam kool kool"
-- it "resolveAddressText" $ do
-- item <-
-- resolveAddressText
-- defaultFakerSettings
-- "#{community_prefix} #{community_suffix}"
-- item `shouldSatisfy` (\x -> T.length x > 0 && T.any (== ' ') item)
-- describe "Resolver check" $ do
-- it "community" $ do
-- item <-
-- resolveAddressText
-- defaultFakerSettings
-- "#{community_prefix} #{community_suffix}"
-- item `shouldSatisfy` (\x -> T.length x >= 5)
-- it "community via function" $ do
-- comm <- communityProvider defaultFakerSettings
-- item <- resolveUnresolved defaultFakerSettings comm resolveAddressText
-- item `shouldSatisfy` (\x -> T.length x >= 5)
-- it "building_number" $ do
-- comm <- buildingNumberProvider defaultFakerSettings
-- item <- resolveUnresolved defaultFakerSettings comm resolveAddressText
-- item `shouldSatisfy` (\x -> T.length x >= 3)
-- it "secondary_address" $ do
-- comm <- secondaryAddressProvider defaultFakerSettings
-- item <- resolveUnresolved defaultFakerSettings comm resolveAddressText
-- item `shouldSatisfy` (\x -> T.length x >= 5)
-- it "street_address" $ do
-- item <-
-- resolveAddressText
-- defaultFakerSettings
-- "#{Name.last_name} #{street_suffix}"
-- item `shouldSatisfy` (\x -> T.length x >= 5)
-- it "street_address via function" $ do
-- comm <- streetAddressProvider defaultFakerSettings
-- item <- resolveUnresolved defaultFakerSettings comm resolveAddressText
-- item `shouldSatisfy` (\x -> T.length x >= 5)
describe "Address functions" $ do
it "basic check" $ do
fakeCountry <- generate country
fakeCountry `shouldBe` "Ecuador"
-- it "check community equality" $ do
-- let community1 :: Fake Text
-- community1 =
-- Fake
-- (cachedRandomUnresolvedVec
-- "address"
-- "community"
-- communityProvider
-- resolveAddressText)
-- c1 <- generate community1
-- c2 <- generate community
-- c1 `shouldBe` c2
-- it "check city prefix equality" $ do
-- let cityPrefix1 :: Fake Text
-- cityPrefix1 =
-- Fake
-- (cachedRandomVec
-- "address"
-- "cityPrefix"
-- addressCityPrefixProvider)
-- c1 <- generate cityPrefix1
-- c2 <- generate cityPrefix
-- c1 `shouldBe` c2
it "Monad instance of Fake" $ do
let someCountry :: Fake Text
someCountry = do
c1 <- country
pure c1
fakeCountry <- generate someCountry
fakeCountry `shouldBe` "Ecuador"
it "Equality of normal generation and Monad" $ do
fakeCountry <- generate country
let someCountry :: Fake Text
someCountry = do
c1 <- country
pure c1
c2 <- generate someCountry
fakeCountry `shouldBe` c2
it "Monad instance of Fake (tuple)" $ do
let someCountry :: Fake (Text, Text)
someCountry = do
c1 <- country
c2 <- country
pure (c1, c2)
fakeCountry <- generate someCountry
fakeCountry `shouldBe` ("Ecuador", "French Guiana")
it "Non equality of sequence" $ do
let someCountry :: Fake (Text, Text)
someCountry = do
c1 <- country
c2 <- country
pure (c1, c2)
(c1, c2) <- generate someCountry
c1 `shouldNotBe` c2
it "Resolver based function" $ do
bno <- generate buildingNumber
bno `shouldBe` "153"
it "Resolver fullAddress" $ do
bno <- generate fullAddress
bno `shouldSatisfy` (\x -> T.length x > 25)
it "Resolver based function - monad" $ do
let someBuilding :: Fake (Text, Text)
someBuilding = do
c1 <- buildingNumber
c2 <- buildingNumber
pure (c1, c2)
(c1, c2) <- generate someBuilding
c1 `shouldNotBe` c2
describe "Empty data sources" $ do
-- it "For ee locale, countries is empty" $ do
-- ctries <- countryProvider (setLocale "ee" defaultFakerSettings)
-- ctries `shouldSatisfy` (\x -> V.length x == 0)
it "For ee locale, throws exception" $ do
let action =
generateWithSettings (setLocale "ee" defaultFakerSettings) country
action `shouldThrow` fakerException