lookup friendly name when invoking (#212)

* lookup friendly name when invoking

* fix mock

internal_activity.go

@@ -215,6 +215,10 @@ func getValidatedActivityFunction(f interface{}, args []interface{}) (*ActivityT
 			"Invalid type 'f' parameter provided, it can be either activity function or name of the activity: %v", f)
 	}
 
+	if alias, ok := getHostEnvironment().getActivityAlias(fnName); ok {
+		fnName = alias
+	}
+
 	input, err := getHostEnvironment().encodeArgs(args)
 	if err != nil {
 		return nil, nil, err

internal_workflow.go

@@ -935,6 +935,10 @@ func getValidatedWorkerFunction(workflowFunc interface{}, args []interface{}) (*
 			workflowFunc)
 	}
 
+	if alias, ok := getHostEnvironment().getWorkflowAlias(fnName); ok {
+		fnName = alias
+	}
+
 	input, err := getHostEnvironment().encodeArgs(args)
 	if err != nil {
 		return nil, nil, err

internal_workflow_testsuite_test.go

@@ -580,7 +580,7 @@ func (s *WorkflowTestSuiteUnitTest) Test_ChildWorkflow_Listener() {
 	s.NoError(env.GetWorkflowResult(&actualResult))
 	s.Equal("hello_activity hello_world", actualResult)
 	s.Equal("hello_world", childWorkflowResult)
-	s.Equal(getFunctionName(testWorkflowHello), childWorkflowName)
+	s.Equal("testWorkflowHello", childWorkflowName)
 }
 
 func (s *WorkflowTestSuiteUnitTest) Test_ChildWorkflow_Clock() {
@@ -732,23 +732,23 @@ func (s *WorkflowTestSuiteUnitTest) Test_MockWorkflowWait() {
 
 	// no delay to the mock call, workflow should return no error
 	env := s.NewTestWorkflowEnvironment()
-	env.OnWorkflow(testWorkflowHello, mock.Anything, mock.Anything).Return("hello_mock_delayed", nil).Once()
+	env.OnWorkflow(testWorkflowHello, mock.Anything).Return("hello_mock_delayed", nil).Once()
 	env.ExecuteWorkflow(workflowFn)
 	s.True(env.IsWorkflowCompleted())
 	s.NoError(env.GetWorkflowError())
 	env.AssertExpectations(s.T())
 
 	// delay 10 minutes, which is shorter than the 1 hour timer, so workflow should return no error.
 	env = s.NewTestWorkflowEnvironment()
-	env.OnWorkflow(testWorkflowHello, mock.Anything, mock.Anything).After(time.Minute*10).Return("hello_mock_delayed", nil).Once()
+	env.OnWorkflow(testWorkflowHello, mock.Anything).After(time.Minute*10).Return("hello_mock_delayed", nil).Once()
 	env.ExecuteWorkflow(workflowFn)
 	s.True(env.IsWorkflowCompleted())
 	s.NoError(env.GetWorkflowError())
 	env.AssertExpectations(s.T())
 
 	// delay 2 hours, which is longer than the 1 hour timer, and workflow should return error.
 	env = s.NewTestWorkflowEnvironment()
-	env.OnWorkflow(testWorkflowHello, mock.Anything, mock.Anything).After(time.Hour*2).Return("hello_mock_delayed", nil).Once()
+	env.OnWorkflow(testWorkflowHello, mock.Anything).After(time.Hour*2).Return("hello_mock_delayed", nil).Once()
 	env.ExecuteWorkflow(workflowFn)
 	s.True(env.IsWorkflowCompleted())
 	s.Error(env.GetWorkflowError())
@@ -827,23 +827,23 @@ func (s *WorkflowTestSuiteUnitTest) Test_ChildWithChild() {
 
 	// no delay to the mock call, workflow should return no error
 	env := s.NewTestWorkflowEnvironment()
-	env.OnWorkflow(testWorkflowHello, mock.Anything, mock.Anything).Return("hello_mock_delayed", nil).Once()
+	env.OnWorkflow(testWorkflowHello, mock.Anything).Return("hello_mock_delayed", nil).Once()
 	env.ExecuteWorkflow(workflowFn)
 	s.True(env.IsWorkflowCompleted())
 	s.NoError(env.GetWorkflowError())
 	env.AssertExpectations(s.T())
 
 	// delay 10 minutes, which is shorter than the 1 hour timer, so workflow should return no error.
 	env = s.NewTestWorkflowEnvironment()
-	env.OnWorkflow(testWorkflowHello, mock.Anything, mock.Anything).After(time.Minute*10).Return("hello_mock_delayed", nil).Once()
+	env.OnWorkflow(testWorkflowHello, mock.Anything).After(time.Minute*10).Return("hello_mock_delayed", nil).Once()
 	env.ExecuteWorkflow(workflowFn)
 	s.True(env.IsWorkflowCompleted())
 	s.NoError(env.GetWorkflowError())
 	env.AssertExpectations(s.T())
 
 	// delay 2 hours, which is longer than the 1 hour timer, and workflow should return error.
 	env = s.NewTestWorkflowEnvironment()
-	env.OnWorkflow(testWorkflowHello, mock.Anything, mock.Anything).After(time.Hour*2).Return("hello_mock_delayed", nil).Once()
+	env.OnWorkflow(testWorkflowHello, mock.Anything).After(time.Hour*2).Return("hello_mock_delayed", nil).Once()
 	env.ExecuteWorkflow(workflowFn)
 	s.True(env.IsWorkflowCompleted())
 	s.Error(env.GetWorkflowError())
@@ -931,3 +931,66 @@ func (s *WorkflowTestSuiteUnitTest) Test_ActivityWithThriftTypes() {
 	}
 	s.EqualValues(expectedValues, actualValues)
 }
+
+func (s *WorkflowTestSuiteUnitTest) Test_ActivityFriendlyName() {
+	activityFn := func(msg string) (string, error) {
+		return "hello_" + msg, nil
+	}
+
+	workflowFn := func(ctx Context) error {
+		ctx = WithActivityOptions(ctx, s.activityOptions)
+		var result string
+		err := ExecuteActivity(ctx, activityFn, "friendly_name").Get(ctx, &result)
+		if err != nil {
+			return err
+		}
+		err = ExecuteActivity(ctx, "foo", "friendly_name").Get(ctx, &result)
+		return err
+	}
+
+	RegisterActivityWithOptions(activityFn, RegisterActivityOptions{Name: "foo"})
+	RegisterWorkflow(workflowFn)
+	env := s.NewTestWorkflowEnvironment()
+	var called []string
+	env.SetOnActivityStartedListener(func(activityInfo *ActivityInfo, ctx context.Context, args EncodedValues) {
+		called = append(called, activityInfo.ActivityType.Name)
+	})
+
+	env.ExecuteWorkflow(workflowFn)
+
+	s.True(env.IsWorkflowCompleted())
+	s.NoError(env.GetWorkflowError())
+	s.Equal(2, len(called))
+	s.Equal("foo", called[0])
+	s.Equal("foo", called[1])
+}
+
+func (s *WorkflowTestSuiteUnitTest) Test_WorkflowFriendlyName() {
+
+	workflowFn := func(ctx Context) error {
+		cwo := ChildWorkflowOptions{ExecutionStartToCloseTimeout: time.Hour /* this is currently ignored by test suite */}
+		ctx = WithChildWorkflowOptions(ctx, cwo)
+		var result string
+		err := ExecuteChildWorkflow(ctx, testWorkflowHello).Get(ctx, &result)
+		if err != nil {
+			return err
+		}
+		err = ExecuteChildWorkflow(ctx, "testWorkflowHello").Get(ctx, &result)
+		return err
+	}
+
+	RegisterWorkflow(workflowFn)
+	env := s.NewTestWorkflowEnvironment()
+	var called []string
+	env.SetOnChildWorkflowStartedListener(func(workflowInfo *WorkflowInfo, ctx Context, args EncodedValues) {
+		called = append(called, workflowInfo.WorkflowType.Name)
+	})
+
+	env.ExecuteWorkflow(workflowFn)
+
+	s.True(env.IsWorkflowCompleted())
+	s.NoError(env.GetWorkflowError())
+	s.Equal(2, len(called))
+	s.Equal("testWorkflowHello", called[0])
+	s.Equal("testWorkflowHello", called[1])
+}

workflow_testsuite.go

@@ -130,7 +130,11 @@ func (t *TestWorkflowEnvironment) OnActivity(activity interface{}, args ...inter
 		if err := validateFnFormat(fnType, false); err != nil {
 			panic(err)
 		}
-		call = t.Mock.On(getFunctionName(activity), args...)
+		fnName := getFunctionName(activity)
+		if alias, ok := getHostEnvironment().getActivityAlias(fnName); ok {
+			fnName = alias
+		}
+		call = t.Mock.On(fnName, args...)
 
 	case reflect.String:
 		call = t.Mock.On(activity.(string), args...)
@@ -163,7 +167,11 @@ func (t *TestWorkflowEnvironment) OnWorkflow(workflow interface{}, args ...inter
 		if err := validateFnFormat(fnType, true); err != nil {
 			panic(err)
 		}
-		call = t.Mock.On(getFunctionName(workflow), args...)
+		fnName := getFunctionName(workflow)
+		if alias, ok := getHostEnvironment().getWorkflowAlias(fnName); ok {
+			fnName = alias
+		}
+		call = t.Mock.On(fnName, args...)
 	case reflect.String:
 		call = t.Mock.On(workflow.(string), args...)
 	default: