go - 如何使用具有差异实现的函数接口(interface)

Question

我正在使用 interface，我想在测试中模拟其中的一个方法function1，但我无法弄清楚如何最好的做法是为产品代码提供 1 个值，为测试提供一些模拟值，有人可以举个例子吗？ (编辑)这是代码:

https://play.golang.org/p/w367IOjADFV

package main

import (
    "fmt"
    "time"
)

type vInterface interface {
    function1() bool
}

type mStruct struct {
    info string
    time time.Time
}

func (s *mStruct) function1() bool {
    return true
}

func callSomething(si vInterface) bool {
    return si.function1()
}

func (s *mStruct) vl1() bool {
    s.time = time.Now()
    s.info = "vl1->info"
    return callSomething(s)
}

var currentVt1 mStruct

func main() {
    vl1 := currentVt1.vl1()

    fmt.Println(vl1)
}

测试是这样的

func Test_callSomething(t *testing.T) {
    type args struct {
        si vInterface
    }
    tests := []struct {
        name string
        args args
        want bool
    }{
        {
            name: "my tests",
            args: args{

            },
            want: false,
        },
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := callSomething(tt.args.si); got != tt.want {
                t.Errorf("callSomething() = %v, want %v", got, tt.want)
            }
        })
    }
}

但不确定如何正确模拟它......

更新

func Test_mStruct_vl1(t *testing.T) {
    type fields struct {
        info string
        time time.Time
    }
    tests := []struct {
        name   string
        fields fields
        want   bool
    }{
        {
            name: "some test",
            fields: struct {
                info string
                time time.Time
            }{info: "myinfo", time: time.Now() },

        },
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            s := &mStruct{
                info: tt.fields.info,
                time: tt.fields.time,
            }
            if got := s.vl1(); got != tt.want {
                t.Errorf("vl1() = %v, want %v", got, tt.want)
            }
        })
    }
}

Answer 1

首先你需要一个实现vInterface接口(interface)的类型(任何类型)。这是一个简单的例子:

type mockedVInterface struct {
    value bool
}

func (m mockedVInterface) function1() bool {
    return m.value
}

这是一个我们可以控制的足够简单的实现:我们可以通过简单地将那个值设置到它的 value 字段来告诉它的 function1() 函数应该返回什么。

此 mockedVInterface 类型仅为测试目的而创建，生产代码不需要它。把它放在你有测试代码的同一个文件中(把它放在 Test_callSomething() 之前)。

这是测试代码:

func Test_callSomething(t *testing.T) {
    type args struct {
        si vInterface
    }
    tests := []struct {
        name string
        args args
        want bool
    }{
        {
            name: "testing false",
            args: args{
                si: mockedVInterface{value: false},
            },
            want: false,
        },
        {
            name: "testing true",
            args: args{
                si: mockedVInterface{value: true},
            },
            want: true,
        },
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := callSomething(tt.args.si); got != tt.want {
                t.Errorf("callSomething() = %v, want %v", got, tt.want)
            }
        })
    }
}

请注意，在这种简单的情况下，我们还可以使用一个简单的非结构类型，它具有 bool 作为其基础类型，如下所示:

type mockedVInterface bool

func (m mockedVInterface) function1() bool {
    return bool(m)
}

它有效并且测试代码也更简单:

tests := []struct {
        name string
        args args
        want bool
    }{
        {
            name: "testing false",
            args: args{
                si: mockedVInterface(false),
            },
            want: false,
        },
        {
            name: "testing true",
            args: args{
                si: mockedVInterface(true),
            },
            want: true,
        },
    }

但这仅在可模拟接口(interface)具有具有单个返回值的单个函数时才有效。在一般情况下，需要一个结构。