[Load Testing] gherkin/go implementation of test plan #1

Makefile

@@ -367,7 +367,7 @@ test_e2e_settlement: test_e2e_env ## Run only the E2E suite that exercises the s
 
 .PHONY: test_load_relays_stress
 test_load_relays_stress: test_e2e_env ## Run the stress test for E2E relays.
- go test -v ./load-testing/tests/... -tags=e2e,test --features-path=relays_stress.feature
+ go test -v -count=1 ./load-testing/tests/... -tags=load,test -run LoadRelays
 
 .PHONY: go_test_verbose
 go_test_verbose: check_go_version ## Run all go tests verbosely
@@ -415,10 +415,6 @@ go_develop: check_ignite_version proto_regen go_mockgen ## Generate protos and m
 .PHONY: go_develop_and_test
 go_develop_and_test: go_develop go_test ## Generate protos, mocks and run all tests
 
-.PHONY: load_test_simple
-load_test_simple: ## Runs the simplest load test through the whole stack (appgate -> relayminer -> anvil)
- k6 run load-testing/tests/appGateServerEtherium.js
-
 #############
 ### TODOS ###
 #############

app/app_config.go

@@ -356,8 +356,14 @@ var (
  Config: appconfig.WrapAny(&gatewaymodulev1.Module{}),
  },
  {
- Name: applicationmoduletypes.ModuleName,
- Config: appconfig.WrapAny(&applicationmodulev1.Module{}),
+ Name: applicationmoduletypes.ModuleName,
+ Config: appconfig.WrapAny(&applicationmodulev1.Module{
+ // TODO_BLOCKER(#486): hardcoded authority address used to update max
+ // delegated gateways for load testing purposes.
+ // To remove when we have proper governance in place.
+ // NB: pnf key address; see `poktrolld keys list --keyring-backend test`.
+ Authority: "pokt1eeeksh2tvkh7wzmfrljnhw4wrhs55lcuvmekkw",
+ }),
  },
  {
  Name: suppliermoduletypes.ModuleName,

config.yml

@@ -76,6 +76,7 @@ validators:
  timeout_propose: "2s"
  instrumentation:
  prometheus: true
+ log_level: "info"
  client:
  chain-id: poktroll
 

load-testing/config/errors.go

@@ -0,0 +1,10 @@
+package config
+
+import sdkerrors "cosmossdk.io/errors"
+
+var (
+ codespace = "load_test_manifest"
+ ErrLoadTestManifestEmpty = sdkerrors.Register(codespace, 2100, "empty load test manifest")
+ ErrLoadTestManifestUnmarshalYAML = sdkerrors.Register(codespace, 2101, "manifest reader cannot unmarshal yaml content")
+ ErrLoadTestInvalidManifest = sdkerrors.Register(codespace, 2102, "invalid load test manifest")
+)

load-testing/config/load_test_manifest_reader.go

@@ -0,0 +1,76 @@
+package config
+
+import (
+ "net/url"
+
+ "gopkg.in/yaml.v2"
+)
+
+// ProvisionedActorConfig is used to represent the signing key used & URL exposed
+// by the pre-provisioned gateway & supplier actors that the load test expects.
+type ProvisionedActorConfig struct {
+ // KeyName is the **name** of the key in the keyring to be used by the given actor.
+ KeyName string `yaml:"key_name"`
+ // ExposedUrl is the URL where the actor is expected to be reachable.
+ ExposedUrl string `yaml:"exposed_url"`
+}
+
+// LoadTestManifestYAML is the struct which the load test manifest is deserialized into.
+// It contains the list of suppliers and gateways that the load test expects to be pre-provisioned.
+type LoadTestManifestYAML struct {
+ Suppliers []ProvisionedActorConfig `yaml:"suppliers"`
+ Gateways []ProvisionedActorConfig `yaml:"gateways"`
+}
+
+// ParseLoadTestManifest reads the load test manifest from the given byte slice
+// and returns the parsed LoadTestManifestYAML struct.
+// It returns an error if the manifest is empty, or if it fails to unmarshal.
+func ParseLoadTestManifest(manifestContent []byte) (*LoadTestManifestYAML, error) {
+ var parsedManifest LoadTestManifestYAML
+
+ if len(manifestContent) == 0 {
+ return nil, ErrLoadTestManifestEmpty
+ }
+
+ if err := yaml.Unmarshal(manifestContent, &parsedManifest); err != nil {
+ return nil, ErrLoadTestManifestUnmarshalYAML.Wrapf("%s", err)
+ }
+
+ if len(parsedManifest.Gateways) == 0 {
+ return nil, ErrLoadTestInvalidManifest.Wrap("empty gateways entry")
+ }
+
+ if len(parsedManifest.Suppliers) == 0 {
+ return nil, ErrLoadTestInvalidManifest.Wrap("empty suppliers entry")
+ }
+
+ for _, supplier := range parsedManifest.Suppliers {
+ if supplier.KeyName == "" {
+ return nil, ErrLoadTestInvalidManifest.Wrap("empty supplier key name")
+ }
+
+ if supplier.ExposedUrl == "" {
+ return nil, ErrLoadTestInvalidManifest.Wrap("empty supplier server url")
+ }
+
+ if _, err := url.Parse(supplier.ExposedUrl); err != nil {
+ return nil, ErrLoadTestInvalidManifest.Wrapf("invalid supplier server url: %s", err)
+ }
+ }
+
+ for _, gateway := range parsedManifest.Gateways {
+ if gateway.KeyName == "" {
+ return nil, ErrLoadTestInvalidManifest.Wrap("empty gateway key name")
+ }
+
+ if gateway.ExposedUrl == "" {
+ return nil, ErrLoadTestInvalidManifest.Wrap("empty gateway server url")
+ }
+
+ if _, err := url.Parse(gateway.ExposedUrl); err != nil {
+ return nil, ErrLoadTestInvalidManifest.Wrapf("invalid supplier server url: %s", err)
+ }
+ }
+
+ return &parsedManifest, nil
+}

load-testing/tests/anvil.feature

@@ -0,0 +1,15 @@
+Feature: Loading anvil node only
+
+ # This scenario loads test the anvil node independently as a baseline for the
+ # volume that it can handle independent of the poktroll infrastructure and actors. 
+ Scenario Outline: Anvil can handle the maximum number of concurrent users
+ Given anvil is running
+ And load of <num_requests> concurrent requests for the "eth_blockNumber" JSON-RPC method
+ Then load is handled within <timeout> seconds
+
+ Examples:
+ | num_requests | timeout |
+ | 10 | 1 |
+ | 100 | 1 |
+ | 1000 | 5 |
+ | 10000 | 10 |