You are viewing a plain text version of this content. The canonical link for it is here.
Posted to issues@beam.apache.org by "ASF GitHub Bot (Jira)" <ji...@apache.org> on 2022/03/03 15:27:00 UTC
[jira] [Work logged] (BEAM-13872) [Playground] Increase test coverage for the code_processing package
[ https://issues.apache.org/jira/browse/BEAM-13872?focusedWorklogId=736074&page=com.atlassian.jira.plugin.system.issuetabpanels:worklog-tabpanel#worklog-736074 ]
ASF GitHub Bot logged work on BEAM-13872:
-----------------------------------------
Author: ASF GitHub Bot
Created on: 03/Mar/22 15:26
Start Date: 03/Mar/22 15:26
Worklog Time Spent: 10m
Work Description: KhaninArtur commented on a change in pull request #16891:
URL: https://github.com/apache/beam/pull/16891#discussion_r818767927
##########
File path: playground/backend/internal/code_processing/code_processing_test.go
##########
@@ -1004,3 +1190,354 @@ func syncMapLen(syncMap *sync.Map) int {
})
return length
}
+
+func TestGetGraph(t *testing.T) {
+ ctx := context.Background()
+ pipelineId1 := uuid.New()
+ graph := "GRAPH"
+ err := cacheService.SetValue(ctx, pipelineId1, cache.Graph, graph)
+ if err != nil {
+ return
+ }
+ pipelineId2 := uuid.New()
+ err = cacheService.SetValue(ctx, pipelineId2, cache.Graph, 1)
+ if err != nil {
+ return
+ }
+ type args struct {
+ ctx context.Context
+ cacheService cache.Cache
+ key uuid.UUID
+ errorTitle string
+ }
+ tests := []struct {
+ name string
+ args args
+ want string
+ wantErr bool
+ }{
+ {
+ name: "Get graph when key exist in cache",
+ args: args{
+ ctx: context.Background(),
+ cacheService: cacheService,
+ key: pipelineId1,
+ errorTitle: "error",
+ },
+ want: graph,
+ wantErr: false,
+ },
+ {
+ name: "Get graph when key doesn't exist in cache",
+ args: args{
+ ctx: context.Background(),
+ cacheService: cacheService,
+ key: uuid.New(),
+ errorTitle: "error",
+ },
+ want: "",
+ wantErr: true,
+ },
+ {
+ name: "Get graph when value from cache by key couldn't be converted to a string",
+ args: args{
+ ctx: context.Background(),
+ cacheService: cacheService,
+ key: pipelineId2,
+ errorTitle: "error",
+ },
+ want: "",
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got, err := GetGraph(tt.args.ctx, tt.args.cacheService, tt.args.key, tt.args.errorTitle)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("GetGraph error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if got != tt.want {
+ t.Errorf("GetGraph got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func Test_processSetupError(t *testing.T) {
+ client, mock := redismock.NewClientMock()
+ pipelineId := uuid.New()
+ errorMessage := "MOCK_ERROR"
+ type args struct {
+ err error
+ pipelineId uuid.UUID
+ cacheService cache.Cache
+ ctxWithTimeout context.Context
+ }
+ tests := []struct {
+ name string
+ mocks func()
+ args args
+ wantErr bool
+ }{
+ {
+ name: "Error during HSet operation",
+ mocks: func() {
+ mock.ExpectHSet(pipelineId.String(), "MOCK_VALUE").SetErr(fmt.Errorf(errorMessage))
+ },
+ args: args{
+ err: fmt.Errorf(errorMessage),
+ pipelineId: pipelineId,
+ cacheService: &redis.Cache{
+ Client: client,
+ },
+ ctxWithTimeout: nil,
+ },
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ tt.mocks()
+ if err := processSetupError(tt.args.err, tt.args.pipelineId, tt.args.cacheService, tt.args.ctxWithTimeout); (err != nil) != tt.wantErr {
+ t.Errorf("processSetupError() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func Test_processErrorWithSavingOutput(t *testing.T) {
+ client, mock := redismock.NewClientMock()
+ pipelineId := uuid.New()
+ errorMessage := "MOCK_ERROR"
+ subKey := cache.RunOutput
+ type args struct {
+ ctx context.Context
+ err error
+ errorOutput []byte
+ pipelineId uuid.UUID
+ subKey cache.SubKey
+ cacheService cache.Cache
+ errorTitle string
+ newStatus pb.Status
+ }
+ tests := []struct {
+ name string
+ mocks func()
+ args args
+ wantErr bool
+ }{
+ {
+ name: "Error during HSet operation",
+ mocks: func() {
+ mock.ExpectHSet(pipelineId.String(), subKey).SetErr(fmt.Errorf(errorMessage))
+ },
+ args: args{
+ ctx: context.Background(),
+ err: fmt.Errorf(errorMessage),
+ errorOutput: nil,
+ pipelineId: pipelineId,
+ subKey: subKey,
+ cacheService: &redis.Cache{Client: client},
+ errorTitle: "",
+ newStatus: 0,
+ },
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ tt.mocks()
+ if err := processErrorWithSavingOutput(tt.args.ctx, tt.args.err, tt.args.errorOutput, tt.args.pipelineId, tt.args.subKey, tt.args.cacheService, tt.args.errorTitle, tt.args.newStatus); (err != nil) != tt.wantErr {
+ t.Errorf("processErrorWithSavingOutput() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func Test_processRunError(t *testing.T) {
+ client, mock := redismock.NewClientMock()
+ pipelineId := uuid.New()
+ errorMessage := "MOCK_ERROR"
+ subKey := cache.RunError
+ errorChannel := make(chan error, 1)
+ errorChannel <- fmt.Errorf(errorMessage)
+ type args struct {
+ ctx context.Context
+ errorChannel chan error
+ errorOutput []byte
+ pipelineId uuid.UUID
+ cacheService cache.Cache
+ stopReadLogsChannel chan bool
+ finishReadLogsChannel chan bool
+ }
+ tests := []struct {
+ name string
+ mocks func()
+ args args
+ wantErr bool
+ }{
+ {
+ name: "Error during HSet operation",
+ mocks: func() {
+ mock.ExpectHSet(pipelineId.String(), subKey).SetErr(fmt.Errorf(errorMessage))
+ },
+ args: args{
+ ctx: context.Background(),
+ errorChannel: errorChannel,
+ errorOutput: nil,
+ pipelineId: pipelineId,
+ cacheService: &redis.Cache{Client: client},
+ stopReadLogsChannel: nil,
+ finishReadLogsChannel: nil,
+ },
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ tt.mocks()
+ if err := processRunError(tt.args.ctx, tt.args.errorChannel, tt.args.errorOutput, tt.args.pipelineId, tt.args.cacheService, tt.args.stopReadLogsChannel, tt.args.finishReadLogsChannel); (err != nil) != tt.wantErr {
+ t.Errorf("processRunError() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func Test_processCompileSuccess(t *testing.T) {
+ client, mock := redismock.NewClientMock()
+ pipelineId := uuid.New()
+ output := "output"
+ cacheMock := &redis.Cache{Client: client}
+ marshalLogs, _ := json.Marshal(cache.Logs)
+ marshalCompileOutput, _ := json.Marshal(cache.CompileOutput)
+ marshalRunOutput, _ := json.Marshal(cache.RunOutput)
+ marshalRunError, _ := json.Marshal(cache.RunError)
+ outputMarshal, _ := json.Marshal(output)
+ marshalEmptyString, _ := json.Marshal("")
+ type args struct {
+ ctx context.Context
+ output []byte
+ pipelineId uuid.UUID
+ cacheService cache.Cache
+ }
+ tests := []struct {
+ name string
+ mocks func()
+ args args
+ wantErr bool
+ }{
+ {
+ name: "Error during set value to CompileOutput subKey",
+ mocks: func() {
+ },
+ args: args{
+ ctx: context.Background(),
+ output: []byte(output),
+ pipelineId: pipelineId,
+ cacheService: cacheMock,
+ },
+ wantErr: true,
+ },
+ {
+ name: "Error during set value to RunOutput subKey",
+ mocks: func() {
+ mock.ExpectHSet(pipelineId.String(), marshalCompileOutput, outputMarshal).SetVal(1)
+ },
+ args: args{
+ ctx: context.Background(),
+ output: []byte(output),
+ pipelineId: pipelineId,
+ cacheService: cacheMock,
+ },
+ wantErr: true,
+ },
+ {
+ name: "Error during set value to RunError subKey",
+ mocks: func() {
+ mock.ExpectHSet(pipelineId.String(), marshalCompileOutput, outputMarshal).SetVal(1)
+ mock.ExpectHSet(pipelineId.String(), marshalRunOutput, marshalEmptyString).SetVal(1)
+ },
+ args: args{
+ ctx: context.Background(),
+ output: []byte(output),
+ pipelineId: pipelineId,
+ cacheService: cacheMock,
+ },
+ wantErr: true,
+ },
+ {
+ name: "Error during set value to Logs subKey",
+ mocks: func() {
+ mock.ExpectHSet(pipelineId.String(), marshalCompileOutput, outputMarshal).SetVal(1)
+ mock.ExpectHSet(pipelineId.String(), marshalRunOutput, marshalEmptyString).SetVal(1)
+ mock.ExpectHSet(pipelineId.String(), marshalRunError, marshalEmptyString).SetVal(1)
+ },
+ args: args{
+ ctx: context.Background(),
+ output: []byte(output),
+ pipelineId: pipelineId,
+ cacheService: cacheMock,
+ },
+ wantErr: true,
+ },
+ {
+ name: "Error during set value to Graph subKey",
+ mocks: func() {
+ mock.ExpectHSet(pipelineId.String(), marshalCompileOutput, outputMarshal).SetVal(1)
+ mock.ExpectHSet(pipelineId.String(), marshalRunOutput, marshalEmptyString).SetVal(1)
+ mock.ExpectHSet(pipelineId.String(), marshalRunError, marshalEmptyString).SetVal(1)
+ mock.ExpectHSet(pipelineId.String(), marshalLogs, marshalEmptyString).SetVal(1)
+ },
+ args: args{
+ ctx: context.Background(),
+ output: []byte(output),
+ pipelineId: pipelineId,
+ cacheService: cacheMock,
+ },
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ tt.mocks()
+ if err := processCompileSuccess(tt.args.ctx, tt.args.output, tt.args.pipelineId, tt.args.cacheService); (err != nil) != tt.wantErr {
+ t.Errorf("processCompileSuccess() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func Test_readGraphFile(t *testing.T) {
+ pipelineLifeCycleCtx, _ := context.WithTimeout(context.Background(), 1*time.Second)
+ type args struct {
+ pipelineLifeCycleCtx context.Context
+ backgroundCtx context.Context
+ cacheService cache.Cache
+ graphFilePath string
+ pipelineId uuid.UUID
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "Successfully saving the prepared graph to the cache",
+ args: args{
+ pipelineLifeCycleCtx: pipelineLifeCycleCtx,
+ backgroundCtx: context.Background(),
+ cacheService: cacheService,
+ graphFilePath: graphFilePath,
+ pipelineId: uuid.New(),
+ },
Review comment:
What happens when we don't have the file with a graph? Does any error raise?
##########
File path: playground/backend/internal/code_processing/code_processing_test.go
##########
@@ -1004,3 +1180,354 @@ func syncMapLen(syncMap *sync.Map) int {
})
return length
}
+
+func TestGetGraph(t *testing.T) {
+ ctx := context.Background()
+ pipelineId1 := uuid.New()
+ graph := "GRAPH"
+ err := cacheService.SetValue(ctx, pipelineId1, cache.Graph, graph)
+ if err != nil {
+ return
+ }
+ pipelineId2 := uuid.New()
+ err = cacheService.SetValue(ctx, pipelineId2, cache.Graph, 1)
+ if err != nil {
+ return
+ }
+ type args struct {
+ ctx context.Context
+ cacheService cache.Cache
+ key uuid.UUID
+ errorTitle string
+ }
+ tests := []struct {
+ name string
+ args args
+ want string
+ wantErr bool
+ }{
+ {
+ name: "Get graph when key exist in cache",
+ args: args{
+ ctx: context.Background(),
+ cacheService: cacheService,
+ key: pipelineId1,
+ errorTitle: "error",
+ },
+ want: graph,
+ wantErr: false,
+ },
+ {
+ name: "Get graph when key doesn't exist in cache",
+ args: args{
+ ctx: context.Background(),
+ cacheService: cacheService,
+ key: uuid.New(),
+ errorTitle: "error",
+ },
+ want: "",
+ wantErr: true,
+ },
+ {
+ name: "Get graph when value from cache by key couldn't be converted to a string",
+ args: args{
+ ctx: context.Background(),
+ cacheService: cacheService,
+ key: pipelineId2,
+ errorTitle: "error",
+ },
+ want: "",
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got, err := GetGraph(tt.args.ctx, tt.args.cacheService, tt.args.key, tt.args.errorTitle)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("GetGraph error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if got != tt.want {
+ t.Errorf("GetGraph got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func Test_processSetupError(t *testing.T) {
+ client, mock := redismock.NewClientMock()
+ pipelineId := uuid.New()
+ errorMessage := "MOCK_ERROR"
+ type args struct {
+ err error
+ pipelineId uuid.UUID
+ cacheService cache.Cache
+ ctxWithTimeout context.Context
+ }
+ tests := []struct {
+ name string
+ mocks func()
+ args args
+ wantErr bool
+ }{
+ {
+ name: "Error during HSet operation",
+ mocks: func() {
+ mock.ExpectHSet(pipelineId.String(), "MOCK_VALUE").SetErr(fmt.Errorf(errorMessage))
+ },
+ args: args{
+ err: fmt.Errorf(errorMessage),
+ pipelineId: pipelineId,
+ cacheService: &redis.Cache{
+ Client: client,
+ },
+ ctxWithTimeout: nil,
+ },
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ tt.mocks()
+ if err := processSetupError(tt.args.err, tt.args.pipelineId, tt.args.cacheService, tt.args.ctxWithTimeout); (err != nil) != tt.wantErr {
+ t.Errorf("processSetupError() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func Test_processErrorWithSavingOutput(t *testing.T) {
+ client, mock := redismock.NewClientMock()
+ pipelineId := uuid.New()
+ errorMessage := "MOCK_ERROR"
+ subKey := cache.RunOutput
+ type args struct {
+ ctx context.Context
+ err error
+ errorOutput []byte
+ pipelineId uuid.UUID
+ subKey cache.SubKey
+ cacheService cache.Cache
+ errorTitle string
+ newStatus pb.Status
+ }
+ tests := []struct {
+ name string
+ mocks func()
+ args args
+ wantErr bool
+ }{
+ {
+ name: "Error during HSet operation",
+ mocks: func() {
+ mock.ExpectHSet(pipelineId.String(), subKey).SetErr(fmt.Errorf(errorMessage))
+ },
+ args: args{
+ ctx: context.Background(),
+ err: fmt.Errorf(errorMessage),
+ errorOutput: nil,
+ pipelineId: pipelineId,
+ subKey: subKey,
+ cacheService: &redis.Cache{Client: client},
+ errorTitle: "",
+ newStatus: 0,
+ },
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ tt.mocks()
+ if err := processErrorWithSavingOutput(tt.args.ctx, tt.args.err, tt.args.errorOutput, tt.args.pipelineId, tt.args.subKey, tt.args.cacheService, tt.args.errorTitle, tt.args.newStatus); (err != nil) != tt.wantErr {
+ t.Errorf("processErrorWithSavingOutput() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func Test_processRunError(t *testing.T) {
+ client, mock := redismock.NewClientMock()
+ pipelineId := uuid.New()
+ errorMessage := "MOCK_ERROR"
+ subKey := cache.RunError
+ errorChannel := make(chan error, 1)
+ errorChannel <- fmt.Errorf(errorMessage)
+ type args struct {
+ ctx context.Context
+ errorChannel chan error
+ errorOutput []byte
+ pipelineId uuid.UUID
+ cacheService cache.Cache
+ stopReadLogsChannel chan bool
+ finishReadLogsChannel chan bool
+ }
+ tests := []struct {
+ name string
+ mocks func()
+ args args
+ wantErr bool
+ }{
+ {
+ name: "Error during HSet operation",
+ mocks: func() {
+ mock.ExpectHSet(pipelineId.String(), subKey).SetErr(fmt.Errorf(errorMessage))
+ },
+ args: args{
+ ctx: context.Background(),
+ errorChannel: errorChannel,
+ errorOutput: nil,
+ pipelineId: pipelineId,
+ cacheService: &redis.Cache{Client: client},
+ stopReadLogsChannel: nil,
+ finishReadLogsChannel: nil,
+ },
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ tt.mocks()
+ if err := processRunError(tt.args.ctx, tt.args.errorChannel, tt.args.errorOutput, tt.args.pipelineId, tt.args.cacheService, tt.args.stopReadLogsChannel, tt.args.finishReadLogsChannel); (err != nil) != tt.wantErr {
+ t.Errorf("processRunError() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func Test_processCompileSuccess(t *testing.T) {
+ client, mock := redismock.NewClientMock()
+ pipelineId := uuid.New()
+ output := "output"
+ cacheMock := &redis.Cache{Client: client}
+ marshalLogs, _ := json.Marshal(cache.Logs)
+ marshalCompileOutput, _ := json.Marshal(cache.CompileOutput)
+ marshalRunOutput, _ := json.Marshal(cache.RunOutput)
+ marshalRunError, _ := json.Marshal(cache.RunError)
+ outputMarshal, _ := json.Marshal(output)
+ marshalEmptyString, _ := json.Marshal("")
+ type args struct {
+ ctx context.Context
+ output []byte
+ pipelineId uuid.UUID
+ cacheService cache.Cache
+ }
+ tests := []struct {
+ name string
+ mocks func()
+ args args
+ wantErr bool
+ }{
+ {
+ name: "Error during set value to CompileOutput subKey",
+ mocks: func() {
+ },
+ args: args{
+ ctx: context.Background(),
+ output: []byte(output),
+ pipelineId: pipelineId,
+ cacheService: cacheMock,
+ },
+ wantErr: true,
+ },
+ {
+ name: "Error during set value to RunOutput subKey",
+ mocks: func() {
+ mock.ExpectHSet(pipelineId.String(), marshalCompileOutput, outputMarshal).SetVal(1)
+ },
+ args: args{
+ ctx: context.Background(),
+ output: []byte(output),
+ pipelineId: pipelineId,
+ cacheService: cacheMock,
+ },
+ wantErr: true,
+ },
+ {
+ name: "Error during set value to RunError subKey",
+ mocks: func() {
+ mock.ExpectHSet(pipelineId.String(), marshalCompileOutput, outputMarshal).SetVal(1)
+ mock.ExpectHSet(pipelineId.String(), marshalRunOutput, marshalEmptyString).SetVal(1)
+ },
+ args: args{
+ ctx: context.Background(),
+ output: []byte(output),
+ pipelineId: pipelineId,
+ cacheService: cacheMock,
+ },
+ wantErr: true,
+ },
+ {
+ name: "Error during set value to Logs subKey",
+ mocks: func() {
+ mock.ExpectHSet(pipelineId.String(), marshalCompileOutput, outputMarshal).SetVal(1)
+ mock.ExpectHSet(pipelineId.String(), marshalRunOutput, marshalEmptyString).SetVal(1)
+ mock.ExpectHSet(pipelineId.String(), marshalRunError, marshalEmptyString).SetVal(1)
+ },
+ args: args{
+ ctx: context.Background(),
+ output: []byte(output),
+ pipelineId: pipelineId,
+ cacheService: cacheMock,
+ },
+ wantErr: true,
+ },
+ {
+ name: "Error during set value to Graph subKey",
+ mocks: func() {
+ mock.ExpectHSet(pipelineId.String(), marshalCompileOutput, outputMarshal).SetVal(1)
+ mock.ExpectHSet(pipelineId.String(), marshalRunOutput, marshalEmptyString).SetVal(1)
+ mock.ExpectHSet(pipelineId.String(), marshalRunError, marshalEmptyString).SetVal(1)
+ mock.ExpectHSet(pipelineId.String(), marshalLogs, marshalEmptyString).SetVal(1)
+ },
+ args: args{
+ ctx: context.Background(),
+ output: []byte(output),
+ pipelineId: pipelineId,
+ cacheService: cacheMock,
+ },
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ tt.mocks()
+ if err := processCompileSuccess(tt.args.ctx, tt.args.output, tt.args.pipelineId, tt.args.cacheService); (err != nil) != tt.wantErr {
+ t.Errorf("processCompileSuccess() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func Test_readGraphFile(t *testing.T) {
+ pipelineLifeCycleCtx, _ := context.WithTimeout(context.Background(), 1*time.Second)
+ type args struct {
+ pipelineLifeCycleCtx context.Context
+ backgroundCtx context.Context
+ cacheService cache.Cache
+ graphFilePath string
+ pipelineId uuid.UUID
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "All success",
Review comment:
What if we read a file that doesn't exist?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@beam.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Issue Time Tracking
-------------------
Worklog Id: (was: 736074)
Time Spent: 3h (was: 2h 50m)
> [Playground] Increase test coverage for the code_processing package
> -------------------------------------------------------------------
>
> Key: BEAM-13872
> URL: https://issues.apache.org/jira/browse/BEAM-13872
> Project: Beam
> Issue Type: Sub-task
> Components: beam-playground
> Reporter: Aydar Zaynutdinov
> Assignee: Pavel Avilov
> Priority: P3
> Labels: beam-playground-backend
> Time Spent: 3h
> Remaining Estimate: 0h
>
> Need to add unit tests to increase test coverage for the _code_processing_ package.
--
This message was sent by Atlassian Jira
(v8.20.1#820001)