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

Makefile

@@ -347,7 +347,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=e2e,test -run LoadRelays
 
 .PHONY: go_test_verbose
 go_test_verbose: check_go_version ## Run all go tests verbosely
@@ -395,10 +395,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 laod 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,13 @@
+Feature: Loading anvil
+
+  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      |