graphql-engine/server/tests-hspec/Harness/Constants.hs

278 lines
7.7 KiB
Haskell
Raw Normal View History

{-# LANGUAGE DisambiguateRecordFields #-}
-- | Constant configurations used throughout the test suite.
module Harness.Constants
( postgresPassword,
postgresUser,
postgresDb,
postgresHost,
postgresPort,
postgresqlConnectionString,
postgresLivenessCheckAttempts,
postgresLivenessCheckIntervalSeconds,
postgresLivenessCheckIntervalMicroseconds,
mysqlLivenessCheckAttempts,
mysqlLivenessCheckIntervalSeconds,
mysqlLivenessCheckIntervalMicroseconds,
mysqlPassword,
mysqlUser,
mysqlDb,
mysqlHost,
mysqlPort,
mysqlConnectInfo,
sqlserverLivenessCheckAttempts,
sqlserverLivenessCheckIntervalSeconds,
sqlserverLivenessCheckIntervalMicroseconds,
sqlserverConnectInfo,
sqlserverDb,
bigqueryServiceKeyVar,
bigqueryProjectIdVar,
bigqueryDataset,
httpHealthCheckAttempts,
httpHealthCheckIntervalSeconds,
httpHealthCheckIntervalMicroseconds,
citusConnectionString,
citusDb,
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
serveOptions,
)
where
-------------------------------------------------------------------------------
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
import Data.HashSet qualified as Set
import Data.Word (Word16)
import Database.MySQL.Simple qualified as Mysql
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
import Database.PG.Query qualified as Q
import Hasura.GraphQL.Execute.Subscription.Options qualified as ES
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
import Hasura.Logging qualified as L
import Hasura.Prelude
import Hasura.RQL.Types
( FunctionPermissionsCtx (FunctionPermissionsInferred),
RemoteSchemaPermsCtx (RemoteSchemaPermsDisabled),
)
import Hasura.RQL.Types.Common (StringifyNumbers (..))
import Hasura.Server.Cors (CorsConfig (CCAllowAll))
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
import Hasura.Server.Init
( API (CONFIG, DEVELOPER, GRAPHQL, METADATA),
OptionalInterval (..),
ResponseInternalErrorsConfig (..),
ServeOptions (..),
)
import Hasura.Server.Init qualified as Init
import Hasura.Server.Logging (MetadataQueryLoggingMode (MetadataQueryLoggingDisabled))
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
import Hasura.Server.Types
( EventingMode (EventingEnabled),
MaintenanceMode (MaintenanceModeDisabled),
ReadOnlyMode (ReadOnlyModeDisabled),
)
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
import Network.WebSockets qualified as WS
-------------------------------------------------------------------------------
-- * Postgres
postgresPassword :: String
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
postgresPassword = "hasura"
postgresUser :: String
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
postgresUser = "hasura"
postgresDb :: String
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
postgresDb = "hasura"
postgresHost :: String
postgresHost = "127.0.0.1"
postgresPort :: Word16
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
postgresPort = 65002
postgresqlConnectionString :: String
postgresqlConnectionString =
"postgres://"
++ postgresUser
++ ":"
++ postgresPassword
++ "@"
++ postgresHost
++ ":"
++ show postgresPort
++ "/"
++ postgresDb
-- * Citus
citusPassword :: String
citusPassword = "hasura"
citusUser :: String
citusUser = "hasura"
citusDb :: String
citusDb = "hasura"
citusHost :: String
citusHost = "127.0.0.1"
citusPort :: Word16
citusPort = 65004
citusConnectionString :: String
citusConnectionString =
"postgres://"
++ citusUser
++ ":"
++ citusPassword
++ "@"
++ citusHost
++ ":"
++ show citusPort
++ "/"
++ citusDb
-- * Liveness
postgresLivenessCheckAttempts :: Int
postgresLivenessCheckAttempts = 5
postgresLivenessCheckIntervalSeconds :: Int
postgresLivenessCheckIntervalSeconds = 1
sqlserverLivenessCheckAttempts :: Int
sqlserverLivenessCheckAttempts = 5
sqlserverLivenessCheckIntervalSeconds :: Int
sqlserverLivenessCheckIntervalSeconds = 1
-- | SQL Server has strict password requirements, that's why it's not
-- simply @hasura@ like the others.
sqlserverConnectInfo :: Text
sqlserverConnectInfo = "DRIVER={ODBC Driver 17 for SQL Server};SERVER=127.0.0.1,65003;Uid=hasura;Pwd=Hasura1!;Encrypt=no"
sqlserverDb :: String
sqlserverDb = "hasura"
sqlserverLivenessCheckIntervalMicroseconds :: Int
sqlserverLivenessCheckIntervalMicroseconds = 1000 * 1000 * sqlserverLivenessCheckIntervalSeconds
postgresLivenessCheckIntervalMicroseconds :: Int
postgresLivenessCheckIntervalMicroseconds = 1000 * 1000 * postgresLivenessCheckIntervalSeconds
mysqlLivenessCheckAttempts :: Int
mysqlLivenessCheckAttempts = 5
mysqlLivenessCheckIntervalSeconds :: Int
mysqlLivenessCheckIntervalSeconds = 1
mysqlLivenessCheckIntervalMicroseconds :: Int
mysqlLivenessCheckIntervalMicroseconds = 1000 * 1000 * mysqlLivenessCheckIntervalSeconds
-- * MySQL
mysqlPassword :: String
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
mysqlPassword = "hasura"
mysqlUser :: String
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
mysqlUser = "hasura"
mysqlDb :: String
mysqlDb = "hasura"
mysqlHost :: String
mysqlHost = "127.0.0.1"
mysqlPort :: Word16
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
mysqlPort = 65001
mysqlConnectInfo :: Mysql.ConnectInfo
mysqlConnectInfo =
Mysql.defaultConnectInfo
{ Mysql.connectUser = mysqlUser,
Mysql.connectPassword = mysqlPassword,
Mysql.connectDatabase = mysqlDb,
Mysql.connectHost = mysqlHost,
Mysql.connectPort = mysqlPort
}
bigqueryServiceKeyVar :: String
bigqueryServiceKeyVar = "HASURA_BIGQUERY_SERVICE_KEY"
bigqueryProjectIdVar :: String
bigqueryProjectIdVar = "HASURA_BIGQUERY_PROJECT_ID"
bigqueryDataset :: String
bigqueryDataset = "hasura"
-- * HTTP health checks
httpHealthCheckAttempts :: Int
httpHealthCheckAttempts = 5
httpHealthCheckIntervalSeconds :: Int
httpHealthCheckIntervalSeconds = 1
httpHealthCheckIntervalMicroseconds :: Int
httpHealthCheckIntervalMicroseconds = 1000 * 1000 * httpHealthCheckIntervalSeconds
-- * Server configuration
serveOptions :: ServeOptions L.Hasura
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
serveOptions =
ServeOptions
{ soPort = 12345, -- The server runner will typically be generating
-- a random port, so this isn't particularly
-- important.
soHost = "0.0.0.0",
soConnParams = Q.defaultConnParams,
soTxIso = Q.Serializable,
soAdminSecret = mempty,
soAuthHook = Nothing,
soJwtSecret = mempty,
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
soUnAuthRole = Nothing,
soCorsConfig = CCAllowAll,
soEnableConsole = True,
soConsoleAssetsDir = Nothing,
soEnableTelemetry = False,
soStringifyNum = StringifyNumbers,
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
soDangerousBooleanCollapse = False,
soEnabledAPIs = testSuiteEnabledApis,
soLiveQueryOpts = ES.mkSubscriptionsOptions Nothing Nothing,
soStreamingQueryOpts = ES.mkSubscriptionsOptions Nothing Nothing,
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
soEnableAllowlist = False,
soEnabledLogTypes = Set.fromList L.userAllowedLogTypes,
soLogLevel = fromMaybe (L.LevelOther "test-suite") engineLogLevel,
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
soResponseInternalErrorsConfig = InternalErrorsAllRequests,
soEventsHttpPoolSize = Nothing,
soEventsFetchInterval = Nothing,
soAsyncActionsFetchInterval = Skip,
soLogHeadersFromEnv = False,
soEnableRemoteSchemaPermissions = RemoteSchemaPermsDisabled,
soConnectionOptions = WS.defaultConnectionOptions,
soWebsocketKeepAlive = Init.defaultKeepAliveDelay,
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
soInferFunctionPermissions = FunctionPermissionsInferred,
soEnableMaintenanceMode = MaintenanceModeDisabled,
-- MUST be disabled to be able to modify schema.
soSchemaPollInterval = Interval 10,
soExperimentalFeatures = mempty,
soEventsFetchBatchSize = 1,
soDevMode = True,
soGracefulShutdownTimeout = 0, -- Don't wait to shutdown.
soWebsocketConnectionInitTimeout = Init.defaultWSConnectionInitTimeout,
soEventingMode = EventingEnabled,
soReadOnlyMode = ReadOnlyModeDisabled,
soEnableMetadataQueryLogging = MetadataQueryLoggingDisabled
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
}
-- | What log level should be used by the engine; this is not exported, and
-- only used in 'serveOptions'.
--
-- This should be adjusted locally for debugging purposes; e.g. change it to
-- @Just L.LevelDebug@ to enable all logs.
--
-- See 'L.LogLevel' for an enumeration of available log levels.
engineLogLevel :: Maybe L.LogLevel
engineLogLevel = Nothing
Auto-launch graphql-engine (close hasura/graphql-engine#7801, hasura/graphql-engine#7827 ) Dupe of https://github.com/hasura/graphql-engine-mono/pull/2853 with branch renamed so it doesn't break a tool. prev pr: https://github.com/hasura/graphql-engine-mono/pull/2911 next pr: https://github.com/hasura/graphql-engine-mono/pull/2922 This implements https://github.com/hasura/graphql-engine/issues/7801 Some points to keep in mind for review: * How state is passed to the tests. Do we like how this works? * I quite like it, with the opaque type [`State`](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/State.hs#L17), we can avoid churn when adding things. * The [setup/teardown](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Spec.hs#L19-L31) seems clean. * By using hspec's own means to pass and denote context, we avoid "getting new ideas" for how to structure the tests -- we use a standard. Hopefully, that means the tests' structure rarely change. * The various flags passed in the [ServeOptions](https://github.com/hasura/graphql-engine-mono/blob/68f33051ca6373c42988e78d069eea2a135dc190/server/tests-hspec/Harness/Constants.hs#L123) - if there are any causes for concern, raise them here. My thinking is that, there are lots. I've picked some "sane" defaults (mostly empty). The tests pass. I think as we add more complex tests, these flags will be scrutinised and updated as needed. I think it's valuable that all flags are explicitly listed here, though. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/2921 GitOrigin-RevId: 2c2e70bf784ef571a48509a7e5006fd0f48773b5
2021-11-23 21:15:17 +03:00
-- These are important for the test suite.
testSuiteEnabledApis :: HashSet API
testSuiteEnabledApis = Set.fromList [METADATA, GRAPHQL, DEVELOPER, CONFIG]