feat: add cypress trigger type (#3439)

Co-authored-by: Daniel Dias <[email protected]>

agent/workers/trigger/triggerer.go

@@ -55,6 +55,10 @@ func (r *Registry) Get(triggererType trigger.TriggerType) (Triggerer, error) {
 	r.Lock()
 	defer r.Unlock()
 
+	if triggererType.IsTraceIDBased() {
+		triggererType = trigger.TriggerTypeTraceID
+	}
+
 	t, found := r.reg[triggererType]
 	if !found {
 		return nil, fmt.Errorf(`cannot get trigger type "%s": %w`, triggererType, ErrTriggererTypeNotRegistered)

api/triggers.yaml

@@ -6,7 +6,7 @@ components:
       properties:
         type:
           type: string
-          enum: ["http", "grpc", "traceid", "kafka"]
+          enum: ["http", "grpc", "traceid", "kafka", "cypress"]
         httpRequest:
           $ref: "./http.yaml#/components/schemas/HTTPRequest"
         grpc:
@@ -21,7 +21,7 @@ components:
       properties:
         type:
           type: string
-          enum: ["http", "grpc", "traceid", "kafka"]
+          enum: ["http", "grpc", "traceid", "kafka", "cypress"]
         triggerResult:
           type: object
           properties:

server/executor/trigger/traceid.go

@@ -8,6 +8,8 @@ import (
 	"github.com/kubeshop/tracetest/server/test/trigger"
 )
 
+const TRACEID_EXPRESSION = "${env:TRACE_ID}"
+
 func TRACEID() Triggerer {
 	return &traceidTriggerer{}
 }
@@ -17,7 +19,7 @@ type traceidTriggerer struct{}
 func (t *traceidTriggerer) Trigger(ctx context.Context, test test.Test, opts *TriggerOptions) (Response, error) {
 	response := Response{
 		Result: trigger.TriggerResult{
-			Type:    t.Type(),
+			Type:    test.Trigger.Type,
 			TraceID: &trigger.TraceIDResponse{ID: test.Trigger.TraceID.ID},
 		},
 	}
@@ -30,6 +32,10 @@ func (t *traceidTriggerer) Type() trigger.TriggerType {
 }
 
 func (t *traceidTriggerer) Resolve(ctx context.Context, test test.Test, opts *ResolveOptions) (test.Test, error) {
+	if test.Trigger.Type.IsFrontendE2EBased() {
+		test.Trigger.TraceID = &trigger.TraceIDRequest{ID: TRACEID_EXPRESSION}
+	}
+
 	traceid := test.Trigger.TraceID
 	if traceid == nil {
 		return test, fmt.Errorf("no settings provided for TRACEID triggerer")

server/executor/trigger/triggerer.go

@@ -61,6 +61,10 @@ func (r *Registry) Get(triggererType trigger.TriggerType) (Triggerer, error) {
 	r.Lock()
 	defer r.Unlock()
 
+	if triggererType.IsTraceIDBased() {
+		triggererType = trigger.TriggerTypeTraceID
+	}
+
 	t, found := r.reg[triggererType]
 	if !found {
 		return nil, fmt.Errorf(`cannot get trigger type "%s": %w`, triggererType, ErrTriggererTypeNotRegistered)

server/executor/trigger_resolver_worker.go

@@ -10,7 +10,6 @@ import (
 	"github.com/kubeshop/tracetest/server/model/events"
 	"github.com/kubeshop/tracetest/server/pkg/pipeline"
 	"github.com/kubeshop/tracetest/server/test"
-	"github.com/kubeshop/tracetest/server/test/trigger"
 	"github.com/kubeshop/tracetest/server/tracedb"
 	"go.opentelemetry.io/otel/trace"
 )
@@ -132,8 +131,8 @@ func (r triggerResolverWorker) ProcessItem(ctx context.Context, job Job) {
 		r.handleError(job.Run, err)
 	}
 
-	if job.Test.Trigger.Type == trigger.TriggerTypeTraceID {
-		traceIDFromParam, err := trace.TraceIDFromHex(job.Test.Trigger.TraceID.ID)
+	if job.Test.Trigger.Type.IsTraceIDBased() {
+		traceIDFromParam, err := trace.TraceIDFromHex(resolvedTest.Trigger.TraceID.ID)
 		if err == nil {
 			run.TraceID = traceIDFromParam
 		}

server/http/mappings/tests.go

@@ -465,13 +465,17 @@ func (m Model) TriggerResult(in openapi.TriggerResult) trigger.TriggerResult {
 		Type:  trigger.TriggerType(in.Type),
 		Error: m.TriggerError(in.TriggerResult.Error),
 	}
+
+	if tr.Type.IsTraceIDBased() {
+		tr.TraceID = m.TraceIDResponse(in.TriggerResult.Traceid)
+		return tr
+	}
+
 	switch in.Type {
 	case "http":
 		tr.HTTP = m.HTTPResponse(in.TriggerResult.Http)
 	case "grpc":
 		tr.GRPC = m.GRPCResponse(in.TriggerResult.Grpc)
-	case "traceid":
-		tr.TraceID = m.TraceIDResponse(in.TriggerResult.Traceid)
 	case "kafka":
 		tr.Kafka = m.KafkaResponse(in.TriggerResult.Kafka)
 	}

server/test/trigger/traceid.go

@@ -1,6 +1,9 @@
 package trigger
 
 const TriggerTypeTraceID TriggerType = "traceid"
+const TriggerTypeCypress TriggerType = "cypress"
+
+var traceIDBasedTriggers = []TriggerType{TriggerTypeTraceID, TriggerTypeCypress}
 
 type TraceIDRequest struct {
 	ID string `json:"id,omitempty" expr_enabled:"true"`

server/test/trigger/trigger.go

@@ -1,6 +1,10 @@
 package trigger
 
-import "errors"
+import (
+	"errors"
+
+	"golang.org/x/exp/slices"
+)
 
 type (
 	TriggerType string
@@ -33,3 +37,11 @@ type (
 func (e TriggerError) Error() error {
 	return errors.New(e.ErrorMessage)
 }
+
+func (t TriggerType) IsTraceIDBased() bool {
+	return slices.Contains(traceIDBasedTriggers, t)
+}
+
+func (t TriggerType) IsFrontendE2EBased() bool {
+	return t == TriggerTypeCypress
+}

server/test/trigger/trigger_json.go

@@ -17,11 +17,11 @@ type triggerJSONV3 struct {
 
 func (v3 triggerJSONV3) valid() bool {
 	// has a valid type and at least one not nil trigger type settings
-	return v3.Type != "" &&
+	return (v3.Type != "" &&
 		(v3.HTTP != nil ||
 			v3.GRPC != nil ||
 			v3.TraceID != nil ||
-			v3.Kafka != nil)
+			v3.Kafka != nil)) || v3.Type == TriggerTypeCypress
 }
 
 type triggerJSONV2 struct {

web/src/components/CreateTest/Header.tsx

@@ -3,6 +3,7 @@ import AllowButton, {Operation} from 'components/AllowButton';
 import CreateButton from 'components/CreateButton';
 import {TriggerTypes} from 'constants/Test.constants';
 import EntryPointFactory from 'components/TestPlugins/EntryPointFactory';
+import Test from 'models/Test.model';
 import * as S from './CreateTest.styled';
 
 interface IProps {
@@ -21,18 +22,20 @@ const Header = ({isLoading, isValid, triggerType}: IProps) => {
       </S.HeaderLeft>
 
       <S.HeaderRight>
-        <AllowButton
-          block
-          ButtonComponent={CreateButton}
-          data-cy="run-test-submit"
-          disabled={!isValid}
-          loading={isLoading}
-          onClick={() => form.submit()}
-          operation={Operation.Edit}
-          type="primary"
-        >
-          Run
-        </AllowButton>
+        {Test.shouldAllowRun(triggerType) && (
+          <AllowButton
+            block
+            ButtonComponent={CreateButton}
+            data-cy="run-test-submit"
+            disabled={!isValid}
+            loading={isLoading}
+            onClick={() => form.submit()}
+            operation={Operation.Edit}
+            type="primary"
+          >
+            Run
+          </AllowButton>
+        )}
       </S.HeaderRight>
     </S.Header>
   );

web/src/components/ResourceCard/TestCard.tsx

@@ -50,17 +50,19 @@ const TestCard = ({onEdit, onDelete, onDuplicate, onRun, onViewAll, test}: IProp
         <ResourceCardSummary summary={test.summary} />
 
         <S.Row $gap={12}>
-          <CreateButton
-            data-cy={`test-run-button-${test.id}`}
-            ghost
-            onClick={event => {
-              event.stopPropagation();
-              onRun(test, ResourceType.Test);
-            }}
-            type="primary"
-          >
-            Run
-          </CreateButton>
+          {Test.shouldAllowRun(test.trigger.type) && (
+            <CreateButton
+              data-cy={`test-run-button-${test.id}`}
+              ghost
+              onClick={event => {
+                event.stopPropagation();
+                onRun(test, ResourceType.Test);
+              }}
+              type="primary"
+            >
+              Run
+            </CreateButton>
+          )}
           <ResourceCardActions
             id={test.id}
             shouldEdit={shouldEdit}

web/src/components/RunDetailLayout/HeaderRight.tsx

@@ -2,7 +2,9 @@ import CreateButton from 'components/CreateButton';
 import RunActionsMenu from 'components/RunActionsMenu';
 import TestActions from 'components/TestActions';
 import TestState from 'components/TestState';
+import {TriggerTypes} from 'constants/Test.constants';
 import {TestState as TestStateEnum} from 'constants/TestRun.constants';
+import Test from 'models/Test.model';
 import {isRunPollingState, isRunStateFinished, isRunStateStopped, isRunStateSucceeded} from 'models/TestRun.model';
 import {useTest} from 'providers/Test/Test.provider';
 import {useTestRun} from 'providers/TestRun/TestRun.provider';
@@ -17,9 +19,10 @@ import useSkipPolling from './hooks/useSkipPolling';
 
 interface IProps {
   testId: string;
+  triggerType: TriggerTypes;
 }
 
-const HeaderRight = ({testId}: IProps) => {
+const HeaderRight = ({testId, triggerType}: IProps) => {
   const {isDraftMode: isTestSpecsDraftMode} = useTestSpecs();
   const {isDraftMode: isTestOutputsDraftMode} = useTestOutput();
   const isDraftMode = isTestSpecsDraftMode || isTestOutputsDraftMode;
@@ -48,7 +51,7 @@ const HeaderRight = ({testId}: IProps) => {
         <RunStatusIcon state={state} requiredGatesResult={requiredGatesResult} />
       )}
       <VariableSetSelector />
-      {!isDraftMode && state && isRunStateFinished(state) && (
+      {!isDraftMode && state && isRunStateFinished(state) && Test.shouldAllowRun(triggerType) && (
         <CreateButton data-cy="run-test-button" ghost onClick={() => onRun()} type="primary">
           Run Test
         </CreateButton>

web/src/components/RunDetailLayout/RunDetailLayout.tsx

@@ -63,7 +63,7 @@ const RunDetailLayout = ({test: {id, name, trigger, skipTraceCollection}, test}:
   const tabBarExtraContent = useMemo(
     () => ({
       left: <HeaderLeft name={name} triggerType={trigger.type.toUpperCase()} origin={runOriginPath} />,
-      right: <HeaderRight testId={id} />,
+      right: <HeaderRight testId={id} triggerType={trigger.type} />,
     }),
     [id, name, trigger.type, runOriginPath]
   );

web/src/components/RunDetailTriggerResponse/RunDetailTriggerResponseFactory.tsx

@@ -15,8 +15,9 @@ export interface IPropsComponent {
 const ComponentMap: Record<TriggerTypes, (props: IPropsComponent) => React.ReactElement> = {
   [TriggerTypes.http]: RunDetailTriggerResponse,
   [TriggerTypes.grpc]: RunDetailTriggerResponse,
-  [TriggerTypes.traceid]: RunDetailTriggerData,
   [TriggerTypes.kafka]: RunDetailTriggerResponse,
+  [TriggerTypes.traceid]: RunDetailTriggerData,
+  [TriggerTypes.cypress]: RunDetailTriggerData,
 };
 
 interface IProps extends IPropsComponent {

web/src/components/TestHeader/TestHeader.tsx

@@ -11,7 +11,7 @@ interface IProps {
   onDelete(): void;
   onDuplicate(): void;
   title: string;
-  runButton: React.ReactElement;
+  runButton: React.ReactNode;
 }
 
 const TestHeader = ({description, id, shouldEdit, onEdit, onDelete, onDuplicate, title, runButton}: IProps) => {

web/src/components/TestPlugins/EntryPointFactory.tsx

@@ -7,8 +7,9 @@ import TriggerHeaderBarKafka from './EntryPoint/Kafka';
 const EntryPointFactoryMap = {
   [TriggerTypes.http]: TriggerHeaderBarHttp,
   [TriggerTypes.grpc]: TriggerHeaderBarGrpc,
-  [TriggerTypes.traceid]: TriggerHeaderBarTraceID,
   [TriggerTypes.kafka]: TriggerHeaderBarKafka,
+  [TriggerTypes.traceid]: TriggerHeaderBarTraceID,
+  [TriggerTypes.cypress]: () => null,
 };
 
 interface IProps {

web/src/components/TestPlugins/FormFactory.tsx

@@ -7,8 +7,9 @@ import {TDraftTestForm} from 'types/Test.types';
 const FormFactoryMap = {
   [TriggerTypes.http]: Rest,
   [TriggerTypes.grpc]: Grpc,
-  [TriggerTypes.traceid]: () => null,
   [TriggerTypes.kafka]: Kafka,
+  [TriggerTypes.traceid]: () => null,
+  [TriggerTypes.cypress]: () => null,
 };
 
 export interface IFormProps {

web/src/components/TriggerTypeModal/TriggerTypeModal.tsx

@@ -1,10 +1,10 @@
-import {TriggerTypeToPlugin} from 'constants/Plugins.constants';
+import {CreateTriggerTypeToPlugin} from 'constants/Plugins.constants';
 import {useDashboard} from 'providers/Dashboard/Dashboard.provider';
 import CreateTestAnalyticsService from 'services/Analytics/CreateTestAnalytics.service';
 import TriggerTypeCard from './TriggerTypeCard';
 import * as S from './TriggerTypeModal.styled';
 
-const pluginList = Object.values(TriggerTypeToPlugin);
+const pluginList = Object.values(CreateTriggerTypeToPlugin);
 
 interface IProps {
   isOpen: boolean;

web/src/constants/Common.constants.ts

@@ -66,6 +66,7 @@ export enum RouterSearchFields {
 export enum SupportedPlugins {
   REST = 'REST',
   GRPC = 'GRPC',
-  TraceID = 'TraceID',
   Kafka = 'Kafka',
+  TraceID = 'TraceID',
+  Cypress = 'Cypress',
 }

web/src/constants/Demo.constants.ts

@@ -228,6 +228,7 @@ export function getDemoByPluginMap(demos: Demo[]) {
       ...((otelDemoMap && otelDemoMap[SupportedPlugins.GRPC]) || []),
     ],
     [SupportedPlugins.TraceID]: [],
+    [SupportedPlugins.Cypress]: [],
     [SupportedPlugins.Kafka]: (pokeshopDemoMap && pokeshopDemoMap[SupportedPlugins.Kafka]) || [],
   };
 }

web/src/constants/Plugins.constants.ts

@@ -48,16 +48,35 @@ const TraceID: IPlugin = {
   type: TriggerTypes.traceid,
 };
 
+const Cypress: IPlugin = {
+  name: SupportedPlugins.Cypress,
+  title: 'Cypress',
+  description: 'Define your test via Cypress',
+  isActive: true,
+  demoList: [],
+  type: TriggerTypes.cypress,
+  requestType: TriggerTypes.traceid,
+};
+
 export const Plugins = {
   [SupportedPlugins.REST]: Rest,
   [SupportedPlugins.GRPC]: GRPC,
   [SupportedPlugins.Kafka]: Kafka,
   [SupportedPlugins.TraceID]: TraceID,
+  [SupportedPlugins.Cypress]: Cypress,
 } as const;
 
 export const TriggerTypeToPlugin = {
   [TriggerTypes.http]: Plugins.REST,
   [TriggerTypes.grpc]: Plugins.GRPC,
   [TriggerTypes.kafka]: Plugins.Kafka,
   [TriggerTypes.traceid]: Plugins.TraceID,
+  [TriggerTypes.cypress]: Plugins.Cypress,
+} as const;
+
+export const CreateTriggerTypeToPlugin = {
+  [TriggerTypes.http]: Plugins.REST,
+  [TriggerTypes.grpc]: Plugins.GRPC,
+  [TriggerTypes.kafka]: Plugins.Kafka,
+  [TriggerTypes.traceid]: Plugins.TraceID,
 } as const;

web/src/constants/Test.constants.ts

@@ -10,6 +10,7 @@ export enum TriggerTypes {
   grpc = 'grpc',
   traceid = 'traceid',
   kafka = 'kafka',
+  cypress = 'cypress',
 }
 
 export enum ImportTypes {

web/src/models/Test.model.ts

@@ -1,3 +1,4 @@
+import {TriggerTypes} from 'constants/Test.constants';
 import {load} from 'js-yaml';
 import {Model, TTestSchemas} from 'types/Common.types';
 import TestOutput from './TestOutput.model';
@@ -54,4 +55,8 @@ Test.FromDefinition = (definition: string): Test => {
   return Test(raw);
 };
 
+Test.shouldAllowRun = (triggerType: TriggerTypes): boolean => {
+  return triggerType !== TriggerTypes.cypress;
+};
+
 export default Test;