stubs

package
v0.16.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 5, 2024 License: MIT Imports: 7 Imported by: 2

Documentation

Overview

Package stubs is a set of test stubs for Dogma interfaces.

Index

Constants

This section is empty.

Variables

View Source 
var (
	// CommandA1 is command of type [CommandA] with content "A1".
	CommandA1 = CommandStub[TypeA]{Content: "A1"}
	// CommandA2 is command of type [CommandA] with content "A2".
	CommandA2 = CommandStub[TypeA]{Content: "A2"}
	// CommandA3 is command of type [CommandA] with content "A3".
	CommandA3 = CommandStub[TypeA]{Content: "A3"}

	// CommandB1 is command of type [CommandB] with content "B1".
	CommandB1 = CommandStub[TypeB]{Content: "B1"}
	// CommandB2 is command of type [CommandB] with content "B2".
	CommandB2 = CommandStub[TypeB]{Content: "B2"}
	// CommandB3 is command of type [CommandB] with content "B3".
	CommandB3 = CommandStub[TypeB]{Content: "B3"}

	// CommandC1 is command of type [CommandC] with content "C1".
	CommandC1 = CommandStub[TypeC]{Content: "C1"}
	// CommandC2 is command of type [CommandC] with content "C2".
	CommandC2 = CommandStub[TypeC]{Content: "C2"}
	// CommandC3 is command of type [CommandC] with content "C3".
	CommandC3 = CommandStub[TypeC]{Content: "C3"}

	// CommandD1 is command of type [CommandD] with content "D1".
	CommandD1 = CommandStub[TypeD]{Content: "D1"}
	// CommandD2 is command of type [CommandD] with content "D2".
	CommandD2 = CommandStub[TypeD]{Content: "D2"}
	// CommandD3 is command of type [CommandD] with content "D3".
	CommandD3 = CommandStub[TypeD]{Content: "D3"}

	// CommandE1 is command of type [CommandE] with content "E1".
	CommandE1 = CommandStub[TypeE]{Content: "E1"}
	// CommandE2 is command of type [CommandE] with content "E2".
	CommandE2 = CommandStub[TypeE]{Content: "E2"}
	// CommandE3 is command of type [CommandE] with content "E3".
	CommandE3 = CommandStub[TypeE]{Content: "E3"}

	// CommandF1 is command of type [CommandF] with content "F1".
	CommandF1 = CommandStub[TypeF]{Content: "F1"}
	// CommandF2 is command of type [CommandF] with content "F2".
	CommandF2 = CommandStub[TypeF]{Content: "F2"}
	// CommandF3 is command of type [CommandF] with content "F3".
	CommandF3 = CommandStub[TypeF]{Content: "F3"}

	// CommandG1 is command of type [CommandG] with content "G1".
	CommandG1 = CommandStub[TypeG]{Content: "G1"}
	// CommandG2 is command of type [CommandG] with content "G2".
	CommandG2 = CommandStub[TypeG]{Content: "G2"}
	// CommandG3 is command of type [CommandG] with content "G3".
	CommandG3 = CommandStub[TypeG]{Content: "G3"}

	// CommandH1 is command of type [CommandH] with content "H1".
	CommandH1 = CommandStub[TypeH]{Content: "H1"}
	// CommandH2 is command of type [CommandH] with content "H2".
	CommandH2 = CommandStub[TypeH]{Content: "H2"}
	// CommandH3 is command of type [CommandH] with content "H3".
	CommandH3 = CommandStub[TypeH]{Content: "H3"}

	// CommandI1 is command of type [CommandI] with content "I1".
	CommandI1 = CommandStub[TypeI]{Content: "I1"}
	// CommandI2 is command of type [CommandI] with content "I2".
	CommandI2 = CommandStub[TypeI]{Content: "I2"}
	// CommandI3 is command of type [CommandI] with content "I3".
	CommandI3 = CommandStub[TypeI]{Content: "I3"}

	// CommandJ1 is command of type [CommandJ] with content "J1".
	CommandJ1 = CommandStub[TypeJ]{Content: "J1"}
	// CommandJ2 is command of type [CommandJ] with content "J2".
	CommandJ2 = CommandStub[TypeJ]{Content: "J2"}
	// CommandJ3 is command of type [CommandJ] with content "J3".
	CommandJ3 = CommandStub[TypeJ]{Content: "J3"}

	// CommandK1 is command of type [CommandK] with content "K1".
	CommandK1 = CommandStub[TypeK]{Content: "K1"}
	// CommandK2 is command of type [CommandK] with content "K2".
	CommandK2 = CommandStub[TypeK]{Content: "K2"}
	// CommandK3 is command of type [CommandK] with content "K3".
	CommandK3 = CommandStub[TypeK]{Content: "K3"}

	// CommandL1 is command of type [CommandL] with content "L1".
	CommandL1 = CommandStub[TypeL]{Content: "L1"}
	// CommandL2 is command of type [CommandL] with content "L2".
	CommandL2 = CommandStub[TypeL]{Content: "L2"}
	// CommandL3 is command of type [CommandL] with content "L3".
	CommandL3 = CommandStub[TypeL]{Content: "L3"}

	// CommandM1 is command of type [CommandM] with content "M1".
	CommandM1 = CommandStub[TypeM]{Content: "M1"}
	// CommandM2 is command of type [CommandM] with content "M2".
	CommandM2 = CommandStub[TypeM]{Content: "M2"}
	// CommandM3 is command of type [CommandM] with content "M3".
	CommandM3 = CommandStub[TypeM]{Content: "M3"}

	// CommandN1 is command of type [CommandN] with content "N1".
	CommandN1 = CommandStub[TypeN]{Content: "N1"}
	// CommandN2 is command of type [CommandN] with content "N2".
	CommandN2 = CommandStub[TypeN]{Content: "N2"}
	// CommandN3 is command of type [CommandN] with content "N3".
	CommandN3 = CommandStub[TypeN]{Content: "N3"}

	// CommandO1 is command of type [CommandO] with content "O1".
	CommandO1 = CommandStub[TypeO]{Content: "O1"}
	// CommandO2 is command of type [CommandO] with content "O2".
	CommandO2 = CommandStub[TypeO]{Content: "O2"}
	// CommandO3 is command of type [CommandO] with content "O3".
	CommandO3 = CommandStub[TypeO]{Content: "O3"}

	// CommandP1 is command of type [CommandP] with content "P1".
	CommandP1 = CommandStub[TypeP]{Content: "P1"}
	// CommandP2 is command of type [CommandP] with content "P2".
	CommandP2 = CommandStub[TypeP]{Content: "P2"}
	// CommandP3 is command of type [CommandP] with content "P3".
	CommandP3 = CommandStub[TypeP]{Content: "P3"}

	// CommandQ1 is command of type [CommandQ] with content "Q1".
	CommandQ1 = CommandStub[TypeQ]{Content: "Q1"}
	// CommandQ2 is command of type [CommandQ] with content "Q2".
	CommandQ2 = CommandStub[TypeQ]{Content: "Q2"}
	// CommandQ3 is command of type [CommandQ] with content "Q3".
	CommandQ3 = CommandStub[TypeQ]{Content: "Q3"}

	// CommandR1 is command of type [CommandR] with content "R1".
	CommandR1 = CommandStub[TypeR]{Content: "R1"}
	// CommandR2 is command of type [CommandR] with content "R2".
	CommandR2 = CommandStub[TypeR]{Content: "R2"}
	// CommandR3 is command of type [CommandR] with content "R3".
	CommandR3 = CommandStub[TypeR]{Content: "R3"}

	// CommandS1 is command of type [CommandS] with content "S1".
	CommandS1 = CommandStub[TypeS]{Content: "S1"}
	// CommandS2 is command of type [CommandS] with content "S2".
	CommandS2 = CommandStub[TypeS]{Content: "S2"}
	// CommandS3 is command of type [CommandS] with content "S3".
	CommandS3 = CommandStub[TypeS]{Content: "S3"}

	// CommandT1 is command of type [CommandT] with content "T1".
	CommandT1 = CommandStub[TypeT]{Content: "T1"}
	// CommandT2 is command of type [CommandT] with content "T2".
	CommandT2 = CommandStub[TypeT]{Content: "T2"}
	// CommandT3 is command of type [CommandT] with content "T3".
	CommandT3 = CommandStub[TypeT]{Content: "T3"}

	// CommandU1 is command of type [CommandU] with content "U1".
	CommandU1 = CommandStub[TypeU]{Content: "U1"}
	// CommandU2 is command of type [CommandU] with content "U2".
	CommandU2 = CommandStub[TypeU]{Content: "U2"}
	// CommandU3 is command of type [CommandU] with content "U3".
	CommandU3 = CommandStub[TypeU]{Content: "U3"}

	// CommandV1 is command of type [CommandV] with content "V1".
	CommandV1 = CommandStub[TypeV]{Content: "V1"}
	// CommandV2 is command of type [CommandV] with content "V2".
	CommandV2 = CommandStub[TypeV]{Content: "V2"}
	// CommandV3 is command of type [CommandV] with content "V3".
	CommandV3 = CommandStub[TypeV]{Content: "V3"}

	// CommandW1 is command of type [CommandW] with content "W1".
	CommandW1 = CommandStub[TypeW]{Content: "W1"}
	// CommandW2 is command of type [CommandW] with content "W2".
	CommandW2 = CommandStub[TypeW]{Content: "W2"}
	// CommandW3 is command of type [CommandW] with content "W3".
	CommandW3 = CommandStub[TypeW]{Content: "W3"}

	// CommandX1 is command of type [CommandX] with content "X1".
	CommandX1 = CommandStub[TypeX]{Content: "X1"}
	// CommandX2 is command of type [CommandX] with content "X2".
	CommandX2 = CommandStub[TypeX]{Content: "X2"}
	// CommandX3 is command of type [CommandX] with content "X3".
	CommandX3 = CommandStub[TypeX]{Content: "X3"}

	// CommandY1 is command of type [CommandY] with content "Y1".
	CommandY1 = CommandStub[TypeY]{Content: "Y1"}
	// CommandY2 is command of type [CommandY] with content "Y2".
	CommandY2 = CommandStub[TypeY]{Content: "Y2"}
	// CommandY3 is command of type [CommandY] with content "Y3".
	CommandY3 = CommandStub[TypeY]{Content: "Y3"}

	// CommandZ1 is command of type [CommandZ] with content "Z1".
	CommandZ1 = CommandStub[TypeZ]{Content: "Z1"}
	// CommandZ2 is command of type [CommandZ] with content "Z2".
	CommandZ2 = CommandStub[TypeZ]{Content: "Z2"}
	// CommandZ3 is command of type [CommandZ] with content "Z3".
	CommandZ3 = CommandStub[TypeZ]{Content: "Z3"}
)
View Source 
var (
	// EventA1 is event of type [EventA] with content "A1".
	EventA1 = EventStub[TypeA]{Content: "A1"}
	// EventA2 is event of type [EventA] with content "A2".
	EventA2 = EventStub[TypeA]{Content: "A2"}
	// EventA3 is event of type [EventA] with content "A3".
	EventA3 = EventStub[TypeA]{Content: "A3"}

	// EventB1 is event of type [EventB] with content "B1".
	EventB1 = EventStub[TypeB]{Content: "B1"}
	// EventB2 is event of type [EventB] with content "B2".
	EventB2 = EventStub[TypeB]{Content: "B2"}
	// EventB3 is event of type [EventB] with content "B3".
	EventB3 = EventStub[TypeB]{Content: "B3"}

	// EventC1 is event of type [EventC] with content "C1".
	EventC1 = EventStub[TypeC]{Content: "C1"}
	// EventC2 is event of type [EventC] with content "C2".
	EventC2 = EventStub[TypeC]{Content: "C2"}
	// EventC3 is event of type [EventC] with content "C3".
	EventC3 = EventStub[TypeC]{Content: "C3"}

	// EventD1 is event of type [EventD] with content "D1".
	EventD1 = EventStub[TypeD]{Content: "D1"}
	// EventD2 is event of type [EventD] with content "D2".
	EventD2 = EventStub[TypeD]{Content: "D2"}
	// EventD3 is event of type [EventD] with content "D3".
	EventD3 = EventStub[TypeD]{Content: "D3"}

	// EventE1 is event of type [EventE] with content "E1".
	EventE1 = EventStub[TypeE]{Content: "E1"}
	// EventE2 is event of type [EventE] with content "E2".
	EventE2 = EventStub[TypeE]{Content: "E2"}
	// EventE3 is event of type [EventE] with content "E3".
	EventE3 = EventStub[TypeE]{Content: "E3"}

	// EventF1 is event of type [EventF] with content "F1".
	EventF1 = EventStub[TypeF]{Content: "F1"}
	// EventF2 is event of type [EventF] with content "F2".
	EventF2 = EventStub[TypeF]{Content: "F2"}
	// EventF3 is event of type [EventF] with content "F3".
	EventF3 = EventStub[TypeF]{Content: "F3"}

	// EventG1 is event of type [EventG] with content "G1".
	EventG1 = EventStub[TypeG]{Content: "G1"}
	// EventG2 is event of type [EventG] with content "G2".
	EventG2 = EventStub[TypeG]{Content: "G2"}
	// EventG3 is event of type [EventG] with content "G3".
	EventG3 = EventStub[TypeG]{Content: "G3"}

	// EventH1 is event of type [EventH] with content "H1".
	EventH1 = EventStub[TypeH]{Content: "H1"}
	// EventH2 is event of type [EventH] with content "H2".
	EventH2 = EventStub[TypeH]{Content: "H2"}
	// EventH3 is event of type [EventH] with content "H3".
	EventH3 = EventStub[TypeH]{Content: "H3"}

	// EventI1 is event of type [EventI] with content "I1".
	EventI1 = EventStub[TypeI]{Content: "I1"}
	// EventI2 is event of type [EventI] with content "I2".
	EventI2 = EventStub[TypeI]{Content: "I2"}
	// EventI3 is event of type [EventI] with content "I3".
	EventI3 = EventStub[TypeI]{Content: "I3"}

	// EventJ1 is event of type [EventJ] with content "J1".
	EventJ1 = EventStub[TypeJ]{Content: "J1"}
	// EventJ2 is event of type [EventJ] with content "J2".
	EventJ2 = EventStub[TypeJ]{Content: "J2"}
	// EventJ3 is event of type [EventJ] with content "J3".
	EventJ3 = EventStub[TypeJ]{Content: "J3"}

	// EventK1 is event of type [EventK] with content "K1".
	EventK1 = EventStub[TypeK]{Content: "K1"}
	// EventK2 is event of type [EventK] with content "K2".
	EventK2 = EventStub[TypeK]{Content: "K2"}
	// EventK3 is event of type [EventK] with content "K3".
	EventK3 = EventStub[TypeK]{Content: "K3"}

	// EventL1 is event of type [EventL] with content "L1".
	EventL1 = EventStub[TypeL]{Content: "L1"}
	// EventL2 is event of type [EventL] with content "L2".
	EventL2 = EventStub[TypeL]{Content: "L2"}
	// EventL3 is event of type [EventL] with content "L3".
	EventL3 = EventStub[TypeL]{Content: "L3"}

	// EventM1 is event of type [EventM] with content "M1".
	EventM1 = EventStub[TypeM]{Content: "M1"}
	// EventM2 is event of type [EventM] with content "M2".
	EventM2 = EventStub[TypeM]{Content: "M2"}
	// EventM3 is event of type [EventM] with content "M3".
	EventM3 = EventStub[TypeM]{Content: "M3"}

	// EventN1 is event of type [EventN] with content "N1".
	EventN1 = EventStub[TypeN]{Content: "N1"}
	// EventN2 is event of type [EventN] with content "N2".
	EventN2 = EventStub[TypeN]{Content: "N2"}
	// EventN3 is event of type [EventN] with content "N3".
	EventN3 = EventStub[TypeN]{Content: "N3"}

	// EventO1 is event of type [EventO] with content "O1".
	EventO1 = EventStub[TypeO]{Content: "O1"}
	// EventO2 is event of type [EventO] with content "O2".
	EventO2 = EventStub[TypeO]{Content: "O2"}
	// EventO3 is event of type [EventO] with content "O3".
	EventO3 = EventStub[TypeO]{Content: "O3"}

	// EventP1 is event of type [EventP] with content "P1".
	EventP1 = EventStub[TypeP]{Content: "P1"}
	// EventP2 is event of type [EventP] with content "P2".
	EventP2 = EventStub[TypeP]{Content: "P2"}
	// EventP3 is event of type [EventP] with content "P3".
	EventP3 = EventStub[TypeP]{Content: "P3"}

	// EventQ1 is event of type [EventQ] with content "Q1".
	EventQ1 = EventStub[TypeQ]{Content: "Q1"}
	// EventQ2 is event of type [EventQ] with content "Q2".
	EventQ2 = EventStub[TypeQ]{Content: "Q2"}
	// EventQ3 is event of type [EventQ] with content "Q3".
	EventQ3 = EventStub[TypeQ]{Content: "Q3"}

	// EventR1 is event of type [EventR] with content "R1".
	EventR1 = EventStub[TypeR]{Content: "R1"}
	// EventR2 is event of type [EventR] with content "R2".
	EventR2 = EventStub[TypeR]{Content: "R2"}
	// EventR3 is event of type [EventR] with content "R3".
	EventR3 = EventStub[TypeR]{Content: "R3"}

	// EventS1 is event of type [EventS] with content "S1".
	EventS1 = EventStub[TypeS]{Content: "S1"}
	// EventS2 is event of type [EventS] with content "S2".
	EventS2 = EventStub[TypeS]{Content: "S2"}
	// EventS3 is event of type [EventS] with content "S3".
	EventS3 = EventStub[TypeS]{Content: "S3"}

	// EventT1 is event of type [EventT] with content "T1".
	EventT1 = EventStub[TypeT]{Content: "T1"}
	// EventT2 is event of type [EventT] with content "T2".
	EventT2 = EventStub[TypeT]{Content: "T2"}
	// EventT3 is event of type [EventT] with content "T3".
	EventT3 = EventStub[TypeT]{Content: "T3"}

	// EventU1 is event of type [EventU] with content "U1".
	EventU1 = EventStub[TypeU]{Content: "U1"}
	// EventU2 is event of type [EventU] with content "U2".
	EventU2 = EventStub[TypeU]{Content: "U2"}
	// EventU3 is event of type [EventU] with content "U3".
	EventU3 = EventStub[TypeU]{Content: "U3"}

	// EventV1 is event of type [EventV] with content "V1".
	EventV1 = EventStub[TypeV]{Content: "V1"}
	// EventV2 is event of type [EventV] with content "V2".
	EventV2 = EventStub[TypeV]{Content: "V2"}
	// EventV3 is event of type [EventV] with content "V3".
	EventV3 = EventStub[TypeV]{Content: "V3"}

	// EventW1 is event of type [EventW] with content "W1".
	EventW1 = EventStub[TypeW]{Content: "W1"}
	// EventW2 is event of type [EventW] with content "W2".
	EventW2 = EventStub[TypeW]{Content: "W2"}
	// EventW3 is event of type [EventW] with content "W3".
	EventW3 = EventStub[TypeW]{Content: "W3"}

	// EventX1 is event of type [EventX] with content "X1".
	EventX1 = EventStub[TypeX]{Content: "X1"}
	// EventX2 is event of type [EventX] with content "X2".
	EventX2 = EventStub[TypeX]{Content: "X2"}
	// EventX3 is event of type [EventX] with content "X3".
	EventX3 = EventStub[TypeX]{Content: "X3"}

	// EventY1 is event of type [EventY] with content "Y1".
	EventY1 = EventStub[TypeY]{Content: "Y1"}
	// EventY2 is event of type [EventY] with content "Y2".
	EventY2 = EventStub[TypeY]{Content: "Y2"}
	// EventY3 is event of type [EventY] with content "Y3".
	EventY3 = EventStub[TypeY]{Content: "Y3"}

	// EventZ1 is event of type [EventZ] with content "Z1".
	EventZ1 = EventStub[TypeZ]{Content: "Z1"}
	// EventZ2 is event of type [EventZ] with content "Z2".
	EventZ2 = EventStub[TypeZ]{Content: "Z2"}
	// EventZ3 is event of type [EventZ] with content "Z3".
	EventZ3 = EventStub[TypeZ]{Content: "Z3"}
)
View Source 
var (
	// TimeoutA1 is a timeout message of type [TimeoutA] with content "A1".
	TimeoutA1 = TimeoutStub[TypeA]{Content: "A1"}
	// TimeoutA2 is a timeout message of type [TimeoutA] with content "A2".
	TimeoutA2 = TimeoutStub[TypeA]{Content: "A2"}
	// TimeoutA3 is a timeout message of type [TimeoutA] with content "A3".
	TimeoutA3 = TimeoutStub[TypeA]{Content: "A3"}

	// TimeoutB1 is a timeout message of type [TimeoutB] with content "B1".
	TimeoutB1 = TimeoutStub[TypeB]{Content: "B1"}
	// TimeoutB2 is a timeout message of type [TimeoutB] with content "B2".
	TimeoutB2 = TimeoutStub[TypeB]{Content: "B2"}
	// TimeoutB3 is a timeout message of type [TimeoutB] with content "B3".
	TimeoutB3 = TimeoutStub[TypeB]{Content: "B3"}

	// TimeoutC1 is a timeout message of type [TimeoutC] with content "C1".
	TimeoutC1 = TimeoutStub[TypeC]{Content: "C1"}
	// TimeoutC2 is a timeout message of type [TimeoutC] with content "C2".
	TimeoutC2 = TimeoutStub[TypeC]{Content: "C2"}
	// TimeoutC3 is a timeout message of type [TimeoutC] with content "C3".
	TimeoutC3 = TimeoutStub[TypeC]{Content: "C3"}

	// TimeoutD1 is a timeout message of type [TimeoutD] with content "D1".
	TimeoutD1 = TimeoutStub[TypeD]{Content: "D1"}
	// TimeoutD2 is a timeout message of type [TimeoutD] with content "D2".
	TimeoutD2 = TimeoutStub[TypeD]{Content: "D2"}
	// TimeoutD3 is a timeout message of type [TimeoutD] with content "D3".
	TimeoutD3 = TimeoutStub[TypeD]{Content: "D3"}

	// TimeoutE1 is a timeout message of type [TimeoutE] with content "E1".
	TimeoutE1 = TimeoutStub[TypeE]{Content: "E1"}
	// TimeoutE2 is a timeout message of type [TimeoutE] with content "E2".
	TimeoutE2 = TimeoutStub[TypeE]{Content: "E2"}
	// TimeoutE3 is a timeout message of type [TimeoutE] with content "E3".
	TimeoutE3 = TimeoutStub[TypeE]{Content: "E3"}

	// TimeoutF1 is a timeout message of type [TimeoutF] with content "F1".
	TimeoutF1 = TimeoutStub[TypeF]{Content: "F1"}
	// TimeoutF2 is a timeout message of type [TimeoutF] with content "F2".
	TimeoutF2 = TimeoutStub[TypeF]{Content: "F2"}
	// TimeoutF3 is a timeout message of type [TimeoutF] with content "F3".
	TimeoutF3 = TimeoutStub[TypeF]{Content: "F3"}

	// TimeoutG1 is a timeout message of type [TimeoutG] with content "G1".
	TimeoutG1 = TimeoutStub[TypeG]{Content: "G1"}
	// TimeoutG2 is a timeout message of type [TimeoutG] with content "G2".
	TimeoutG2 = TimeoutStub[TypeG]{Content: "G2"}
	// TimeoutG3 is a timeout message of type [TimeoutG] with content "G3".
	TimeoutG3 = TimeoutStub[TypeG]{Content: "G3"}

	// TimeoutH1 is a timeout message of type [TimeoutH] with content "H1".
	TimeoutH1 = TimeoutStub[TypeH]{Content: "H1"}
	// TimeoutH2 is a timeout message of type [TimeoutH] with content "H2".
	TimeoutH2 = TimeoutStub[TypeH]{Content: "H2"}
	// TimeoutH3 is a timeout message of type [TimeoutH] with content "H3".
	TimeoutH3 = TimeoutStub[TypeH]{Content: "H3"}

	// TimeoutI1 is a timeout message of type [TimeoutI] with content "I1".
	TimeoutI1 = TimeoutStub[TypeI]{Content: "I1"}
	// TimeoutI2 is a timeout message of type [TimeoutI] with content "I2".
	TimeoutI2 = TimeoutStub[TypeI]{Content: "I2"}
	// TimeoutI3 is a timeout message of type [TimeoutI] with content "I3".
	TimeoutI3 = TimeoutStub[TypeI]{Content: "I3"}

	// TimeoutJ1 is a timeout message of type [TimeoutJ] with content "J1".
	TimeoutJ1 = TimeoutStub[TypeJ]{Content: "J1"}
	// TimeoutJ2 is a timeout message of type [TimeoutJ] with content "J2".
	TimeoutJ2 = TimeoutStub[TypeJ]{Content: "J2"}
	// TimeoutJ3 is a timeout message of type [TimeoutJ] with content "J3".
	TimeoutJ3 = TimeoutStub[TypeJ]{Content: "J3"}

	// TimeoutK1 is a timeout message of type [TimeoutK] with content "K1".
	TimeoutK1 = TimeoutStub[TypeK]{Content: "K1"}
	// TimeoutK2 is a timeout message of type [TimeoutK] with content "K2".
	TimeoutK2 = TimeoutStub[TypeK]{Content: "K2"}
	// TimeoutK3 is a timeout message of type [TimeoutK] with content "K3".
	TimeoutK3 = TimeoutStub[TypeK]{Content: "K3"}

	// TimeoutL1 is a timeout message of type [TimeoutL] with content "L1".
	TimeoutL1 = TimeoutStub[TypeL]{Content: "L1"}
	// TimeoutL2 is a timeout message of type [TimeoutL] with content "L2".
	TimeoutL2 = TimeoutStub[TypeL]{Content: "L2"}
	// TimeoutL3 is a timeout message of type [TimeoutL] with content "L3".
	TimeoutL3 = TimeoutStub[TypeL]{Content: "L3"}

	// TimeoutM1 is a timeout message of type [TimeoutM] with content "M1".
	TimeoutM1 = TimeoutStub[TypeM]{Content: "M1"}
	// TimeoutM2 is a timeout message of type [TimeoutM] with content "M2".
	TimeoutM2 = TimeoutStub[TypeM]{Content: "M2"}
	// TimeoutM3 is a timeout message of type [TimeoutM] with content "M3".
	TimeoutM3 = TimeoutStub[TypeM]{Content: "M3"}

	// TimeoutN1 is a timeout message of type [TimeoutN] with content "N1".
	TimeoutN1 = TimeoutStub[TypeN]{Content: "N1"}
	// TimeoutN2 is a timeout message of type [TimeoutN] with content "N2".
	TimeoutN2 = TimeoutStub[TypeN]{Content: "N2"}
	// TimeoutN3 is a timeout message of type [TimeoutN] with content "N3".
	TimeoutN3 = TimeoutStub[TypeN]{Content: "N3"}

	// TimeoutO1 is a timeout message of type [TimeoutO] with content "O1".
	TimeoutO1 = TimeoutStub[TypeO]{Content: "O1"}
	// TimeoutO2 is a timeout message of type [TimeoutO] with content "O2".
	TimeoutO2 = TimeoutStub[TypeO]{Content: "O2"}
	// TimeoutO3 is a timeout message of type [TimeoutO] with content "O3".
	TimeoutO3 = TimeoutStub[TypeO]{Content: "O3"}

	// TimeoutP1 is a timeout message of type [TimeoutP] with content "P1".
	TimeoutP1 = TimeoutStub[TypeP]{Content: "P1"}
	// TimeoutP2 is a timeout message of type [TimeoutP] with content "P2".
	TimeoutP2 = TimeoutStub[TypeP]{Content: "P2"}
	// TimeoutP3 is a timeout message of type [TimeoutP] with content "P3".
	TimeoutP3 = TimeoutStub[TypeP]{Content: "P3"}

	// TimeoutQ1 is a timeout message of type [TimeoutQ] with content "Q1".
	TimeoutQ1 = TimeoutStub[TypeQ]{Content: "Q1"}
	// TimeoutQ2 is a timeout message of type [TimeoutQ] with content "Q2".
	TimeoutQ2 = TimeoutStub[TypeQ]{Content: "Q2"}
	// TimeoutQ3 is a timeout message of type [TimeoutQ] with content "Q3".
	TimeoutQ3 = TimeoutStub[TypeQ]{Content: "Q3"}

	// TimeoutR1 is a timeout message of type [TimeoutR] with content "R1".
	TimeoutR1 = TimeoutStub[TypeR]{Content: "R1"}
	// TimeoutR2 is a timeout message of type [TimeoutR] with content "R2".
	TimeoutR2 = TimeoutStub[TypeR]{Content: "R2"}
	// TimeoutR3 is a timeout message of type [TimeoutR] with content "R3".
	TimeoutR3 = TimeoutStub[TypeR]{Content: "R3"}

	// TimeoutS1 is a timeout message of type [TimeoutS] with content "S1".
	TimeoutS1 = TimeoutStub[TypeS]{Content: "S1"}
	// TimeoutS2 is a timeout message of type [TimeoutS] with content "S2".
	TimeoutS2 = TimeoutStub[TypeS]{Content: "S2"}
	// TimeoutS3 is a timeout message of type [TimeoutS] with content "S3".
	TimeoutS3 = TimeoutStub[TypeS]{Content: "S3"}

	// TimeoutT1 is a timeout message of type [TimeoutT] with content "T1".
	TimeoutT1 = TimeoutStub[TypeT]{Content: "T1"}
	// TimeoutT2 is a timeout message of type [TimeoutT] with content "T2".
	TimeoutT2 = TimeoutStub[TypeT]{Content: "T2"}
	// TimeoutT3 is a timeout message of type [TimeoutT] with content "T3".
	TimeoutT3 = TimeoutStub[TypeT]{Content: "T3"}

	// TimeoutU1 is a timeout message of type [TimeoutU] with content "U1".
	TimeoutU1 = TimeoutStub[TypeU]{Content: "U1"}
	// TimeoutU2 is a timeout message of type [TimeoutU] with content "U2".
	TimeoutU2 = TimeoutStub[TypeU]{Content: "U2"}
	// TimeoutU3 is a timeout message of type [TimeoutU] with content "U3".
	TimeoutU3 = TimeoutStub[TypeU]{Content: "U3"}

	// TimeoutV1 is a timeout message of type [TimeoutV] with content "V1".
	TimeoutV1 = TimeoutStub[TypeV]{Content: "V1"}
	// TimeoutV2 is a timeout message of type [TimeoutV] with content "V2".
	TimeoutV2 = TimeoutStub[TypeV]{Content: "V2"}
	// TimeoutV3 is a timeout message of type [TimeoutV] with content "V3".
	TimeoutV3 = TimeoutStub[TypeV]{Content: "V3"}

	// TimeoutW1 is a timeout message of type [TimeoutW] with content "W1".
	TimeoutW1 = TimeoutStub[TypeW]{Content: "W1"}
	// TimeoutW2 is a timeout message of type [TimeoutW] with content "W2".
	TimeoutW2 = TimeoutStub[TypeW]{Content: "W2"}
	// TimeoutW3 is a timeout message of type [TimeoutW] with content "W3".
	TimeoutW3 = TimeoutStub[TypeW]{Content: "W3"}

	// TimeoutX1 is a timeout message of type [TimeoutX] with content "X1".
	TimeoutX1 = TimeoutStub[TypeX]{Content: "X1"}
	// TimeoutX2 is a timeout message of type [TimeoutX] with content "X2".
	TimeoutX2 = TimeoutStub[TypeX]{Content: "X2"}
	// TimeoutX3 is a timeout message of type [TimeoutX] with content "X3".
	TimeoutX3 = TimeoutStub[TypeX]{Content: "X3"}

	// TimeoutY1 is a timeout message of type [TimeoutY] with content "Y1".
	TimeoutY1 = TimeoutStub[TypeY]{Content: "Y1"}
	// TimeoutY2 is a timeout message of type [TimeoutY] with content "Y2".
	TimeoutY2 = TimeoutStub[TypeY]{Content: "Y2"}
	// TimeoutY3 is a timeout message of type [TimeoutY] with content "Y3".
	TimeoutY3 = TimeoutStub[TypeY]{Content: "Y3"}

	// TimeoutZ1 is a timeout message of type [TimeoutZ] with content "Z1".
	TimeoutZ1 = TimeoutStub[TypeZ]{Content: "Z1"}
	// TimeoutZ2 is a timeout message of type [TimeoutZ] with content "Z2".
	TimeoutZ2 = TimeoutStub[TypeZ]{Content: "Z2"}
	// TimeoutZ3 is a timeout message of type [TimeoutZ] with content "Z3".
	TimeoutZ3 = TimeoutStub[TypeZ]{Content: "Z3"}
)
View Source 
var Marshaler marshaler.Marshaler

Marshaler is a marshaler.Marshaler that can marshal and unmarshal all of the data types in this package.

Functions

This section is empty.

Types

type AggregateMessageHandlerStub 

type AggregateMessageHandlerStub struct {
	NewFunc                    func() dogma.AggregateRoot
	ConfigureFunc              func(dogma.AggregateConfigurer)
	RouteCommandToInstanceFunc func(dogma.Command) string
	HandleCommandFunc          func(dogma.AggregateRoot, dogma.AggregateCommandScope, dogma.Command)
}

AggregateMessageHandlerStub is a test implementation of dogma.AggregateMessageHandler.

func (*AggregateMessageHandlerStub) Configure 

func (h *AggregateMessageHandlerStub) Configure(c dogma.AggregateConfigurer)

Configure describes the handler's configuration to the engine.

func (*AggregateMessageHandlerStub) HandleCommand 

func (h *AggregateMessageHandlerStub) HandleCommand(
	r dogma.AggregateRoot,
	s dogma.AggregateCommandScope,
	c dogma.Command,
)

HandleCommand executes business logic in response to a command.

func (*AggregateMessageHandlerStub) New 

func (h *AggregateMessageHandlerStub) New() dogma.AggregateRoot

New returns an aggregate root instance in its initial state.

func (*AggregateMessageHandlerStub) RouteCommandToInstance 

func (h *AggregateMessageHandlerStub) RouteCommandToInstance(c dogma.Command) string

RouteCommandToInstance returns the ID of the instance that handles a specific command.

type AggregateRootStub 

type AggregateRootStub struct {
	AppliedEvents  []dogma.Event     `json:"applied_events,omitempty"`
	ApplyEventFunc func(dogma.Event) `json:"-"`
}

AggregateRootStub is a test implementation of dogma.AggregateRoot.

func (*AggregateRootStub) ApplyEvent 

func (v *AggregateRootStub) ApplyEvent(e dogma.Event)

ApplyEvent updates aggregate instance to reflect the occurrence of an event.

type ApplicationStub 

type ApplicationStub struct {
	ConfigureFunc func(dogma.ApplicationConfigurer)
}

ApplicationStub is a test implementation of dogma.Application.

func (*ApplicationStub) Configure 

func (a *ApplicationStub) Configure(c dogma.ApplicationConfigurer)

Configure describes the application's configuration to the engine.

type CommandStub 

type CommandStub[T any] struct {
	Content         T      `json:"content,omitempty"`
	ValidationError string `json:"validation_error,omitempty"`
}

CommandStub is a test implementation of dogma.Command.

func (CommandStub[T]) MessageDescription 

func (s CommandStub[T]) MessageDescription() string

MessageDescription returns a description of the command.

func (CommandStub[T]) Validate 

func (s CommandStub[T]) Validate(dogma.CommandValidationScope) error

Validate returns a non-nil error if c.Invalid is not empty.

type EventStub 

type EventStub[T any] struct {
	Content         T      `json:"content,omitempty"`
	ValidationError string `json:"validation_error,omitempty"`
}

EventStub is a test implementation of dogma.Event.

func (EventStub[T]) MessageDescription 

func (s EventStub[T]) MessageDescription() string

MessageDescription returns a description of the command.

func (EventStub[T]) Validate 

func (s EventStub[T]) Validate(dogma.EventValidationScope) error

Validate returns a non-nil error if c.Invalid is not empty.

type IntegrationMessageHandlerStub 

type IntegrationMessageHandlerStub struct {
	ConfigureFunc     func(dogma.IntegrationConfigurer)
	HandleCommandFunc func(context.Context, dogma.IntegrationCommandScope, dogma.Command) error
}

IntegrationMessageHandlerStub is a test implementation of dogma.IntegrationMessageHandler.

func (*IntegrationMessageHandlerStub) Configure 

func (h *IntegrationMessageHandlerStub) Configure(c dogma.IntegrationConfigurer)

Configure describes the handler's configuration to the engine.

func (*IntegrationMessageHandlerStub) HandleCommand 

func (h *IntegrationMessageHandlerStub) HandleCommand(
	ctx context.Context,
	s dogma.IntegrationCommandScope,
	c dogma.Command,
) error

HandleCommand handles a command, typically by invoking some external API.

type ProcessMessageHandlerStub 

type ProcessMessageHandlerStub struct {
	NewFunc                  func() dogma.ProcessRoot
	ConfigureFunc            func(dogma.ProcessConfigurer)
	RouteEventToInstanceFunc func(context.Context, dogma.Event) (string, bool, error)
	HandleEventFunc          func(context.Context, dogma.ProcessRoot, dogma.ProcessEventScope, dogma.Event) error
	HandleTimeoutFunc        func(context.Context, dogma.ProcessRoot, dogma.ProcessTimeoutScope, dogma.Timeout) error
}

ProcessMessageHandlerStub is a test implementation of dogma.ProcessMessageHandler.

func (*ProcessMessageHandlerStub) Configure 

func (h *ProcessMessageHandlerStub) Configure(c dogma.ProcessConfigurer)

Configure describes the handler's configuration to the engine.

func (*ProcessMessageHandlerStub) HandleEvent 

func (h *ProcessMessageHandlerStub) HandleEvent(
	ctx context.Context,
	r dogma.ProcessRoot,
	s dogma.ProcessEventScope,
	e dogma.Event,
) error

HandleEvent begins or continues the process in response to an event.

func (*ProcessMessageHandlerStub) HandleTimeout 

func (h *ProcessMessageHandlerStub) HandleTimeout(
	ctx context.Context,
	r dogma.ProcessRoot,
	s dogma.ProcessTimeoutScope,
	t dogma.Timeout,
) error

HandleTimeout continues the process in response to a timeout.

func (*ProcessMessageHandlerStub) New 

func (h *ProcessMessageHandlerStub) New() dogma.ProcessRoot

New returns a process root instance in its initial state.

func (*ProcessMessageHandlerStub) RouteEventToInstance 

func (h *ProcessMessageHandlerStub) RouteEventToInstance(
	ctx context.Context,
	e dogma.Event,
) (string, bool, error)

RouteEventToInstance returns the ID of the instance that handles a specific event.

type ProcessRootStub 

type ProcessRootStub struct {
	Value any `json:"value,omitempty"`
}

ProcessRootStub is a test implementation of dogma.ProcessRoot.

type ProjectionMessageHandlerStub 

type ProjectionMessageHandlerStub struct {
	ConfigureFunc       func(dogma.ProjectionConfigurer)
	HandleEventFunc     func(context.Context, []byte, []byte, []byte, dogma.ProjectionEventScope, dogma.Event) (bool, error)
	ResourceVersionFunc func(context.Context, []byte) ([]byte, error)
	CloseResourceFunc   func(context.Context, []byte) error
	CompactFunc         func(context.Context, dogma.ProjectionCompactScope) error
}

ProjectionMessageHandlerStub is a test implementation of dogma.ProjectionMessageHandler.

func (*ProjectionMessageHandlerStub) CloseResource 

func (h *ProjectionMessageHandlerStub) CloseResource(
	ctx context.Context,
	r []byte,
) error

CloseResource informs the handler that the engine has no further use for a resource.

func (*ProjectionMessageHandlerStub) Compact 

func (h *ProjectionMessageHandlerStub) Compact(
	ctx context.Context,
	s dogma.ProjectionCompactScope,
) error

Compact attempts to reduce the size of the projection.

func (*ProjectionMessageHandlerStub) Configure 

func (h *ProjectionMessageHandlerStub) Configure(c dogma.ProjectionConfigurer)

Configure describes the handler's configuration to the engine.

func (*ProjectionMessageHandlerStub) HandleEvent 

func (h *ProjectionMessageHandlerStub) HandleEvent(
	ctx context.Context,
	r, c, n []byte,
	s dogma.ProjectionEventScope,
	e dogma.Event,
) (bool, error)

HandleEvent updates the projection to reflect the occurrence of an event.

func (*ProjectionMessageHandlerStub) ResourceVersion 

func (h *ProjectionMessageHandlerStub) ResourceVersion(
	ctx context.Context,
	r []byte,
) ([]byte, error)

ResourceVersion returns the current version of a resource.

type TimeoutStub 

type TimeoutStub[T any] struct {
	Content         T      `json:"content,omitempty"`
	ValidationError string `json:"validation_error,omitempty"`
}

TimeoutStub is a test implementation of dogma.Test.

func (TimeoutStub[T]) MessageDescription 

func (s TimeoutStub[T]) MessageDescription() string

MessageDescription returns a description of the command.

func (TimeoutStub[T]) Validate 

func (s TimeoutStub[T]) Validate(dogma.TimeoutValidationScope) error

Validate returns a non-nil error if c.Invalid is not empty.

type TypeA 

type TypeA string

TypeA is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeB 

type TypeB string

TypeB is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeC 

type TypeC string

TypeC is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeD 

type TypeD string

TypeD is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeE 

type TypeE string

TypeE is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeF 

type TypeF string

TypeF is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeG 

type TypeG string

TypeG is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeH 

type TypeH string

TypeH is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeI 

type TypeI string

TypeI is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeJ 

type TypeJ string

TypeJ is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeK 

type TypeK string

TypeK is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeL 

type TypeL string

TypeL is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeM 

type TypeM string

TypeM is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeN 

type TypeN string

TypeN is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeO 

type TypeO string

TypeO is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeP 

type TypeP string

TypeP is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeQ 

type TypeQ string

TypeQ is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeR 

type TypeR string

TypeR is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeS 

type TypeS string

TypeS is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeT 

type TypeT string

TypeT is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeU 

type TypeU string

TypeU is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeV 

type TypeV string

TypeV is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeW 

type TypeW string

TypeW is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeX 

type TypeX string

TypeX is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeY 

type TypeY string

TypeY is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

type TypeZ 

type TypeZ string

TypeZ is a named type used as a type parameter for CommandStub, EventStub and TimeoutStub to provide a unique type.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.