graphql-engine/server/src-test/Hasura/Server/InitSpec.hs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1444 lines
59 KiB
Haskell
Raw Normal View History

{-# LANGUAGE TemplateHaskell #-}
module Hasura.Server.InitSpec
( spec,
)
where
--------------------------------------------------------------------------------
import Data.HashSet qualified as Set
import Data.Monoid (All (..))
import Data.Time (NominalDiffTime)
import Database.PG.Query qualified as Query
import Hasura.GraphQL.Execute.Subscription.Options qualified as Subscription.Options
import Hasura.GraphQL.Schema.NamingCase qualified as NamingCase
import Hasura.GraphQL.Schema.Options qualified as Options
import Hasura.Logging (Hasura)
import Hasura.Logging qualified as Logging
import Hasura.Prelude
import Hasura.SQL.Types qualified as MonadTx
import Hasura.Server.Auth qualified as Auth
import Hasura.Server.Cors qualified as Cors
import Hasura.Server.Init qualified as UUT
import Hasura.Server.Logging qualified as Logging
import Hasura.Server.Types qualified as Types
import Hasura.Session qualified as UUT
import Network.WebSockets qualified as WS
import Refined (NonNegative, Positive, refineTH, unrefine)
import Test.Hspec qualified as Hspec
{-# ANN module ("HLint: ignore Redundant ==" :: String) #-}
--------------------------------------------------------------------------------
spec :: Hspec.Spec
spec = Hspec.describe "Init Tests" $ do
mkServeOptionsSpec
--------------------------------------------------------------------------------
emptyServeOptionsRaw :: UUT.ServeOptionsRaw Hasura
emptyServeOptionsRaw =
UUT.ServeOptionsRaw
{ rsoPort = Nothing,
rsoHost = Nothing,
rsoConnParams =
UUT.ConnParamsRaw
{ rcpStripes = Nothing,
rcpConns = Nothing,
rcpIdleTime = Nothing,
rcpConnLifetime = Nothing,
rcpAllowPrepare = Nothing,
rcpPoolTimeout = Nothing
},
rsoTxIso = Nothing,
rsoAdminSecret = Nothing,
rsoAuthHook = UUT.AuthHookRaw Nothing Nothing,
rsoJwtSecret = Nothing,
rsoUnAuthRole = Nothing,
rsoCorsConfig = Nothing,
rsoEnableConsole = False,
rsoConsoleAssetsDir = Nothing,
rsoConsoleSentryDsn = Nothing,
rsoEnableTelemetry = Nothing,
rsoWsReadCookie = False,
rsoStringifyNum = Options.Don'tStringifyNumbers,
rsoDangerousBooleanCollapse = Nothing,
rsoEnabledAPIs = Nothing,
rsoMxRefetchInt = Nothing,
rsoMxBatchSize = Nothing,
rsoStreamingMxRefetchInt = Nothing,
rsoStreamingMxBatchSize = Nothing,
rsoEnableAllowlist = False,
rsoEnabledLogTypes = Nothing,
rsoLogLevel = Nothing,
rsoDevMode = False,
rsoAdminInternalErrors = Nothing,
rsoEventsHttpPoolSize = Nothing,
rsoEventsFetchInterval = Nothing,
rsoAsyncActionsFetchInterval = Nothing,
rsoEnableRemoteSchemaPermissions = Options.DisableRemoteSchemaPermissions,
rsoWebSocketCompression = False,
rsoWebSocketKeepAlive = Nothing,
rsoInferFunctionPermissions = Nothing,
rsoEnableMaintenanceMode = Types.MaintenanceModeDisabled,
rsoSchemaPollInterval = Nothing,
rsoExperimentalFeatures = Nothing,
rsoEventsFetchBatchSize = Nothing,
rsoGracefulShutdownTimeout = Nothing,
rsoWebSocketConnectionInitTimeout = Nothing,
rsoEnableMetadataQueryLoggingEnv = Logging.MetadataQueryLoggingDisabled,
rsoDefaultNamingConvention = Nothing,
rsoExtensionsSchema = Nothing,
rsoMetadataDefaults = Nothing
}
mkServeOptionsSpec :: Hspec.Spec
mkServeOptionsSpec =
Hspec.describe "mkServeOptions" $ do
Hspec.describe "soPort" $ do
Hspec.it "Default == 8080" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soPort result `Hspec.shouldBe` Right (UUT._default UUT.servePortOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.servePortOption, "420")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soPort result `Hspec.shouldBe` Right (UUT.unsafePort 420)
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoPort = Just (UUT.unsafePort 11)}
-- When
env = [(UUT._envVar UUT.servePortOption, "420")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soPort result `Hspec.shouldBe` Right (UUT.unsafePort 11)
Hspec.describe "soHost" $ do
Hspec.it "Default = '*'" $ do
-- Given
let rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soHost result `Hspec.shouldBe` Right (UUT._default UUT.serveHostOption)
Hspec.it "Env > Nothing" $ do
-- Given
let rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.serveHostOption, "127.0.0.1")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soHost result `Hspec.shouldBe` Right "127.0.0.1"
Hspec.it "Arg > Env" $ do
-- Given
let rawServeOptions = emptyServeOptionsRaw {UUT.rsoHost = Just "*4"}
-- When
env = [(UUT._envVar UUT.serveHostOption, "127.0.0.1")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soHost result `Hspec.shouldBe` Right "*4"
Hspec.describe "soConnParams" $ do
Hspec.it "Default == 1, 50, 180, 600" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soConnParams result
`Hspec.shouldBe` Right
( Query.ConnParams
{ Query.cpStripes = unrefine $ UUT._default UUT.pgStripesOption,
Query.cpConns = unrefine $ UUT._default UUT.pgConnsOption,
Query.cpIdleTime = unrefine $ UUT._default UUT.pgTimeoutOption,
Query.cpAllowPrepare = UUT._default UUT.pgUsePreparedStatementsOption,
Query.cpMbLifetime = Just $ unrefine $ UUT._default UUT.pgConnLifetimeOption,
Query.cpTimeout = Nothing,
Query.cpCancel = True
}
)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env =
[ (UUT._envVar UUT.pgStripesOption, "42"),
(UUT._envVar UUT.pgConnsOption, "43"),
(UUT._envVar UUT.pgTimeoutOption, "44"),
(UUT._envVar UUT.pgConnLifetimeOption, "45"),
(UUT._envVar UUT.pgUsePreparedStatementsOption, "false"),
(UUT._envVar UUT.pgPoolTimeoutOption, "46")
]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soConnParams result
`Hspec.shouldBe` Right
( Query.ConnParams
{ Query.cpStripes = 42,
Query.cpConns = 43,
Query.cpIdleTime = 44,
Query.cpAllowPrepare = False,
Query.cpMbLifetime = Just 45,
Query.cpTimeout = Just 46,
Query.cpCancel = True
}
)
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions =
emptyServeOptionsRaw
{ UUT.rsoConnParams =
UUT.ConnParamsRaw
{ rcpStripes = Just $$(refineTH @NonNegative @Int 2),
rcpConns = Just $$(refineTH @NonNegative @Int 3),
rcpIdleTime = Just $$(refineTH @NonNegative @Int 4),
rcpConnLifetime = Just $$(refineTH @NonNegative @NominalDiffTime 5),
rcpAllowPrepare = Just True,
rcpPoolTimeout = Just $$(refineTH @NonNegative @NominalDiffTime 6)
}
}
-- When
env =
[ (UUT._envVar UUT.pgStripesOption, "42"),
(UUT._envVar UUT.pgConnsOption, "43"),
(UUT._envVar UUT.pgTimeoutOption, "44"),
(UUT._envVar UUT.pgConnLifetimeOption, "45"),
(UUT._envVar UUT.pgUsePreparedStatementsOption, "false"),
(UUT._envVar UUT.pgPoolTimeoutOption, "46")
]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soConnParams result
`Hspec.shouldBe` Right
( Query.ConnParams
{ cpStripes = 2,
cpConns = 3,
cpIdleTime = 4,
cpAllowPrepare = True,
cpMbLifetime = Just 5,
cpTimeout = Just 6,
cpCancel = True
}
)
Hspec.describe "soTxIso" $ do
Hspec.it "Default == ReadCommitted" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soTxIso result `Hspec.shouldBe` Right (UUT._default UUT.txIsolationOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.txIsolationOption, "repeatable-read")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soTxIso result `Hspec.shouldBe` Right Query.RepeatableRead
Hspec.it "Arg > Env" $ do
-- Given
let rawServeOptions = emptyServeOptionsRaw {UUT.rsoTxIso = Just Query.Serializable}
-- When
env = [(UUT._envVar UUT.txIsolationOption, "repeatable-read")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soTxIso result `Hspec.shouldBe` Right Query.Serializable
Hspec.describe "soAdminSecret" $ do
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.adminSecretOption, "A monad is a monoid in the category of endofunctors")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soAdminSecret result `Hspec.shouldBe` Right (Set.singleton (Auth.hashAdminSecret "A monad is a monoid in the category of endofunctors"))
Hspec.it "Arg > Env" $ do
-- Given
let rawServeOptions = emptyServeOptionsRaw {UUT.rsoAdminSecret = Just (Auth.hashAdminSecret "Whats the big deal")}
-- When
env = [(UUT._envVar UUT.adminSecretOption, "A monad is a monoid in the category of endofunctors")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soAdminSecret result `Hspec.shouldBe` Right (Set.singleton (Auth.hashAdminSecret "Whats the big deal"))
Hspec.describe "soAuthHook" $ do
Hspec.it "Default Hook Mode == GET" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.authHookOption, "http://auth.hook.com")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soAuthHook result `Hspec.shouldBe` Right (Just (Auth.AuthHook "http://auth.hook.com" Auth.AHTGet))
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env =
[ (UUT._envVar UUT.authHookOption, "http://auth.hook.com"),
(UUT._envVar UUT.authHookModeOption, "POST")
]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soAuthHook result `Hspec.shouldBe` Right (Just (Auth.AuthHook "http://auth.hook.com" Auth.AHTPost))
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoAuthHook = UUT.AuthHookRaw (Just "http://auth.hook.com") (Just Auth.AHTGet)}
-- When
env =
[ (UUT._envVar UUT.authHookOption, "http://auth.hook.com"),
(UUT._envVar UUT.authHookModeOption, "POST")
]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soAuthHook result `Hspec.shouldBe` Right (Just (Auth.AuthHook "http://auth.hook.com" Auth.AHTGet))
Hspec.describe "soJwtSecret" $ do
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env =
[ ( UUT._envVar UUT.jwtSecretOption,
"{\"type\": \"HS256\", \"key\": \"11111111111111111111111111111111\", \"claims_namespace\": \"<optional-custom-claims-key-name>\"}"
)
]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soJwtSecret result
`Hspec.shouldBe` UUT.fromEnv "[{\"type\": \"HS256\", \"key\": \"11111111111111111111111111111111\", \"claims_namespace\": \"<optional-custom-claims-key-name>\"}]"
Hspec.it "Arg > Env" $ do
let -- Given
jwtConfig = eitherToMaybe $ UUT.fromEnv @Auth.JWTConfig "{\"type\": \"HS256\", \"key\": \"22222222222222222222222222222222\", \"claims_namespace\": \"<optional-custom-claims-key-name>\"}"
rawServeOptions = emptyServeOptionsRaw {UUT.rsoJwtSecret = jwtConfig}
-- When
env =
[ ( UUT._envVar UUT.jwtSecretOption,
"{\"type\": \"HS256\", \"key\": \"11111111111111111111111111111111\", \"claims_namespace\": \"<optional-custom-claims-key-name>\"}"
)
]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soJwtSecret result `Hspec.shouldBe` Right (onNothing jwtConfig [])
Hspec.describe "soUnAuthRole" $ do
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.unAuthRoleOption, "guest")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soUnAuthRole result `Hspec.shouldBe` Right (UUT.mkRoleName "guest")
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoUnAuthRole = UUT.mkRoleName "visitor"}
-- When
env = [(UUT._envVar UUT.unAuthRoleOption, "guest")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soUnAuthRole result `Hspec.shouldBe` Right (UUT.mkRoleName "visitor")
Hspec.describe "soCorsConfig" $ do
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.corsDomainOption, "http://domain1:23, http://domain2:34")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soCorsConfig result `Hspec.shouldBe` Cors.readCorsDomains "http://domain1:23, http://domain2:34"
Hspec.it "Default CorsConfig == CCAllowAll" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soCorsConfig result `Hspec.shouldBe` Right (UUT._default UUT.corsDomainOption)
Hspec.it "Env 'HASURA_GRAPHQL_DISABLE_CORS=false' superseded by 'HASURA_GRAPHQL_CORS_DOMAIN'" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.corsDomainOption, "http://domain1:23, http://domain2:34"), (UUT._envVar UUT.disableCorsOption, "false")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soCorsConfig result `Hspec.shouldBe` Cors.readCorsDomains "http://domain1:23, http://domain2:34"
Hspec.it "Env 'HASURA_GRAPHQL_DISABLE_CORS=true' enables use of cookie value" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.wsReadCookieOption, "true"), (UUT._envVar UUT.disableCorsOption, "true")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soCorsConfig result `Hspec.shouldBe` Right (Cors.CCDisabled True)
Hspec.it "Env 'HASURA_GRAPHQL_DISABLE_CORS=true' supersedes 'HASURA_GRAPHQL_CORS_DOMAIN'" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.corsDomainOption, "http://domain1:23, http://domain2:34"), (UUT._envVar UUT.disableCorsOption, "true")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soCorsConfig result `Hspec.shouldBe` Right (Cors.CCDisabled False)
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoCorsConfig = eitherToMaybe (Cors.readCorsDomains "http://domain1:23, http://domain2:34")}
-- When
env = [(UUT._envVar UUT.corsDomainOption, "http://domain1:23, http://domain2:34")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soCorsConfig result `Hspec.shouldBe` Cors.readCorsDomains "http://domain1:23, http://domain2:34"
Hspec.describe "soEnableConsole" $ do
Hspec.it "Default == False" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnableConsole result `Hspec.shouldBe` Right (UUT._default UUT.enableConsoleOption)
-- NOTE: This is a little confusing. We are first simulating
-- not providing the '--enable-console' flag with the env var set to 'true'.
-- Next we simulate providing the '--enable-console' flag and
-- the env var to ensure the flag supersedes the env var.
Hspec.it "Env > No Switch" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.enableConsoleOption, "true")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnableConsole result `Hspec.shouldBe` Right True
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoEnableConsole = True}
-- When
env = [(UUT._envVar UUT.enableConsoleOption, "false")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnableConsole result `Hspec.shouldBe` Right True
Hspec.describe "soConsoleAssetsDir" $ do
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.consoleAssetsDirOption, "/assets")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soConsoleAssetsDir result `Hspec.shouldBe` Right (Just "/assets")
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoConsoleAssetsDir = Just "/data"}
-- When
env = [("HASURA_GRAPHQL_CONSOLE_ASSETS_DIR", "/assets")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soConsoleAssetsDir result `Hspec.shouldBe` Right (Just "/data")
Hspec.describe "soConsoleSentryDsn" $ do
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.consoleSentryDsnOption, "123123")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soConsoleSentryDsn result `Hspec.shouldBe` Right (Just "123123")
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoConsoleSentryDsn = Just "456456"}
-- When
env = [("HASURA_CONSOLE_SENTRY_DSN", "123123")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soConsoleSentryDsn result `Hspec.shouldBe` Right (Just "456456")
Hspec.describe "soEnableTelemetry" $ do
Hspec.it "Default == True" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnableTelemetry result `Hspec.shouldBe` Right (UUT._default UUT.enableTelemetryOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.enableTelemetryOption, "false")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnableTelemetry result `Hspec.shouldBe` Right False
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoEnableTelemetry = Just False}
-- When
env = [(UUT._envVar UUT.enableTelemetryOption, "true")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnableTelemetry result `Hspec.shouldBe` Right False
Hspec.describe "soStringifyNum" $ do
Hspec.it "Default == Don'tStringifyNumbers" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soStringifyNum result `Hspec.shouldBe` Right (UUT._default UUT.stringifyNumOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.stringifyNumOption, "true")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soStringifyNum result `Hspec.shouldBe` Right Options.StringifyNumbers
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoStringifyNum = Options.StringifyNumbers}
-- When
env = [(UUT._envVar UUT.stringifyNumOption, "false")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soStringifyNum result `Hspec.shouldBe` Right Options.StringifyNumbers
Hspec.describe "soDangerousBooleanCollapse" $ do
Hspec.it "Default == False" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soDangerousBooleanCollapse result `Hspec.shouldBe` Right (UUT._default UUT.dangerousBooleanCollapseOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.dangerousBooleanCollapseOption, "true")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soDangerousBooleanCollapse result `Hspec.shouldBe` Right Options.DangerouslyCollapseBooleans
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoDangerousBooleanCollapse = Just Options.Don'tDangerouslyCollapseBooleans}
-- When
env = [(UUT._envVar UUT.dangerousBooleanCollapseOption, "true")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soDangerousBooleanCollapse result `Hspec.shouldBe` Right Options.Don'tDangerouslyCollapseBooleans
Hspec.describe "soEnabledAPIs" $ do
Hspec.it "Default == metadata,graphql,pgdump,config" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnabledAPIs result `Hspec.shouldBe` Right (UUT._default UUT.enabledAPIsOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.enabledAPIsOption, "metadata,graphql")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnabledAPIs result `Hspec.shouldBe` Right (Set.fromList [UUT.METADATA, UUT.GRAPHQL])
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoEnabledAPIs = Just $ Set.fromList [UUT.CONFIG]}
-- When
env = [(UUT._envVar UUT.enabledAPIsOption, "metadata,graphql")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnabledAPIs result `Hspec.shouldBe` Right (Set.fromList [UUT.CONFIG])
Hspec.describe "soLiveQueryOpts" $ do
Hspec.it "Default == 1000, 100" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soLiveQueryOpts result
`Hspec.shouldBe` Right
( Subscription.Options.SubscriptionsOptions
{ _lqoRefetchInterval = UUT._default UUT.mxRefetchDelayOption,
_lqoBatchSize = UUT._default UUT.mxBatchSizeOption
}
)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env =
[ (UUT._envVar UUT.mxRefetchDelayOption, "2000"),
(UUT._envVar UUT.mxBatchSizeOption, "200")
]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soLiveQueryOpts result
`Hspec.shouldBe` Right
( Subscription.Options.SubscriptionsOptions
{ _lqoRefetchInterval = Subscription.Options.RefetchInterval $$(refineTH 2),
_lqoBatchSize = Subscription.Options.BatchSize $$(refineTH 200)
}
)
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions =
emptyServeOptionsRaw
{ UUT.rsoMxRefetchInt = Subscription.Options.mkRefetchInterval 3,
UUT.rsoMxBatchSize = Subscription.Options.mkBatchSize 300
}
-- When
env =
[ (UUT._envVar UUT.mxRefetchDelayOption, "2000"),
(UUT._envVar UUT.mxBatchSizeOption, "200")
]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soLiveQueryOpts result
`Hspec.shouldBe` Right
( Subscription.Options.SubscriptionsOptions
{ _lqoRefetchInterval = Subscription.Options.RefetchInterval $$(refineTH 3),
_lqoBatchSize = Subscription.Options.BatchSize $$(refineTH 300)
}
)
Hspec.describe "soStreamingQueryOpts" $ do
Hspec.it "Default == 1000, 100" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soStreamingQueryOpts result
`Hspec.shouldBe` Right
( Subscription.Options.SubscriptionsOptions
{ _lqoRefetchInterval = UUT._default UUT.streamingMxRefetchDelayOption,
_lqoBatchSize = UUT._default UUT.streamingMxBatchSizeOption
}
)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env =
[ (UUT._envVar UUT.streamingMxRefetchDelayOption, "2000"),
(UUT._envVar UUT.streamingMxBatchSizeOption, "200")
]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soStreamingQueryOpts result
`Hspec.shouldBe` Right
( Subscription.Options.SubscriptionsOptions
{ _lqoRefetchInterval = Subscription.Options.RefetchInterval $$(refineTH 2),
_lqoBatchSize = Subscription.Options.BatchSize $$(refineTH 200)
}
)
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions =
emptyServeOptionsRaw
{ UUT.rsoStreamingMxRefetchInt = Subscription.Options.mkRefetchInterval 3,
UUT.rsoStreamingMxBatchSize = Subscription.Options.mkBatchSize 300
}
-- When
env =
[ (UUT._envVar UUT.streamingMxRefetchDelayOption, "2000"),
(UUT._envVar UUT.streamingMxBatchSizeOption, "200")
]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soStreamingQueryOpts result
`Hspec.shouldBe` Right
( Subscription.Options.SubscriptionsOptions
{ _lqoRefetchInterval = Subscription.Options.RefetchInterval $$(refineTH 3),
_lqoBatchSize = Subscription.Options.BatchSize $$(refineTH 300)
}
)
Hspec.describe "soEnableAllowlist" $ do
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.enableAllowlistOption, "true")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnableAllowlist result `Hspec.shouldBe` Right True
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoEnableAllowlist = True}
-- When
env = [(UUT._envVar UUT.enableAllowlistOption, "false")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnableAllowlist result `Hspec.shouldBe` Right True
Hspec.describe "soEnabledLogTypes" $ do
Hspec.it "Default == Startup, HttpLog, WebhookLog, WebsocketLog" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnabledLogTypes result `Hspec.shouldBe` Right (UUT._default UUT.enabledLogsOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar (UUT.enabledLogsOption @Hasura), "http-log")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnabledLogTypes result `Hspec.shouldBe` Right (Set.fromList [Logging.ELTHttpLog])
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoEnabledLogTypes = Just (Set.fromList [Logging.ELTActionHandler])}
-- When
env = [(UUT._envVar (UUT.enabledLogsOption @Hasura), "http-log")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnabledLogTypes result `Hspec.shouldBe` Right (Set.fromList [Logging.ELTActionHandler])
Hspec.describe "soLogLevel" $ do
Hspec.it "Default == LevelInfo" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soLogLevel result `Hspec.shouldBe` Right (UUT._default UUT.logLevelOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.logLevelOption, "warn")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soLogLevel result `Hspec.shouldBe` Right Logging.LevelWarn
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoLogLevel = Just Logging.LevelWarn}
-- When
env = [(UUT._envVar UUT.logLevelOption, "warn")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soLogLevel result `Hspec.shouldBe` Right Logging.LevelWarn
Hspec.describe "soDevMode" $ do
Hspec.it "Default == False" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soDevMode &&& UUT.soResponseInternalErrorsConfig) result `Hspec.shouldSatisfy` \case
Right (soDevMode, soResponseInternalErrorsConfig) ->
getAll $ foldMap All [soDevMode == UUT._default UUT.graphqlDevModeOption, soResponseInternalErrorsConfig == UUT.InternalErrorsAdminOnly]
Left _err -> False
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.graphqlDevModeOption, "true")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soDevMode &&& UUT.soResponseInternalErrorsConfig) result `Hspec.shouldSatisfy` \case
Right (soDevMode, soResponseInternalErrorsConfig) ->
getAll $ foldMap All [soDevMode == True, soResponseInternalErrorsConfig == UUT.InternalErrorsAllRequests]
Left _err -> False
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoDevMode = True}
-- When
env = [(UUT._envVar UUT.graphqlDevModeOption, "false")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soDevMode result `Hspec.shouldBe` Right True
Hspec.describe "soAdminInternalErrors" $ do
Hspec.it "Default == InternalErrorsAdminOnly" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soResponseInternalErrorsConfig result `Hspec.shouldBe` Right UUT.InternalErrorsAdminOnly
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.graphqlAdminInternalErrorsOption, "false")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soResponseInternalErrorsConfig result `Hspec.shouldBe` Right UUT.InternalErrorsDisabled
Hspec.it "Dev Mode supersedes rsoAdminInternalErrors" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.graphqlAdminInternalErrorsOption, "false"), (UUT._envVar UUT.graphqlDevModeOption, "true")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soResponseInternalErrorsConfig result `Hspec.shouldBe` Right UUT.InternalErrorsAllRequests
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoAdminInternalErrors = Just False}
-- When
env = [(UUT._envVar UUT.graphqlAdminInternalErrorsOption, "true")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soResponseInternalErrorsConfig result `Hspec.shouldBe` Right UUT.InternalErrorsDisabled
Hspec.describe "soEventsHttpPoolSize" $ do
Hspec.it "Default == 100" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Logging.Hasura rawServeOptions)
fmap UUT.soEventsHttpPoolSize result `Hspec.shouldBe` Right (UUT._default UUT.graphqlEventsHttpPoolSizeOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.graphqlEventsHttpPoolSizeOption, "200")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEventsHttpPoolSize result `Hspec.shouldBe` Right $$(refineTH @Positive @Int 200)
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoEventsHttpPoolSize = Just $$(refineTH @Positive @Int 300)}
-- When
env = [(UUT._envVar UUT.graphqlEventsHttpPoolSizeOption, "200")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEventsHttpPoolSize result `Hspec.shouldBe` Right $$(refineTH @Positive @Int 300)
Hspec.describe "soEventsFetchInterval" $ do
Hspec.it "Default == 1" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEventsFetchInterval result `Hspec.shouldBe` Right (UUT._default UUT.graphqlEventsFetchIntervalOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.graphqlEventsFetchIntervalOption, "200")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEventsFetchInterval result `Hspec.shouldBe` Right $$(refineTH @NonNegative @Milliseconds 200)
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoEventsFetchInterval = Just $$(refineTH @NonNegative @Milliseconds 300)}
-- When
env = [(UUT._envVar UUT.graphqlEventsFetchIntervalOption, "200")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEventsFetchInterval result `Hspec.shouldBe` Right $$(refineTH @NonNegative @Milliseconds 300)
Hspec.describe "soAsyncActionsFetchInterval" $ do
Hspec.it "Default == 1000" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soAsyncActionsFetchInterval result `Hspec.shouldBe` Right (UUT._default UUT.asyncActionsFetchIntervalOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.asyncActionsFetchIntervalOption, "200")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soAsyncActionsFetchInterval result `Hspec.shouldBe` Right (UUT.Interval $$(refineTH 200))
Hspec.it "0 == 'Skip'" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.asyncActionsFetchIntervalOption, "0")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soAsyncActionsFetchInterval result `Hspec.shouldBe` Right UUT.Skip
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoAsyncActionsFetchInterval = Just (UUT.Interval $$(refineTH 300))}
-- When
env = [(UUT._envVar UUT.asyncActionsFetchIntervalOption, "200")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soAsyncActionsFetchInterval result `Hspec.shouldBe` Right (UUT.Interval $$(refineTH 300))
Hspec.describe "soEnableRemoteSchemaPermissions" $ do
Hspec.it "Default == False" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnableRemoteSchemaPermissions result `Hspec.shouldBe` Right (UUT._default UUT.enableRemoteSchemaPermsOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.enableRemoteSchemaPermsOption, "true")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnableRemoteSchemaPermissions result `Hspec.shouldBe` Right Options.EnableRemoteSchemaPermissions
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoEnableRemoteSchemaPermissions = Options.EnableRemoteSchemaPermissions}
-- When
env = [(UUT._envVar UUT.enableRemoteSchemaPermsOption, "false")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soEnableRemoteSchemaPermissions result `Hspec.shouldBe` Right Options.EnableRemoteSchemaPermissions
Hspec.describe "soWebSocketCompression" $ do
Hspec.it "Default == NoCompression" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (WS.connectionCompressionOptions . UUT.soConnectionOptions) result `Hspec.shouldBe` Right WS.NoCompression
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.webSocketCompressionOption, "true")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (WS.connectionCompressionOptions . UUT.soConnectionOptions) result
`Hspec.shouldBe` Right (WS.PermessageDeflateCompression WS.defaultPermessageDeflate)
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoWebSocketCompression = True}
-- When
env = [(UUT._envVar UUT.webSocketCompressionOption, "false")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (WS.connectionCompressionOptions . UUT.soConnectionOptions) result
`Hspec.shouldBe` Right (WS.PermessageDeflateCompression WS.defaultPermessageDeflate)
Hspec.describe "soWebSocketKeepAlive" $ do
Hspec.it "Default == 5" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soWebSocketKeepAlive) result `Hspec.shouldBe` Right (UUT._default UUT.webSocketKeepAliveOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.webSocketKeepAliveOption, "10")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soWebSocketKeepAlive) result `Hspec.shouldBe` Right (UUT.KeepAliveDelay $$(refineTH 10))
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoWebSocketKeepAlive = Just (UUT.KeepAliveDelay $$(refineTH 20))}
-- When
env = [(UUT._envVar UUT.webSocketKeepAliveOption, "10")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soWebSocketKeepAlive) result `Hspec.shouldBe` Right (UUT.KeepAliveDelay $$(refineTH 20))
Hspec.describe "soInferFunctionPermissions" $ do
Hspec.it "Default == FunctionPermissionsInferred" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soInferFunctionPermissions) result `Hspec.shouldBe` Right (UUT._default UUT.inferFunctionPermsOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.inferFunctionPermsOption, "false")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soInferFunctionPermissions) result `Hspec.shouldBe` Right Options.Don'tInferFunctionPermissions
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoInferFunctionPermissions = Just Options.InferFunctionPermissions}
-- When
env = [(UUT._envVar UUT.inferFunctionPermsOption, "false")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soInferFunctionPermissions) result `Hspec.shouldBe` Right Options.InferFunctionPermissions
Hspec.describe "soEnableMaintenanceMode" $ do
Hspec.it "Defaut == MaintenanceModeDisabled" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soEnableMaintenanceMode) result `Hspec.shouldBe` Right (UUT._default UUT.enableMaintenanceModeOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.enableMaintenanceModeOption, "true")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soEnableMaintenanceMode) result `Hspec.shouldBe` Right (Types.MaintenanceModeEnabled ())
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoEnableMaintenanceMode = Types.MaintenanceModeEnabled ()}
-- When
env = [(UUT._envVar UUT.enableMaintenanceModeOption, "false")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soEnableMaintenanceMode) result `Hspec.shouldBe` Right (Types.MaintenanceModeEnabled ())
Hspec.describe "soSchemaPollInterval" $ do
Hspec.it "Default == 1000" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soSchemaPollInterval) result `Hspec.shouldBe` Right (UUT._default UUT.schemaPollIntervalOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.schemaPollIntervalOption, "2000")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soSchemaPollInterval) result `Hspec.shouldBe` Right (UUT.Interval $$(refineTH 2000))
Hspec.it "0 == Skip" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.schemaPollIntervalOption, "0")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soSchemaPollInterval) result `Hspec.shouldBe` Right UUT.Skip
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoSchemaPollInterval = Just (UUT.Interval $$(refineTH 3000))}
-- When
env = [(UUT._envVar UUT.schemaPollIntervalOption, "2000")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soSchemaPollInterval) result `Hspec.shouldBe` Right (UUT.Interval $$(refineTH 3000))
Hspec.describe "soExperimentalFeatures" $ do
Hspec.it "Default == mempty" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soExperimentalFeatures) result `Hspec.shouldBe` Right (UUT._default UUT.experimentalFeaturesOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
-- When
env = [(UUT._envVar UUT.experimentalFeaturesOption, "inherited_roles,optimize_permission_filters,naming_convention")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soExperimentalFeatures) result
`Hspec.shouldBe` Right (Set.fromList [Types.EFInheritedRoles, Types.EFOptimizePermissionFilters, Types.EFNamingConventions])
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoExperimentalFeatures = Just (Set.fromList [Types.EFInheritedRoles, Types.EFOptimizePermissionFilters, Types.EFNamingConventions])}
-- When
env = [(UUT._envVar UUT.experimentalFeaturesOption, "inherited_roles")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soExperimentalFeatures) result
`Hspec.shouldBe` Right (Set.fromList [Types.EFInheritedRoles, Types.EFOptimizePermissionFilters, Types.EFNamingConventions])
Hspec.describe "soEventsFetchBatchSize" $ do
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.eventsFetchBatchSizeOption, "200")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soEventsFetchBatchSize) result `Hspec.shouldBe` Right $$(refineTH @NonNegative @Int 200)
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoEventsFetchBatchSize = Just $$(refineTH @NonNegative @Int 300)}
-- When
env = [(UUT._envVar UUT.eventsFetchBatchSizeOption, "200")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soEventsFetchBatchSize) result `Hspec.shouldBe` Right $$(refineTH @NonNegative @Int 300)
Hspec.describe "soGracefulShutdownTimeout" $ do
Hspec.it "Default == 60" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soGracefulShutdownTimeout) result `Hspec.shouldBe` Right (UUT._default UUT.gracefulShutdownOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
-- When
env = [(UUT._envVar UUT.gracefulShutdownOption, "200")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soGracefulShutdownTimeout) result `Hspec.shouldBe` Right $$(refineTH @NonNegative @Seconds 200)
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoGracefulShutdownTimeout = Just $$(refineTH @NonNegative @Seconds 300)}
-- When
env = [(UUT._envVar UUT.gracefulShutdownOption, "200")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soGracefulShutdownTimeout) result `Hspec.shouldBe` Right $$(refineTH @NonNegative @Seconds 300)
Hspec.describe "soWebSocketConnectionInitTimeout" $ do
Hspec.it "Default == 3" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soWebSocketConnectionInitTimeout) result `Hspec.shouldBe` Right (UUT._default UUT.webSocketConnectionInitTimeoutOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
env = [(UUT._envVar UUT.webSocketConnectionInitTimeoutOption, "200")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soWebSocketConnectionInitTimeout) result `Hspec.shouldBe` Right (UUT.WSConnectionInitTimeout $$(refineTH @NonNegative @Seconds 200))
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions =
emptyServeOptionsRaw
{ UUT.rsoWebSocketConnectionInitTimeout = Just (UUT.WSConnectionInitTimeout $$(refineTH @NonNegative @Seconds 300))
}
-- When
env = [(UUT._envVar UUT.webSocketConnectionInitTimeoutOption, "200")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soWebSocketConnectionInitTimeout) result `Hspec.shouldBe` Right (UUT.WSConnectionInitTimeout $$(refineTH @NonNegative @Seconds 300))
Hspec.describe "soEnableMetadataQueryLoggingEnv" $ do
Hspec.it "Default == MetadataQueryLoggingDisabled" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soEnableMetadataQueryLogging) result `Hspec.shouldBe` Right (UUT._default UUT.enableMetadataQueryLoggingOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
-- When
env = [(UUT._envVar UUT.enableMetadataQueryLoggingOption, "true")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soEnableMetadataQueryLogging) result `Hspec.shouldBe` Right Logging.MetadataQueryLoggingEnabled
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoEnableMetadataQueryLoggingEnv = Logging.MetadataQueryLoggingEnabled}
-- When
env = [(UUT._envVar UUT.enableMetadataQueryLoggingOption, "false")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soEnableMetadataQueryLogging) result `Hspec.shouldBe` Right Logging.MetadataQueryLoggingEnabled
Hspec.describe "soDefaultNamingConvention" $ do
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
-- When
env = [(UUT._envVar UUT.defaultNamingConventionOption, "graphql-default")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soDefaultNamingConvention) result `Hspec.shouldBe` Right (Just NamingCase.GraphqlCase)
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoDefaultNamingConvention = Just NamingCase.GraphqlCase}
-- When
env = [(UUT._envVar UUT.defaultNamingConventionOption, "hasura-default")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap (UUT.soDefaultNamingConvention) result `Hspec.shouldBe` Right (Just NamingCase.GraphqlCase)
Hspec.describe "soExtensionsSchema" $ do
Hspec.it "Default == 'public' " $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
-- When
env = []
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soExtensionsSchema result `Hspec.shouldBe` Right (UUT._default UUT.metadataDBExtensionsSchemaOption)
Hspec.it "Env > Nothing" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw
-- When
-- When
env = [(UUT._envVar UUT.metadataDBExtensionsSchemaOption, "private")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soExtensionsSchema result `Hspec.shouldBe` Right (MonadTx.ExtensionsSchema "private")
Hspec.it "Arg > Env" $ do
let -- Given
rawServeOptions = emptyServeOptionsRaw {UUT.rsoExtensionsSchema = Just (MonadTx.ExtensionsSchema "other")}
-- When
env = [(UUT._envVar UUT.metadataDBExtensionsSchemaOption, "private")]
-- Then
result = UUT.runWithEnv env (UUT.mkServeOptions @Hasura rawServeOptions)
fmap UUT.soExtensionsSchema result `Hspec.shouldBe` Right (MonadTx.ExtensionsSchema "other")