Skip to content

Commit

Permalink
Fixed naming in test
Browse files Browse the repository at this point in the history
  • Loading branch information
@MaartendeKruijf
MaartendeKruijf committed Aug 16, 2024
1 parent b56ddf8 commit 4f242e3
Showing 1 changed file with 92 additions and 50 deletions.
142 changes: 92 additions & 50 deletions test/unittest/routes/trigger_api/tigger_api_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -40,12 +40,12 @@ func TestTriggerExecutionOfPlaybook(t *testing.T) {
mock_controller.On("NewDecomposer").Return(mock_decomposer)
playbook := cacao.Decode(byteValue)

trigger_api := trigger.New(mock_controller, mock_database_controller)
triggerApi := trigger.New(mock_controller, mock_database_controller)
recorder := httptest.NewRecorder()
trigger.Routes(app, trigger_api)
trigger.Routes(app, triggerApi)

executionId, _ := uuid.Parse("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
mock_decomposer.On("ExecuteAsync", *playbook, trigger_api.ExecutionsChannel).Return(&decomposer.ExecutionDetails{}, nil, executionId)
mock_decomposer.On("ExecuteAsync", *playbook, triggerApi.ExecutionsChannel).Return(&decomposer.ExecutionDetails{}, nil, executionId)

request, err := http.NewRequest("POST", "/trigger/playbook", bytes.NewBuffer(byteValue))
if err != nil {
Expand Down Expand Up @@ -81,9 +81,9 @@ func TestExecutionOfPlaybookById(t *testing.T) {
executionId, _ := uuid.Parse("6ba7b810-9dad-11d1-80b4-00c04fd430c8")

recorder := httptest.NewRecorder()
trigger_api := trigger.New(mock_controller, mock_database_controller)
trigger.Routes(app, trigger_api)
mock_decomposer.On("ExecuteAsync", *playbook, trigger_api.ExecutionsChannel).Return(&decomposer.ExecutionDetails{}, nil, executionId)
triggerApi := trigger.New(mock_controller, mock_database_controller)
trigger.Routes(app, triggerApi)
mock_decomposer.On("ExecuteAsync", *playbook, triggerApi.ExecutionsChannel).Return(&decomposer.ExecutionDetails{}, nil, executionId)

request, err := http.NewRequest("POST", "/trigger/playbook/1", nil)
if err != nil {
Expand Down Expand Up @@ -129,10 +129,10 @@ func TestExecutionOfPlaybookByIdWithPayloadValidVariables(t *testing.T) {
assert.Equal(t, err, nil)

recorder := httptest.NewRecorder()
trigger_api := trigger.New(mock_controller, mock_database_controller)
trigger.Routes(app, trigger_api)
triggerApi := trigger.New(mock_controller, mock_database_controller)
trigger.Routes(app, triggerApi)

mock_decomposer.On("ExecuteAsync", *playbook, trigger_api.ExecutionsChannel).Return(&decomposer.ExecutionDetails{}, nil, executionId)
mock_decomposer.On("ExecuteAsync", *playbook, triggerApi.ExecutionsChannel).Return(&decomposer.ExecutionDetails{}, nil, executionId)

request, err := http.NewRequest("POST", "/trigger/playbook/1", bytes.NewReader(json))
if err != nil {
Expand All @@ -145,9 +145,7 @@ func TestExecutionOfPlaybookByIdWithPayloadValidVariables(t *testing.T) {
mock_decomposer.AssertExpectations(t)
}

func TestExecutionOfPlaybookByIdWithPayloadInvalidVariables(t *testing.T) {

// ################################################################### Setup
func TestPlaybookByIdVariableNotInPlaybook(t *testing.T) {
jsonFile, err := os.Open("../playbook.json")
if err != nil {
fmt.Println(err)
Expand All @@ -167,93 +165,137 @@ func TestExecutionOfPlaybookByIdWithPayloadInvalidVariables(t *testing.T) {
mock_database.On("Read", "1").Return(*playbook, nil)
mock_controller.On("NewDecomposer").Return(mock_decomposer)

recorder_not_in_pb := httptest.NewRecorder()
recorder_wrong_type := httptest.NewRecorder()
recorder_not_external := httptest.NewRecorder()
trigger_api := trigger.New(mock_controller, mock_database_controller)
trigger.Routes(app, trigger_api)
recorder := httptest.NewRecorder()
triggerApi := trigger.New(mock_controller, mock_database_controller)

// ################################################################### Var not in playbook
trigger.Routes(app, triggerApi)
var_not_in_playbook := cacao.Variable{
Name: "__not_in_playbook__",
Type: cacao.VariableTypeString,
}
variables_not_in_playbook := cacao.NewVariables(var_not_in_playbook)
variablesNotInPlaybook := cacao.NewVariables(var_not_in_playbook)

json_not_in_pb, err := json.Marshal(variables_not_in_playbook)
jsonNotInPlaybook, err := json.Marshal(variablesNotInPlaybook)
assert.Equal(t, err, nil)

request_not_in_pb, err := http.NewRequest("POST", "/trigger/playbook/1", bytes.NewReader(json_not_in_pb))
requestNotInPlaybook, err := http.NewRequest("POST", "/trigger/playbook/1", bytes.NewReader(jsonNotInPlaybook))
if err != nil {
t.Fail()
}
app.ServeHTTP(recorder_not_in_pb, request_not_in_pb)
app.ServeHTTP(recorder, requestNotInPlaybook)

// Assertions
var result_not_in_pb map[string]interface{}
err = json.Unmarshal(recorder_not_in_pb.Body.Bytes(), &result_not_in_pb)
var resultNotInPlaybook map[string]interface{}
err = json.Unmarshal(recorder.Body.Bytes(), &resultNotInPlaybook)
if err != nil {
t.Fatalf("Could not unmarshal response body: %v", err)
}
expected_message_not_in_pb := "Cannot execute. reason: provided variables is not a valid subset of the variables for the referenced playbook [ playbook id: playbook--61a6c41e-6efc-4516-a242-dfbc5c89d562 ]"
assert.Equal(t, 400, recorder_not_in_pb.Code)
assert.Equal(t, expected_message_not_in_pb, result_not_in_pb["message"].(string))
notInPlaybookError := "Cannot execute. reason: provided variables is not a valid subset of the variables for the referenced playbook [ playbook id: playbook--61a6c41e-6efc-4516-a242-dfbc5c89d562 ]"
assert.Equal(t, 400, recorder.Code)
assert.Equal(t, notInPlaybookError, resultNotInPlaybook["message"].(string))

}

func TestPlaybookByIdVariableTypeMismatch(t *testing.T) {
jsonFile, err := os.Open("../playbook.json")
if err != nil {
fmt.Println(err)
t.Fail()
}
defer jsonFile.Close()
byteValue, _ := io.ReadAll(jsonFile)

gin.SetMode(gin.DebugMode)
app := gin.New()
mock_decomposer := new(mock_decomposer.Mock_Decomposer)
mock_controller := new(mock_decomposer_controller.Mock_Controller)
mock_database := new(mock_playbook_database.MockPlaybook)
mock_database_controller := new(mock_database_controller.Mock_Controller)
mock_database_controller.On("GetDatabaseInstance").Return(mock_database)
playbook := cacao.Decode(byteValue)
mock_database.On("Read", "1").Return(*playbook, nil)
mock_controller.On("NewDecomposer").Return(mock_decomposer)

recorder := httptest.NewRecorder()

// ################################################################### Var is of wrong type
var_wrong_type := cacao.Variable{
Name: "__var1__",
Type: cacao.VariableTypeInt,
}
variables_wrong_type := cacao.NewVariables(var_wrong_type)
variablesWrongType := cacao.NewVariables(var_wrong_type)

json_wrong_type, err := json.Marshal(variables_wrong_type)
jsonWrongType, err := json.Marshal(variablesWrongType)
assert.Equal(t, err, nil)

request_wrong_type, err := http.NewRequest("POST", "/trigger/playbook/1", bytes.NewReader(json_wrong_type))
requestWrongType, err := http.NewRequest("POST", "/trigger/playbook/1", bytes.NewReader(jsonWrongType))
if err != nil {
t.Fail()
}
app.ServeHTTP(recorder_wrong_type, request_wrong_type)
assert.Equal(t, 400, recorder_wrong_type.Code)
app.ServeHTTP(recorder, requestWrongType)
assert.Equal(t, 400, recorder.Code)

// Assertions
var result_wrong_type map[string]interface{}
err = json.Unmarshal(recorder_wrong_type.Body.Bytes(), &result_wrong_type)
var resultWrongType map[string]interface{}
err = json.Unmarshal(recorder.Body.Bytes(), &resultWrongType)
if err != nil {
t.Fatalf("Could not unmarshal response body: %v", err)
}
expected_message_wrong_type := "Cannot execute. reason: mismatch in variables type for [ __var1__ ]: payload var type = integer, playbook var type = string"
assert.Equal(t, 400, recorder_wrong_type.Code)
assert.Equal(t, expected_message_wrong_type, result_wrong_type["message"].(string))
assert.Equal(t, 400, recorder.Code)
assert.Equal(t, expected_message_wrong_type, resultWrongType["message"].(string))

// ################################################################### Playbook var is not external
var_not_external := cacao.Variable{
}

func TestPlaybookByIdVariableIsNotExternal(t *testing.T) {

jsonFile, err := os.Open("../playbook.json")
if err != nil {
fmt.Println(err)
t.Fail()
}
defer jsonFile.Close()
byteValue, _ := io.ReadAll(jsonFile)

gin.SetMode(gin.DebugMode)
app := gin.New()
mock_decomposer := new(mock_decomposer.Mock_Decomposer)
mock_controller := new(mock_decomposer_controller.Mock_Controller)
mock_database := new(mock_playbook_database.MockPlaybook)
mock_database_controller := new(mock_database_controller.Mock_Controller)
mock_database_controller.On("GetDatabaseInstance").Return(mock_database)
playbook := cacao.Decode(byteValue)
mock_database.On("Read", "1").Return(*playbook, nil)
mock_controller.On("NewDecomposer").Return(mock_decomposer)

recorder := httptest.NewRecorder()

varNotExternal := cacao.Variable{
Name: "__var2_not_external__",
Type: cacao.VariableTypeString,
Value: "I'm not gonna be assigned :(",
}
variables_not_external := cacao.NewVariables(var_not_external)
variablesNotExternal := cacao.NewVariables(varNotExternal)

json_not_external, err := json.Marshal(variables_not_external)
jsonNotExternal, err := json.Marshal(variablesNotExternal)
assert.Equal(t, err, nil)

request_not_external, err := http.NewRequest("POST", "/trigger/playbook/1", bytes.NewReader(json_not_external))
request_not_external, err := http.NewRequest("POST", "/trigger/playbook/1", bytes.NewReader(jsonNotExternal))
if err != nil {
t.Fail()
}
app.ServeHTTP(recorder_not_external, request_not_external)
assert.Equal(t, 400, recorder_not_external.Code)
app.ServeHTTP(recorder, request_not_external)
assert.Equal(t, 400, recorder.Code)

// Assertions
var result_not_external map[string]interface{}
err = json.Unmarshal(recorder_not_external.Body.Bytes(), &result_not_external)
var resultNotExternal map[string]interface{}
err = json.Unmarshal(recorder.Body.Bytes(), &resultNotExternal)
if err != nil {
t.Fatalf("Could not unmarshal response body: %v", err)
}
expected_message_not_external := "Cannot execute. reason: playbook variable [ __var2_not_external__ ] cannot be assigned in playbook because it is not marked as external in the plabook"
assert.Equal(t, 400, recorder_not_external.Code)
assert.Equal(t, expected_message_not_external, result_not_external["message"].(string))
expectedError := "Cannot execute. reason: playbook variable [ __var2_not_external__ ] cannot be assigned in playbook because it is not marked as external in the plabook"
assert.Equal(t, 400, recorder.Code)
assert.Equal(t, expectedError, resultNotExternal["message"].(string))

// ################################################################### End test
mock_decomposer.AssertExpectations(t)

}

0 comments on commit 4f242e3

Please sign in to comment.