You are viewing a plain text version of this content. The canonical link for it is here.
Posted to github@beam.apache.org by GitBox <gi...@apache.org> on 2022/03/03 15:26:51 UTC
[GitHub] [beam] KhaninArtur commented on a change in pull request #16891: [BEAM-13872] [Playground] Increase test coverage for the code_processing package
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