当前位置：首页 > 文章列表 > Golang > Go问答 > 使用接口模拟测试场景

使用接口模拟测试场景

来源：stackoverflow 2024-02-27 15:48:27 0浏览收藏

本篇文章给大家分享《使用接口模拟测试场景》，覆盖了Golang的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

问题内容

我对 go 还很陌生，而且我来自 oop 语言。现在，接口和类的概念似乎完全不同。

我想知道在测试时模拟如何工作。我遇到的困惑是是否可以使用 struct 作为类，以及下面的方法是否是您想要做的？假设 defaultarticlesrepository 用于真实数据，而 mockarticlesrepository 用于模拟数据。

type ArticlesRepository interface {
    GetArticleSections() []ArticleSectionResponse
}

type DefaultArticlesRepository struct{}
type MockArticlesRepository struct{}

func (repository DefaultArticlesRepository) GetArticleSections() []ArticleSectionResponse {
    return []ArticleSectionResponse{
        {
            Title: "Default response",
            Tag:   "Default Tag",
        },
    }
}

func (repository MockArticlesRepository) GetArticleSections() []ArticleSectionResponse {
    return []ArticleSectionResponse{
        {
            Title: "Mock response",
            Tag:   "Mock Tag",
        },
    }
}

func ArticleSectionsProvider(v ArticlesRepository) ArticlesRepository {
    return v
}

func TestFoo(t *testing.T) {
    realProvider := ArticleSectionsProvider(DefaultArticlesRepository{})
    mockProvider := ArticleSectionsProvider(MockArticlesRepository{})

    assert.Equal(t, realProvider.GetArticleSections(), []ArticleSectionResponse{
        {
            Title: "Default response",
            Tag:   "Default Tag",
        },
    })

    assert.Equal(t, mockProvider.GetArticleSections(), []ArticleSectionResponse{
        {
            Title: "Mock response",
            Tag:   "Mock Tag",
        },
    })
}

解决方案

首先，我建议您使用 https://github.com/vektra/mockery 根据接口自动生成模拟结构。实现像您这样的模拟结构是可以的，但我认为如果您并不真正需要该结构的非常特殊的行为，那只会浪费您的时间和精力。

其次，我们不需要像您在代码中那样测试模拟结构。

assert.equal(t, mockprovider.getarticlesections(), []articlesectionresponse{
    {
        title: "mock response",
        tag:   "mock tag",
    },
})

因此，当我们使用模拟结构时，假设结构a是结构b的依赖项。例如：

type a interface {
    dotask() bool
} 

type a struct {}

func (sa *a) dotask() bool {
    return true
}

type b struct {
    a a
}

func (sb *b) dosomething() bool {
    //do some logic
    sb.a.dotask();
    //do some logic
    return true;
}

并且您想测试结构体b的函数dosomething。当然，在这种情况下，您不关心也不想测试 struct a 的函数 dotask。然后，您只需在测试中提供结构 a 的模拟到结构 b 即可。此模拟还可以帮助您避免在测试结构 b 时处理与结构 a 相关的任何问题。现在你的测试应该是这样的：

func (s *testsuiteofstructb) testdosomething_noerror() {
    //suppose that mockedofa  is a mock of struct a
    instanceofb := b{a: mockedofa}
    mockedofa.on("dotask").return(true)
    actualresult := instanceofb.dosomething()
    s.equal(true, actualresult)
}

最后，这只是一件小事，但没有看到你的articlesectionsprovider有明确的责任。

首先，没有必要使用任何外部模拟库，例如：

您真正需要的只是一个接口和一些使用标准库并行运行所有测试的代码。

检查下面这个真实世界的示例，而不是下一个“计算器测试示例”：

├── api
│   ├── storage.go
│   ├── server.go
│   └── server_test.go
└── main.go

api/storage.go

package api

import "database/sql"

type storage struct {
    // any database driver of your choice...
    pool *sql.db
}

func newstorage(p *sql.db) *storage {
    return &storage{pool: p}
}

func (s *storage) find() (string, error) {
    // use database driver to find from storage...
    return `{ "id": "123" }`, nil
}

func (s *storage) add(v string) error {
    // use database driver to add to storage...
    return nil
}

api/server.go

package api

import (
    "fmt"
    "net/http"
)

type storage interface {
    find() (string, error)
    add(string) error
}

type server struct {
    storage storage
}

func newserver(s storage) *server {
    return &server{storage: s}
}

func (s *server) find(w http.responsewriter, r *http.request) {
    response, err := s.storage.find()
    if err != nil {
        w.writeheader(http.statusnotfound)
        fmt.fprint(w, `{ "message": "not found" }`)
        return
    }

    fmt.fprint(w, response)
}

func (s *server) add(w http.responsewriter, r *http.request) {
    query := r.url.query()
    name := query.get("name")

    if err := s.storage.add(name); err != nil {
        w.writeheader(http.statusnotfound)
        fmt.fprint(w, `{ "message": "not found" }`)
        return
    }

    fmt.fprint(w, `{ "message": "success" }`)
}

api/server_test.go

package api

import (
    "errors"
    "net/http"
    "net/http/httptest"
    "testing"
)

type mock struct {
    find func() (string, error)
    add  func(string) error
}

func (m *mock) find() (string, error) { return m.find() }
func (m *mock) add(v string) error    { return m.add(v) }

func testfindok(t *testing.t) {
    t.parallel()

    // arrange
    expectedbody := `{ "message": "ok" }`
    expectedstatus := http.statusok
    m := &mock{find: func() (string, error) { return expectedbody, nil }}
    server := newserver(m)
    recorder := httptest.newrecorder()

    // act
    server.find(recorder, &http.request{})

    // assert
    if recorder.code != expectedstatus {
        t.errorf("want %d, got %d", expectedstatus, recorder.code)
    }

    if recorder.body.string() != expectedbody {
        t.errorf("want %s, got %s", expectedbody, recorder.body.string())
    }
}

func testfindnotfound(t *testing.t) {
    t.parallel()

    // arrange
    expectedbody := `{ "message": "not found" }`
    expectedstatus := http.statusnotfound
    m := &mock{find: func() (string, error) { return expectedbody, errors.new("not found") }}
    server := newserver(m)
    recorder := httptest.newrecorder()

    // act
    server.find(recorder, &http.request{})

    // assert
    if recorder.code != expectedstatus {
        t.errorf("want %d, got %d", expectedstatus, recorder.code)
    }

    if recorder.body.string() != expectedbody {
        t.errorf("want %s, got %s", expectedbody, recorder.body.string())
    }
}

func testaddok(t *testing.t) {
    t.parallel()

    // arrange
    expectedbody := `{ "message": "success" }`
    expectedstatus := http.statusok
    m := &mock{add: func(string) error { return nil }}
    server := newserver(m)
    recorder := httptest.newrecorder()

    // act
    request, _ := http.newrequest("get", "/add?name=mike", nil)
    server.add(recorder, request)

    // assert
    if recorder.code != expectedstatus {
        t.errorf("want %d, got %d", expectedstatus, recorder.code)
    }

    if recorder.body.string() != expectedbody {
        t.errorf("want %s, got %s", expectedbody, recorder.body.string())
    }
}