나는 약간 다른 접근법을 사용하고 있습니다. 공용 구조체 메소드가 인터페이스를 구현 있지만 논리는 해당 인터페이스 를 매개 변수로 사용 하는 개인 (내보내기되지 않은) 함수를 래핑하는 것으로 제한됩니다 . 이를 통해 거의 모든 종속성을 조롱하고 테스트 스위트 외부에서 사용할 깨끗한 API를 확보 할 수 있습니다.

이것을 이해하기 위해서는 테스트 케이스 (예 : _test.go파일 내 ) 에서 내 보내지 않은 메소드에 액세스 할 수 있으므로 래핑 옆에 논리가없는 내 보낸 메소드 를 테스트하는 대신 테스트합니다.

요약 : 내 보낸 기능을 테스트하는 대신 내 보내지 않은 기능을 테스트하십시오!

예를 들어 봅시다. 두 가지 방법이있는 Slack API 구조체가 있다고 가정 해 봅시다.

• SendMessage슬랙은 webhook에 HTTP 요청을 전송하는 방법
• 그만큼 SendDataSynchronously그들을 문자열의 반복의 조각을 주어 호출 방법 SendMessage의 모든 반복에 대해

따라서 SendDataSynchronously매번 HTTP 요청을하지 않고 테스트 하려면 모의해야합니다.SendMessage .

package main

import (
    "fmt"
)

// URI interface
type URI interface {
    GetURL() string
}

// MessageSender interface
type MessageSender interface {
    SendMessage(message string) error
}

// This one is the "object" that our users will call to use this package functionalities
type API struct {
    baseURL  string
    endpoint string
}

// Here we make API implement implicitly the URI interface
func (api *API) GetURL() string {
    return api.baseURL + api.endpoint
}

// Here we make API implement implicitly the MessageSender interface
// Again we're just WRAPPING the sendMessage function here, nothing fancy 
func (api *API) SendMessage(message string) error {
    return sendMessage(api, message)
}

// We want to test this method but it calls SendMessage which makes a real HTTP request!
// Again we're just WRAPPING the sendDataSynchronously function here, nothing fancy
func (api *API) SendDataSynchronously(data []string) error {
    return sendDataSynchronously(api, data)
}

// this would make a real HTTP request
func sendMessage(uri URI, message string) error {
    fmt.Println("This function won't get called because we will mock it")
    return nil
}

// this is the function we want to test :)
func sendDataSynchronously(sender MessageSender, data []string) error {
    for _, text := range data {
        err := sender.SendMessage(text)

        if err != nil {
            return err
        }
    }

    return nil
}

// TEST CASE BELOW

// Here's our mock which just contains some variables that will be filled for running assertions on them later on
type mockedSender struct {
    err      error
    messages []string
}

// We make our mock implement the MessageSender interface so we can test sendDataSynchronously
func (sender *mockedSender) SendMessage(message string) error {
    // let's store all received messages for later assertions
    sender.messages = append(sender.messages, message)

    return sender.err // return error for later assertions
}

func TestSendsAllMessagesSynchronously() {
    mockedMessages := make([]string, 0)
    sender := mockedSender{nil, mockedMessages}

    messagesToSend := []string{"one", "two", "three"}
    err := sendDataSynchronously(&sender, messagesToSend)

    if err == nil {
        fmt.Println("All good here we expect the error to be nil:", err)
    }

    expectedMessages := fmt.Sprintf("%v", messagesToSend)
    actualMessages := fmt.Sprintf("%v", sender.messages)

    if expectedMessages == actualMessages {
        fmt.Println("Actual messages are as expected:", actualMessages)
    }
}

func main() {
    TestSendsAllMessagesSynchronously()
}

이 접근법에 대해 내가 좋아하는 것은 내 보내지 않은 메소드를 보면 종속성이 무엇인지 명확하게 볼 수 있다는 것입니다. 동시에 내보내는 API는 훨씬 깨끗하고 매개 변수가 적습니다. 여기서 진정한 종속성은 모든 인터페이스 자체를 구현하는 상위 수신기 일뿐이므로 전달해야 할 매개 변수가 적습니다. 그러나 모든 기능은 잠재적으로 기능의 한 부분 (하나, 두 개의 인터페이스)에만 의존하므로 리팩터링이 훨씬 쉬워집니다. 함수 시그니처를 보면 코드가 실제로 어떻게 결합되어 있는지 보는 것이 좋습니다. 코드 냄새를 막는 강력한 도구가 될 것 같습니다.

일을 쉽게하기 위해 여기 놀이터에서 코드를 실행할 수 있도록 모든 것을 하나의 파일에 넣었 지만 GitHub의 전체 예제를 확인하는 것이 좋습니다. 여기 slack.go 파일과 slack_test.go가 있습니다. . 있습니다.

그리고 여기 에 모든 것이 있습니다 🙂

답변

var getPage = get_page
func get_page (...

func downloader() {
    dl_slots = make(chan bool, DL_SLOT_AMOUNT) // Init the download slot semaphore
    content := getPage(BASE_URL)
    links_regexp := regexp.MustCompile(LIST_LINK_REGEXP)
    matches := links_regexp.FindAllStringSubmatch(content, -1)
    for _, match := range matches{
        go serie_dl(match[1], match[2])
    }
}

func TestDownloader (t *testing.T) {
    origGetPage := getPage
    getPage = mock_get_page
    defer func() {getPage = origGatePage}()
    // The rest to be written
}

// define mock_get_page and rest of the codes
func mock_get_page (....

func getPage(url string) string {
  if GetPageMock != nil {
    return GetPageMock()
  }

  // getPage real implementation goes here!
}

func downloader() {
  if GetPageMock != nil {
    return GetPageMock()
  }

  // getPage real implementation goes here!
}

var GetPageMock func(url string) string = nil
var DownloaderMock func() = nil

// download.go
func getPage(url string) string {
  if m.GetPageMock != nil {
    return m.GetPageMock()
  }

  // getPage real implementation goes here!
}

func downloader() {
  if m.GetPageMock != nil {
    return m.GetPageMock()
  }

  // getPage real implementation goes here!
}

type MockHandler struct {
  GetPage func(url string) string
  Downloader func()
}

var m *MockHandler = new(MockHandler)

func Mock(handler *MockHandler) {
  m = handler
}

// download_test.go
func GetPageMock(url string) string {
  // ...
}

func TestDownloader(t *testing.T) {
  Mock(&MockHandler{
    GetPage: GetPageMock,
  })

  // Test implementation goes here!

  Mock(new(MockHandler)) // Reset mocked functions
}

type AA struct {
 //...
}
func (a *AA) OriginalFunc() {
//...
}

var a *AA

func NewFunc(a *AA) {
 //...
}

monkey.PatchMethod(reflect.TypeOf(a), "OriginalFunc", NewFunc)