testfixtures

Documentation

Index

• Constants
• Variables
• func DeepCopy(events *armadaevents.EventSequence_Event) (*armadaevents.EventSequence_Event, error)
• func JobSetCancelRequestedWithStateFilter(states ...armadaevents.JobState) *armadaevents.EventSequence_Event
• func NewEventSequence(event ...*armadaevents.EventSequence_Event) *armadaevents.EventSequence

Constants

const (
	JobIdString                  = "01f3j0g1md4qx7z5qb148qnh4r"
	RunIdString                  = "123e4567-e89b-12d3-a456-426614174000"
	PartitionMarkerGroupIdString = "223e4567-e89b-12d3-a456-426614174000"
)

Standard Set of events for common tests

const (
	JobSetName                 = "testJobset"
	ExecutorId                 = "testCluster"
	NodeName                   = "testNode"
	PodName                    = "test-pod"
	Queue                      = "test-Queue"
	UserId                     = "testUser"
	Namespace                  = "test-ns"
	Priority                   = 3
	NewPriority                = 4
	PodNumber                  = 6
	ExitCode                   = 322
	ErrMsg                     = "sample error message"
	LeaseReturnedMsg           = "lease returned error message"
	TerminatedMsg              = "test pod terminated message"
	UnschedulableMsg           = "test pod is unschedulable"
	PartitionMarkerPartitionId = 456
)

Variables

var (
	JobIdProto, _               = armadaevents.ProtoUuidFromUlidString(JobIdString)
	RunIdProto                  = armadaevents.ProtoUuidFromUuid(uuid.MustParse(RunIdString))
	PartitionMarkerGroupIdProto = armadaevents.ProtoUuidFromUuid(uuid.MustParse(PartitionMarkerGroupIdString))
	JobIdUuid                   = armadaevents.UuidFromProtoUuid(JobIdProto)
	RunIdUuid                   = armadaevents.UuidFromProtoUuid(RunIdProto)
	PartitionMarkerGroupIdUuid  = armadaevents.UuidFromProtoUuid(PartitionMarkerGroupIdProto)
	PriorityClassName           = "test-priority"
	PriorityClassValue          = int32(100)
	PriorityClasses             = map[string]types.PriorityClass{PriorityClassName: {Priority: PriorityClassValue}}
	Groups                      = []string{"group1", "group2"}
	NodeSelector                = map[string]string{"foo": "bar"}
	Affinity                    = &v1.Affinity{
		NodeAffinity: &v1.NodeAffinity{
			RequiredDuringSchedulingIgnoredDuringExecution: &v1.NodeSelector{
				NodeSelectorTerms: []v1.NodeSelectorTerm{
					{
						MatchExpressions: []v1.NodeSelectorRequirement{
							{
								Key:      "noode-name",
								Operator: v1.NodeSelectorOpNotIn,
								Values:   []string{"node-1"},
							},
						},
					},
				},
			},
		},
	}
	Tolerations = []v1.Toleration{{
		Key:      "fish",
		Operator: "exists",
	}}
	BaseTime, _ = time.Parse("2006-01-02T15:04:05.000Z", "2022-03-01T15:04:05.000Z")
)

var Assigned = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobRunAssigned{
		JobRunAssigned: &armadaevents.JobRunAssigned{
			RunId: RunIdProto,
			JobId: JobIdProto,
			ResourceInfos: []*armadaevents.KubernetesResourceInfo{
				{
					ObjectMeta: &armadaevents.ObjectMeta{
						KubernetesId: RunIdString,
						Name:         PodName,
						Namespace:    Namespace,
						ExecutorId:   ExecutorId,
					},
					Info: &armadaevents.KubernetesResourceInfo_PodInfo{
						PodInfo: &armadaevents.PodInfo{
							PodNumber: PodNumber,
						},
					},
				},
			},
		},
	},
}

var JobCancelRequested = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_CancelJob{
		CancelJob: &armadaevents.CancelJob{
			JobId: JobIdProto,
		},
	},
}

var JobCancelled = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_CancelledJob{
		CancelledJob: &armadaevents.CancelledJob{
			JobId: JobIdProto,
		},
	},
}

var JobFailed = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobErrors{
		JobErrors: &armadaevents.JobErrors{
			JobId: JobIdProto,
			Errors: []*armadaevents.Error{
				{
					Terminal: true,
					Reason: &armadaevents.Error_PodError{
						PodError: &armadaevents.PodError{
							Message:  ErrMsg,
							NodeName: NodeName,
							ContainerErrors: []*armadaevents.ContainerError{
								{ExitCode: ExitCode},
							},
						},
					},
				},
			},
		},
	},
}

var JobLeaseReturned = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobRunErrors{
		JobRunErrors: &armadaevents.JobRunErrors{
			JobId: JobIdProto,
			RunId: RunIdProto,
			Errors: []*armadaevents.Error{
				{
					Terminal: true,
					Reason: &armadaevents.Error_PodLeaseReturned{
						PodLeaseReturned: &armadaevents.PodLeaseReturned{
							ObjectMeta: &armadaevents.ObjectMeta{
								ExecutorId: ExecutorId,
							},
							Message: LeaseReturnedMsg,
						},
					},
				},
			},
		},
	},
}

var JobPreempted = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobErrors{
		JobErrors: &armadaevents.JobErrors{
			JobId: JobIdProto,
			Errors: []*armadaevents.Error{
				{
					Terminal: true,
					Reason: &armadaevents.Error_JobRunPreemptedError{
						JobRunPreemptedError: &armadaevents.JobRunPreemptedError{},
					},
				},
			},
		},
	},
}

var JobPreemptionRequested = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobPreemptionRequested{
		JobPreemptionRequested: &armadaevents.JobPreemptionRequested{
			JobId: JobIdProto,
		},
	},
}

var JobReprioritiseRequested = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_ReprioritiseJob{
		ReprioritiseJob: &armadaevents.ReprioritiseJob{
			JobId:    JobIdProto,
			Priority: NewPriority,
		},
	},
}

var JobReprioritised = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_ReprioritisedJob{
		ReprioritisedJob: &armadaevents.ReprioritisedJob{
			JobId:    JobIdProto,
			Priority: NewPriority,
		},
	},
}

var JobRequeued = &armadaevents.EventSequence_Event{
	Created: &BaseTime,
	Event: &armadaevents.EventSequence_Event_JobRequeued{
		JobRequeued: &armadaevents.JobRequeued{
			JobId: JobIdProto,
			SchedulingInfo: &schedulerobjects.JobSchedulingInfo{
				Lifetime:        0,
				AtMostOnce:      true,
				Preemptible:     true,
				ConcurrencySafe: true,
				Version:         0,
				ObjectRequirements: []*schedulerobjects.ObjectRequirements{
					{
						Requirements: &schedulerobjects.ObjectRequirements_PodRequirements{
							PodRequirements: &schedulerobjects.PodRequirements{
								NodeSelector:     NodeSelector,
								Tolerations:      Tolerations,
								PreemptionPolicy: "PreemptLowerPriority",
								Priority:         PriorityClassValue,
								Affinity:         Affinity,
								ResourceRequirements: v1.ResourceRequirements{
									Limits: map[v1.ResourceName]resource.Quantity{
										"memory": resource.MustParse("64Mi"),
										"cpu":    resource.MustParse("150m"),
									},
									Requests: map[v1.ResourceName]resource.Quantity{
										"memory": resource.MustParse("64Mi"),
										"cpu":    resource.MustParse("150m"),
									},
								},
							},
						},
					},
				},
			},
			UpdateSequenceNumber: 2,
		},
	},
}

var JobRunCancelled = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobRunCancelled{
		JobRunCancelled: &armadaevents.JobRunCancelled{
			RunId: RunIdProto,
			JobId: JobIdProto,
		},
	},
}

var JobRunFailed = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobRunErrors{
		JobRunErrors: &armadaevents.JobRunErrors{
			JobId: JobIdProto,
			RunId: RunIdProto,
			Errors: []*armadaevents.Error{
				{
					Terminal: true,
					Reason: &armadaevents.Error_PodError{
						PodError: &armadaevents.PodError{
							Message:  ErrMsg,
							NodeName: NodeName,
							ContainerErrors: []*armadaevents.ContainerError{
								{ExitCode: ExitCode},
							},
						},
					},
				},
			},
		},
	},
}

var JobRunPreempted = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobRunPreempted{
		JobRunPreempted: &armadaevents.JobRunPreempted{
			PreemptedJobId: JobIdProto,
			PreemptedRunId: RunIdProto,
		},
	},
}

var JobRunSucceeded = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobRunSucceeded{
		JobRunSucceeded: &armadaevents.JobRunSucceeded{
			RunId: RunIdProto,
			JobId: JobIdProto,
		},
	},
}

var JobRunTerminated = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobRunErrors{
		JobRunErrors: &armadaevents.JobRunErrors{
			JobId: JobIdProto,
			RunId: RunIdProto,
			Errors: []*armadaevents.Error{
				{
					Terminal: false,
					Reason: &armadaevents.Error_PodTerminated{
						PodTerminated: &armadaevents.PodTerminated{
							NodeName: NodeName,
							ObjectMeta: &armadaevents.ObjectMeta{
								ExecutorId: ExecutorId,
							},
							Message: TerminatedMsg,
						},
					},
				},
			},
		},
	},
}

var JobRunUnschedulable = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobRunErrors{
		JobRunErrors: &armadaevents.JobRunErrors{
			JobId: JobIdProto,
			RunId: RunIdProto,
			Errors: []*armadaevents.Error{
				{
					Terminal: false,
					Reason: &armadaevents.Error_PodUnschedulable{
						PodUnschedulable: &armadaevents.PodUnschedulable{
							NodeName: NodeName,
							ObjectMeta: &armadaevents.ObjectMeta{
								ExecutorId: ExecutorId,
							},
							Message: UnschedulableMsg,
						},
					},
				},
			},
		},
	},
}

var JobSetCancelRequested = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_CancelJobSet{
		CancelJobSet: &armadaevents.CancelJobSet{},
	},
}

var JobSetReprioritiseRequested = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_ReprioritiseJobSet{
		ReprioritiseJobSet: &armadaevents.ReprioritiseJobSet{
			Priority: NewPriority,
		},
	},
}

var JobSucceeded = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobSucceeded{
		JobSucceeded: &armadaevents.JobSucceeded{
			JobId: JobIdProto,
		},
	},
}

var JobValidated = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobValidated{
		JobValidated: &armadaevents.JobValidated{
			JobId: JobIdProto,
		},
	},
}

var LeaseReturned = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobRunErrors{
		JobRunErrors: &armadaevents.JobRunErrors{
			JobId: JobIdProto,
			RunId: RunIdProto,
			Errors: []*armadaevents.Error{
				{
					Terminal: true,
					Reason: &armadaevents.Error_PodLeaseReturned{
						PodLeaseReturned: &armadaevents.PodLeaseReturned{
							Message:      LeaseReturnedMsg,
							RunAttempted: true,
						},
					},
				},
			},
		},
	},
}

var Leased = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobRunLeased{
		JobRunLeased: &armadaevents.JobRunLeased{
			RunId:                  RunIdProto,
			JobId:                  JobIdProto,
			ExecutorId:             ExecutorId,
			NodeId:                 NodeName,
			HasScheduledAtPriority: true,
			ScheduledAtPriority:    15,
			UpdateSequenceNumber:   1,
			PodRequirementsOverlay: &schedulerobjects.PodRequirements{
				Tolerations: []v1.Toleration{
					{
						Key:    "whale",
						Value:  "true",
						Effect: v1.TaintEffectNoSchedule,
					},
				},
				Priority: 15,
			},
		},
	},
}

var PartitionMarker = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_PartitionMarker{
		PartitionMarker: &armadaevents.PartitionMarker{
			GroupId:   PartitionMarkerGroupIdProto,
			Partition: PartitionMarkerPartitionId,
		},
	},
}

var Running = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_JobRunRunning{
		JobRunRunning: &armadaevents.JobRunRunning{
			RunId: RunIdProto,
			JobId: JobIdProto,
			ResourceInfos: []*armadaevents.KubernetesResourceInfo{
				{
					Info: &armadaevents.KubernetesResourceInfo_PodInfo{
						PodInfo: &armadaevents.PodInfo{
							NodeName:  NodeName,
							PodNumber: PodNumber,
						},
					},
				},
			},
		},
	},
}

var ScheduledAtPriority = int32(15)

var Submit = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_SubmitJob{
		SubmitJob: &armadaevents.SubmitJob{
			JobId:           JobIdProto,
			Priority:        Priority,
			AtMostOnce:      true,
			Preemptible:     true,
			ConcurrencySafe: true,
			ObjectMeta: &armadaevents.ObjectMeta{
				Namespace: Namespace,
				Name:      "test-job",
			},
			MainObject: &armadaevents.KubernetesMainObject{
				ObjectMeta: &armadaevents.ObjectMeta{
					Annotations: map[string]string{
						"foo":                            "bar",
						configuration.FailFastAnnotation: "true",
					},
				},
				Object: &armadaevents.KubernetesMainObject_PodSpec{
					PodSpec: &armadaevents.PodSpecWithAvoidList{
						PodSpec: &v1.PodSpec{
							NodeSelector:      NodeSelector,
							Tolerations:       Tolerations,
							PriorityClassName: PriorityClassName,
							Containers: []v1.Container{
								{
									Name:    "container1",
									Image:   "alpine:latest",
									Command: []string{"myprogram.sh"},
									Args:    []string{"foo", "bar"},
									Resources: v1.ResourceRequirements{
										Limits: map[v1.ResourceName]resource.Quantity{
											"memory": resource.MustParse("64Mi"),
											"cpu":    resource.MustParse("150m"),
										},
										Requests: map[v1.ResourceName]resource.Quantity{
											"memory": resource.MustParse("64Mi"),
											"cpu":    resource.MustParse("150m"),
										},
									},
								},
							},
						},
					},
				},
			},
		},
	},
}

var SubmitDuplicate = &armadaevents.EventSequence_Event{
	Created: &testfixtures.BaseTime,
	Event: &armadaevents.EventSequence_Event_SubmitJob{
		SubmitJob: &armadaevents.SubmitJob{
			IsDuplicate:     true,
			JobId:           JobIdProto,
			Priority:        Priority,
			AtMostOnce:      true,
			Preemptible:     true,
			ConcurrencySafe: true,
			ObjectMeta: &armadaevents.ObjectMeta{
				Namespace: Namespace,
				Name:      "test-job",
			},
			MainObject: &armadaevents.KubernetesMainObject{
				Object: &armadaevents.KubernetesMainObject_PodSpec{
					PodSpec: &armadaevents.PodSpecWithAvoidList{
						PodSpec: &v1.PodSpec{
							NodeSelector:      NodeSelector,
							Tolerations:       Tolerations,
							PriorityClassName: PriorityClassName,
							Containers: []v1.Container{
								{
									Name:    "container1",
									Image:   "alpine:latest",
									Command: []string{"myprogram.sh"},
									Args:    []string{"foo", "bar"},
									Resources: v1.ResourceRequirements{
										Limits: map[v1.ResourceName]resource.Quantity{
											"memory": resource.MustParse("64Mi"),
											"cpu":    resource.MustParse("150m"),
										},
										Requests: map[v1.ResourceName]resource.Quantity{
											"memory": resource.MustParse("64Mi"),
											"cpu":    resource.MustParse("150m"),
										},
									},
								},
							},
						},
					},
				},
			},
		},
	},
}

Functions

func DeepCopy

func DeepCopy(events *armadaevents.EventSequence_Event) (*armadaevents.EventSequence_Event, error)

func JobSetCancelRequestedWithStateFilter

func JobSetCancelRequestedWithStateFilter(states ...armadaevents.JobState) *armadaevents.EventSequence_Event

func NewEventSequence

func NewEventSequence(event ...*armadaevents.EventSequence_Event) *armadaevents.EventSequence