func TestTypedActivityWorker(t *testing.T) {
if os.Getenv("AWS_ACCESS_KEY_ID") == "" || os.Getenv("AWS_SECRET_ACCESS_KEY") == "" {
Log.Printf("WARNING: NO AWS CREDS SPECIFIED, SKIPPING MIGRATIONS TEST")
return
}
config := &aws.Config{
Credentials: credentials.NewEnvCredentials(),
Region: aws.String("us-east-1"),
}
client := swf.New(session.New(config))
domain := "worker-test-domain"
req := swf.RegisterDomainInput{
Name: aws.String(domain),
Description: aws.String("test domain"),
WorkflowExecutionRetentionPeriodInDays: aws.String("30"),
}
d := migrator.DomainMigrator{
RegisteredDomains: []swf.RegisterDomainInput{req},
Client: client,
}
d.Migrate()
workflow := "worker-test-workflow"
version := "worker-test-workflow-version"
wreq := swf.RegisterWorkflowTypeInput{
Name: &workflow,
Description: aws.String("test workflow migration"),
Version: &version,
Domain: aws.String(domain),
DefaultTaskList: &swf.TaskList{Name: S("worker-fsm")},
}
w := migrator.WorkflowTypeMigrator{
RegisteredWorkflowTypes: []swf.RegisterWorkflowTypeInput{wreq},
Client: client,
}
w.Migrate()
one := swf.RegisterActivityTypeInput{
Name: aws.String("one"),
Description: aws.String("worker test activity 1"),
Version: aws.String("one"),
Domain: aws.String(domain),
}
two := swf.RegisterActivityTypeInput{
Name: aws.String("two"),
Description: aws.String("worker test activity 2"),
Version: aws.String("two"),
Domain: aws.String(domain),
}
a := migrator.ActivityTypeMigrator{
RegisteredActivityTypes: []swf.RegisterActivityTypeInput{one, two},
Client: client,
}
a.Migrate()
taskList := "aTaskListSharedBetweenTaskOneAndTwo"
worker := &ActivityWorker{
Domain: domain,
Serializer: fsm.JSONStateSerializer{},
TaskList: taskList,
SWF: client,
Identity: "test-activity-worker",
}
//This is where the actual worker config code is
var activities Activities
activities = MockActivities{}
worker.AddHandler(NewActivityHandler("one", activities.Task1))
worker.AddHandler(NewActivityHandler("two", activities.Task2))
go worker.Start()
//yep thats all the worker config code
done := make(chan struct{})
go NewWorkerFSM(client, done).Start()
_, err := client.StartWorkflowExecution(&swf.StartWorkflowExecutionInput{
Domain: S(domain),
WorkflowId: S("worker-test"),
WorkflowType: &swf.WorkflowType{Name: S(workflow), Version: S(version)},
Input: S("{}"),
ExecutionStartToCloseTimeout: S("90"),
TaskStartToCloseTimeout: S("10"),
ChildPolicy: S("ABANDON"),
})
if err != nil {
t.Fatal(err)
}
select {
case <-done:
case <-time.After(1 * time.Minute):
t.Fatal("One Minute Elapsed, not done with workflow")
}
}
func TestClient(t *testing.T) {
if os.Getenv("AWS_ACCESS_KEY_ID") == "" || os.Getenv("AWS_SECRET_ACCESS_KEY") == "" {
Log.Printf("WARNING: NO AWS CREDS SPECIFIED, SKIPPING MIGRATIONS TEST")
return
}
config := &aws.Config{
Credentials: credentials.NewEnvCredentials(),
Region: aws.String("us-east-1"),
}
client := swf.New(session.New(config))
req := swf.RegisterDomainInput{
Name: aws.String("client-test"),
Description: aws.String("test domain"),
WorkflowExecutionRetentionPeriodInDays: aws.String("30"),
}
d := migrator.DomainMigrator{
RegisteredDomains: []swf.RegisterDomainInput{req},
Client: client,
}
d.Migrate()
wreq := swf.RegisterWorkflowTypeInput{
Name: aws.String("client-test"),
Description: aws.String("test workflow migration"),
Version: aws.String("1"),
Domain: aws.String("client-test"),
}
w := migrator.WorkflowTypeMigrator{
RegisteredWorkflowTypes: []swf.RegisterWorkflowTypeInput{wreq},
Client: client,
}
w.Migrate()
fsm := &FSM{
Domain: "client-test",
Name: "client-test",
DataType: TestData{},
Serializer: JSONStateSerializer{},
SystemSerializer: JSONStateSerializer{},
AllowPanics: false,
}
fsm.AddInitialState(&FSMState{Name: "initial",
Decider: func(ctx *FSMContext, h *swf.HistoryEvent, data interface{}) Outcome {
if *h.EventType == swf.EventTypeWorkflowExecutionSignaled {
d := data.(*TestData)
d.States = append(d.States, *h.WorkflowExecutionSignaledEventAttributes.SignalName)
}
return ctx.Stay(data, ctx.EmptyDecisions())
},
})
fsmClient := NewFSMClient(fsm, client)
workflow := uuid.New()
testData := uuid.New()
startTemplate := swf.StartWorkflowExecutionInput{
WorkflowType: &swf.WorkflowType{Name: aws.String("client-test"), Version: aws.String("1")},
ExecutionStartToCloseTimeout: aws.String("120"),
TaskStartToCloseTimeout: aws.String("120"),
ChildPolicy: aws.String("ABANDON"),
TaskList: &swf.TaskList{Name: aws.String("task-list")},
}
_, err := fsmClient.Start(startTemplate, workflow, &TestData{States: []string{testData}})
if err != nil {
t.Fatal(err)
}
state, data, err := fsmClient.GetState(workflow)
if err != nil {
t.Fatal(err)
}
if data.(*TestData).States[0] != testData {
t.Fatal(data)
}
if state != "initial" {
t.Fatal("not in initial")
}
found := false
err = fsmClient.WalkOpenWorkflowInfos(&swf.ListOpenWorkflowExecutionsInput{}, func(infos *swf.WorkflowExecutionInfos) error {
for _, info := range infos.ExecutionInfos {
if *info.Execution.WorkflowId == workflow {
found = true
return StopWalking()
}
}
return nil
})
if err != nil {
t.Fatal(err)
}
if !found {
t.Fatalf("%s not found", workflow)
}
exec, err := fsmClient.FindLatestByWorkflowID(workflow)
if err != nil {
t.Fatal(err)
}
segments := []HistorySegment{}
seg := fsmClient.NewHistorySegmentor()
seg.OnSegment(func(segment HistorySegment) {
segments = append(segments, segment)
})
seg.OnError(func(err error) {
t.Fatal(err)
})
err = fsmClient.GetWorkflowExecutionHistoryPages(exec, seg.FromPage)
if err != nil {
t.Fatal(err)
}
if length := len(segments); length != 2 {
t.Fatalf("segments length: %d \n%#v", length, segments)
}
if name := *segments[1].State.Name; name != "initial" {
t.Fatalf("segments[1].State.Name: %s ", name)
}
if version := *segments[1].State.Version; version != 0 {
t.Fatalf("segments[1].State.Version: %d ", version)
}
if id := *segments[1].State.ID; id != 1 {
t.Fatalf("segments[1].State.ID: %d ", id)
}
}