Adapter Pattern — Find the Bug¶

package payments

type StripeAdapter struct { client *StripeClient }

func (a *StripeAdapter) Charge(ctx context.Context, amount int) error {
    return a.client.Charge(amount)
}

// constructor:
func NewStripeAdapter(c *StripeClient) *StripeAdapter {
    return &StripeAdapter{client: c}
}

var p *StripeAdapter = payments.NewStripeAdapter(client)
service.SetPayer(p)

type LegacyMailer struct{ /* no context support */ }
func (m *LegacyMailer) Deliver(to, subject, body string) error { /* ... */ }

type MailerAdapter struct { Inner *LegacyMailer }

func (a *MailerAdapter) Send(ctx context.Context, msg Message) error {
    return a.Inner.Deliver(msg.To, msg.Subject, msg.Body)
}

type Adapter struct { Inner *Source }

func (a *Adapter) Do(ctx context.Context) error {
    a.Inner.LegacyDo()
    return nil
}

type StructuredLogger interface {
    Info(msg string, kv ...any)
}

type LegacyLogger struct{}
func (l *LegacyLogger) Print(format string, args ...any) {
    fmt.Printf(format+"\n", args...)
}

type LogAdapter struct{ L *LegacyLogger }

func (a *LogAdapter) Info(msg string, kv ...any) {
    a.L.Print(msg)
}

type Cacher struct {
    Inner Payer
    cache map[string]chargeResult
}

func (c *Cacher) Charge(ctx context.Context, amount int) error {
    if r, ok := c.cache[fmt.Sprintf("%d", amount)]; ok { return r.err }
    err := c.Inner.Charge(ctx, amount)
    c.cache[fmt.Sprintf("%d", amount)] = chargeResult{err: err}
    return err
}

type Charger interface {
    Charge(ctx context.Context, amount int) error
}

type ChargerFunc func(ctx context.Context, amount int) error

func (f *ChargerFunc) Charge(ctx context.Context, amount int) error {
    return (*f)(ctx, amount)
}

c := ChargerFunc(myFunc)
process(&c)

func NewAdapter(enabled bool) Payer {
    var a *PayerAdapter
    if enabled {
        a = &PayerAdapter{client: client}
    }
    return a
}

p := NewAdapter(false)
if p == nil {
    log.Println("not enabled")
    return
}
p.Charge(ctx, 100) // !

type Counter struct{ n int }
func (c *Counter) Inc() { c.n++ }
func (c *Counter) Value() int { return c.n }

type Adapter struct{ Inner Counter }  // !

func (a *Adapter) Tick() { a.Inner.Inc() }

c := Counter{}
a := &Adapter{Inner: c}
a.Tick()
fmt.Println(c.Value()) // expecting 1

type LegacyMsg struct { Body string }
type NewMsg    struct { Body, Subject string; Recipients []string }

type LegacyToNew struct{ L LegacyMailer }

func (a *LegacyToNew) Send(to []string, subject, body string) error {
    return a.L.SendLegacy(LegacyMsg{Body: body})
}

type NewToLegacy struct{ N NewMailer }

func (a *NewToLegacy) SendLegacy(m LegacyMsg) error {
    return a.N.Send([]string{}, "", m.Body)
}

type Mailer interface{ Send(msg Msg) error }

type Adapter struct { Inner Mailer }

func (a *Adapter) Send(msg Msg) error {
    log.Printf("Send: %v", msg)
    return a.Send(msg)  // !
}

type Adapter struct {
    apiKey string
    client *Client
}

func (a *Adapter) Charge(ctx context.Context, amount int) error {
    if a.client == nil {
        a.client = NewClient(a.apiKey)
    }
    return a.client.Charge(amount)
}

type LoggingPayer struct { Inner Payer; Log *log.Logger }
func (l *LoggingPayer) Charge(ctx context.Context, amount int) error {
    l.Log.Printf("Charge: %d", amount)
    err := l.Inner.Charge(ctx, amount)
    if err != nil {
        l.Log.Printf("Charge failed: %v", err)
        // !
    }
    return nil
}

type RetryingPayer struct { Inner Payer; Attempts int }
func (r *RetryingPayer) Charge(ctx context.Context, amount int) error {
    for i := 0; i < r.Attempts; i++ {
        if err := r.Inner.Charge(ctx, amount); err == nil { return nil }
    }
    return errors.New("retry exhausted")
}

// chain:
var p Payer = realPayer
p = &LoggingPayer{Inner: p, Log: log.Default()}
p = &RetryingPayer{Inner: p, Attempts: 3}

type Adapter struct{ inner *SQLClient }

func (a *Adapter) Get(id string) ([]byte, error) { return a.inner.Get(id) }

func (a *Adapter) Inner() *SQLClient { return a.inner }

adapter := NewAdapter()
adapter.Inner().BulkInsert(items)  // bypasses the abstraction

type Adapter struct{ inner *Source }

func NewAdapter(source *Source) *Adapter {
    a := &Adapter{inner: source}
    go a.healthCheck()  // !
    return a
}

func (a *Adapter) healthCheck() {
    for {
        time.Sleep(30 * time.Second)
        a.inner.Ping()
    }
}

type Reader interface { Read(p []byte) (int, error) }

type LoggingReader struct { Inner Reader }

func (l *LoggingReader) Read(p []byte) (int, error) {
    if br, ok := l.Inner.(*bytes.Reader); ok {
        br.Seek(0, io.SeekStart)  // !
    }
    return l.Inner.Read(p)
}