тестирование закрытия

Question

у меня есть следующая функция, которая возвращает замыкание в golang, любая идея / ссылка, как можно написать тест для него?

  type (
    OrderRepoInterface interface {
       func save(msg Message) error
    }

    // OrderAggregation represents an event handler
    EventHandler struct {
        repo         OrderRepoInterface // in main.go i pass a concrete repository here
    }

    VersionedEventHandler struct {
       function func(msg *Message) error
    }

    Message struct {
       version int
       payload string
    }

 )

    func (o *EventHandler) OnOrderWasCreated() VersionedEventHandler {
        return func(msg *Message) error {
            msg.version = 1
            err := o.repo.save(msg)
            return err
        }
    }

ps

это не настоящий кодПоскольку я использую пару библиотек, я разработал этот вопрос с помощью приведенного выше кода, надеясь, что он даст представление о том, чего я пытаюсь достичь, поэтому он может не скомпилировать

edit

я хочу увидеть некоторые идиоматические примеры или идеи, в которых функция, возвращающая анонимную функцию, проверена на ходу.

, поэтому мне не нужно рабочее решение.

Answer 1

Было бы полезно иметь рабочий пример, поэтому я предоставил один.В этом простом случае, вероятно, было бы достаточно иметь только слова, которые отображают номера версий в функции, которые обрабатывают сохранение заказа.Но я попытался реализовать ближе к тому, что вы предоставили, с интерфейсом обработчика заказов.

Для тестирования вам понадобится какой-то журнал, чтобы фиксировать побочные эффекты, чтобы вы могли убедиться, что правильный обработчикбудучи призваннымДля этого я добавил глобальный строковый массив с именем eventLog, к которому можно добавить.Для тестирования вы захотите создать больше MultiVersionHandlers и больше тестовых сообщений.

Вы захотите убедиться, что обработчики реагируют на тестовые сообщения так, как вы себе представляете, вызвав метод save () для обработчиков и сравнив содержимое EventLog с тем, что вы ожидали.Кроме того, вы хотите создавать сообщения, которые должны потерпеть неудачу.Эти сообщения не будут соответствовать версии, поддерживаемой обработчиком.Затем вы убедитесь, что возвращается правильное значение ошибки.Я сделал кое-что для тебя.

package main

import "fmt"

type MultiVersionHandler struct {
    handlers map[int]OrderRepoInterface
}

type Message struct {
    version int
    payload string
}

type OrderRepoInterface interface {
    save(Message) error
}

type OrderHandler struct {
    saveHandler func(Message) error
}

// let's implement the OrderRepoInterface for a regular order handler
func (oh OrderHandler) save(msg Message) error {
    return oh.saveHandler(msg)
}

// let's implement the OrderRepoInterface for a multi version order handler
func (mh MultiVersionHandler) save(msg Message) error {

    if handler, ok := mh.handlers[msg.version]; ok {
        return handler.save(msg)
    }

    return fmt.Errorf("doesn't support version %d, payload %q",
            msg.version,
            msg.payload)

}

// We will use eventLog capture simulations of a log of events which
// happen via our handlers. Useful for verification.
var eventLog = []string{}

func main() {

    multiHandler := MakeMultiHandler()

    msg1 := Message{payload: "make me a burger", version: 1}

    msg2 := Message{payload: "make me a cake", version: 2}

    msg3 := Message{payload: "make me a robot", version: 3}

    // Create a message which has no handler.
    // This message for version 4, should cause an error.
    msg4 := Message{payload: "make me a planet", version: 4}

    err := multiHandler.save(msg1)
    err  = multiHandler.save(msg2)
    err  = multiHandler.save(msg3)
    err  = multiHandler.save(msg4)
    if err != nil {
        fmt.Printf("Expecting an error: %q\n", err.Error())
        // Expecting an error: 
        //  "does not have a handler for version 4.
        //   Cannot process payload "make me a planet""

    }

    fmt.Printf("Event Log:%#v", eventLog)
    // Event Log:[]string{
    //   "Amy will make me a burger", 
    //   "Brandy will make me a cake", 
    //   "Caleb will make me a robot"}        



}

// This makes a multi version handler for an example. 
// You should create more of these for testing different scenarios.
func MakeMultiHandler() OrderRepoInterface {

    amy := OrderHandler{
        saveHandler: func(msg Message) error {
            action := "Amy will " + msg.payload
            eventLog = append(eventLog, action)
            return nil
        },
    }

    brandy := OrderHandler{
        saveHandler: func(msg Message) error {
            action := "Brandy will " + msg.payload
            eventLog = append(eventLog, action)
            return nil
        },
    }

    caleb := OrderHandler{
        saveHandler: func(msg Message) error {
            action := "Caleb will " + msg.payload
            eventLog = append(eventLog, action)
            return nil
        },
    }

    multiHandler := MultiVersionHandler{
        handlers: map[int]OrderRepoInterface{
            1: amy,    // amy should handle version 1 message
            2: brandy, // brandy should handle version 2 message
            3: caleb,  // caleb should handle version 3 message
        },
    }

    return multiHandler

}