在 go 中使用通道 return 值测试发射器功能

Testing Emitter func with channel return value in go

我很难对我的发射器函数进行测试,该函数通过数据管道的通道传递结果。此功能将定期触发并从数据库中提取记录。我为这个问题编译了一个精简的完成版本,真正的代码会更复杂,但会遵循相同的模式。为了进行测试,我模拟了对数据库的访问,因为我想测试 Emitter 函数的行为。

我想代码不仅仅是文字:

这是我要测试的方法:

//EmittRecord pull record from database
func EmittRecord(svc Service, count int) <-chan *Result {
    out := make(chan *Result)

    go func() {
        defer close(out)
        for i := 0; i < count; i++ {
            r, err := svc.Next()
            if err != nil {
                out <- &Result{Error: err}
                continue
            }
            out <- &Result{Payload: &Payload{
                Field1: r.Field1,
                Field2: r.Field2,
            }, Error: nil}
        }

    }()

    return out
}

我有几个带有接口的类型:

//Record is a Record from db
type Record struct {
    Field1 string
    Field2 string
}

//Payload is a record for the data pipeline
type Payload struct {
    Field1 string
    Field2 string
}

//Result is a type for the data pipeline
type Result struct {
    Payload *Payload
    Error   error
}

//Service is an abstraction to access the database
type Service interface {
    Next() (*Record, error)
}

这是我用于测试的服务模拟:

//MockService is a struct to support testing for mocking the database
type MockService struct {
    NextMock func() (*Record, error)
}

//Next is an Implementation of the Service interface for the mock
func (m *MockService) Next() (*Record, error) {
    if m.NextMock != nil {
        return m.NextMock()
    }
    panic("Please set NextMock!")
}

最后这是我的测试方法,它不起作用。它没有遇到完成的情况,也没有遇到 1*time.Second 超时情况……测试只是超时。我想我在这里遗漏了一些东西。

 func TestEmitter(t *testing.T) {

    tt := []struct {
        name           string
        svc            runner.Service
        expectedResult runner.Result
    }{

        {name: "Database returns error",
            svc: &runner.MockService{
                NextMock: func() (*runner.Record, error) {
                    return nil, fmt.Errorf("YIKES")
                },
            },
            expectedResult: runner.Result{Payload: nil, Error: fmt.Errorf("RRRR")},
        },
        {name: "Database returns record",
            svc: &runner.MockService{
                NextMock: func() (*runner.Record, error) {
                    return &runner.Record{
                        Field1: "hello",
                        Field2: "world",
                    }, nil
                },
            },
        },
    }

    for _, tc := range tt {

        t.Run(tc.name, func(t *testing.T) {
            done := make(chan bool)
            defer close(done)

            var output <-chan *runner.Result
            go func() {
                output = runner.EmittRecord(tc.svc, 1)
                done <- true
            }()
            found := <-output
            <-done
            select {
            case <-done:
            case <-time.After(1 * time.Second):
                panic("timeout")
            }

            if found.Error.Error() != tc.expectedResult.Error.Error() {
                t.Errorf("FAIL: %s, expected: %s; but got %s", tc.name, tc.expectedResult.Error.Error(), found.Error.Error())

            } else if reflect.DeepEqual(found.Payload, tc.expectedResult.Payload) {
                t.Errorf("FAIL: %s, expected: %+v; got %+v", tc.name, tc.expectedResult.Payload, found.Payload)
            }

        })
    }

}

太好了,如果有人能给我一个我在这里遗漏的建议,也许还有一些输入如何验证 EmittRecord 函数的计数,现在它只设置为 1 提前致谢

//编辑:根据@Lansana

评论的预期结果

您确定将测试中的预期结果设置为正确的值吗?

在测试的第一个切片中,您期望 fmt.Errorf("RRRR"),但模拟 returns 是 fmt.Errorf("YIKES")

然后在实际测试条件中,你这样做:

if found.Error.Error() != "Hello" {
    t.Errorf("FAIL: %s, expected: %s; but got %s", tc.name, tc.expectedResult.Error.Error(), found.Error.Error())
}

您正在查看 "Hello"。您不应该检查消息 "YIKES" 是否有错误吗?

我觉得你的逻辑很好,只是你的测试写得不对。在这里检查我的 Go Playground example 和 运行 代码。当你 运行 它时,你会看到没有输出或恐慌。这是因为代码在 main.

中通过了我的测试条件

您正在通过更多渠道为您的测试增加更多的复杂性,如果这些额外的渠道无效,那么您可能会有一些误报,让您认为您的业务逻辑很糟糕。在这种情况下,它实际上似乎在正常工作。

这是我的 playground 示例代码的亮点。 (考验逻辑的部分):

func main() {
    svc1 := &MockService{
        NextMock: func() (*Record, error) {
            return nil, errors.New("foo")
        },
    }
    for item := range EmittRecord(svc1, 5) {
        if item.Payload != nil {
            panic("item.Payload should be nil")
        }
        if item.Error == nil {
            panic("item.Error should be an error")
        }
    }

    svc2 := &MockService{
        NextMock: func() (*Record, error) {
            return &Record{Field1: "Hello ", Field2: "World"}, nil
        },
    }
    for item := range EmittRecord(svc2, 5) {
        if item.Payload == nil {
            panic("item.Payload should have a value")
        }
        if item.Payload.Field1 + item.Payload.Field2 != "Hello World" {
            panic("item.Payload.Field1 and item.Payload.Field2 are invalid!")
        }
        if item.Error != nil {
            panic("item.Error should be nil")
        }
    }
}

以上代码的输出是空的。没有恐慌。这样就成功了。

尝试将测试简化为工作状态,然后从那里增加更多的复杂性。 :)