github.com/TIBCOSoftware/flogo-lib@v0.5.9/engine/runner/direct_test.go (about)

     1  package runner
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"testing"
     7  
     8  	"github.com/TIBCOSoftware/flogo-lib/core/action"
     9  	"github.com/TIBCOSoftware/flogo-lib/core/data"
    10  	"github.com/stretchr/testify/assert"
    11  	"github.com/stretchr/testify/mock"
    12  )
    13  
    14  type MockAsyncAction struct {
    15  	mock.Mock
    16  }
    17  
    18  func (m *MockAsyncAction) IOMetadata() *data.IOMetadata {
    19  	return nil
    20  }
    21  
    22  func (m *MockAsyncAction) Config() *action.Config {
    23  	return nil
    24  }
    25  
    26  func (m *MockAsyncAction) Metadata() *action.Metadata {
    27  	return nil
    28  }
    29  
    30  func (m *MockAsyncAction) Run(context context.Context, inputs map[string]*data.Attribute, handler action.ResultHandler) error {
    31  	args := m.Called(context, inputs, handler)
    32  	if handler != nil {
    33  		dataAttr, _ := data.NewAttribute("data", data.TypeString, "mock")
    34  		codeAttr, _ := data.NewAttribute("code", data.TypeInteger, 200)
    35  		resultData := map[string]*data.Attribute{
    36  			"data": dataAttr,
    37  			"code": codeAttr,
    38  		}
    39  		handler.HandleResult(resultData, nil)
    40  		handler.Done()
    41  	}
    42  	return args.Error(0)
    43  }
    44  
    45  //Test that Result returns the expected values
    46  func TestResultOk(t *testing.T) {
    47  
    48  	//mockData,_ :=data.CoerceToObject("{\"data\":\"mock data \"}")
    49  	dataAttr, _ := data.NewAttribute("data", data.TypeString, "mock data")
    50  	codeAttr, _ := data.NewAttribute("code", data.TypeInteger, 1)
    51  	resultData := map[string]*data.Attribute{
    52  		"data": dataAttr,
    53  		"code": codeAttr,
    54  	}
    55  
    56  	rh := &SyncResultHandler{resultData: resultData, err: errors.New("New Error")}
    57  	data, err := rh.Result()
    58  	assert.Equal(t, 1, data["code"].Value())
    59  	assert.Equal(t, "mock data", data["data"].Value())
    60  	assert.NotNil(t, err)
    61  }
    62  
    63  //Test Direct Start method
    64  func TestDirectStartOk(t *testing.T) {
    65  	runner := NewDirect()
    66  	assert.NotNil(t, runner)
    67  	err := runner.Start()
    68  	assert.Nil(t, err)
    69  }
    70  
    71  //Test Stop method
    72  func TestDirectStopOk(t *testing.T) {
    73  	runner := NewDirect()
    74  	assert.NotNil(t, runner)
    75  	err := runner.Stop()
    76  	assert.Nil(t, err)
    77  }
    78  
    79  //Test Run method with a nil action
    80  func TestDirectRunNilAction(t *testing.T) {
    81  	runner := NewDirect()
    82  	assert.NotNil(t, runner)
    83  	_, err := runner.Execute(nil, nil, nil)
    84  	assert.NotNil(t, err)
    85  }
    86  
    87  //Test Run method with error running action
    88  func TestDirectRunErr(t *testing.T) {
    89  	runner := NewDirect()
    90  	assert.NotNil(t, runner)
    91  	// Mock Action
    92  	mockAction := new(MockAsyncAction)
    93  	mockAction.On("Run", nil, mock.AnythingOfType("map[string]*data.Attribute"), mock.AnythingOfType("*runner.SyncResultHandler")).Return(errors.New("Action Error"))
    94  	_, err := runner.Execute(nil, mockAction, nil)
    95  	assert.NotNil(t, err)
    96  }
    97  
    98  //Test Run method ok
    99  func TestDirectRunOk(t *testing.T) {
   100  	runner := NewDirect()
   101  	assert.NotNil(t, runner)
   102  	// Mock Action
   103  	mockAction := new(MockAsyncAction)
   104  
   105  	mockAction.On("Run", nil, mock.AnythingOfType("map[string]*data.Attribute"), mock.AnythingOfType("*runner.SyncResultHandler")).Return(nil)
   106  	results, err := runner.Execute(nil, mockAction, nil)
   107  	assert.Nil(t, err)
   108  	assert.NotNil(t, results)
   109  	code, ok := results["code"]
   110  	assert.True(t, ok)
   111  	data, ok := results["data"]
   112  	assert.True(t, ok)
   113  	assert.Equal(t, 200, code.Value())
   114  	assert.Equal(t, "mock", data.Value())
   115  }
   116  
   117  //Test Run method with a nil action
   118  func TestDirectRunNilActionOld(t *testing.T) {
   119  	runner := NewDirect()
   120  	assert.NotNil(t, runner)
   121  	_, err := runner.Execute(nil, nil, nil)
   122  	assert.NotNil(t, err)
   123  }
   124  
   125  //Test Run method with error running action
   126  func TestDirectRunErrOld(t *testing.T) {
   127  	runner := NewDirect()
   128  	assert.NotNil(t, runner)
   129  	// Mock Action
   130  	mockAction := new(MockAsyncAction)
   131  	mockAction.On("Run", nil, mock.AnythingOfType("map[string]*data.Attribute"), mock.AnythingOfType("*runner.SyncResultHandler")).Return(errors.New("Action Error"))
   132  	_, err := runner.Execute(nil, mockAction, nil)
   133  	assert.NotNil(t, err)
   134  }
   135  
   136  //Test Run method ok
   137  //func TestDirectRunOkOld(t *testing.T) {
   138  //	runner := NewDirect()
   139  //	assert.NotNil(t, runner)
   140  //	// Mock Action
   141  //	mockAction := new(MockAsyncAction)
   142  //
   143  //	mockAction.On("Run", nil, mock.AnythingOfType("map[string]*data.Attribute"), mock.AnythingOfType("*runner.SyncResultHandler")).Return(nil)
   144  //	code, data, err := runner.Execute(nil, mockAction,  nil)
   145  //	assert.Nil(t, err)
   146  //	assert.Equal(t, 200, code)
   147  //	assert.Equal(t, "mock", data)
   148  //}