package main

import (
    "errors"
    "log"
    "testing"
)

type HesteService interface {
    CreateHest(name string) error
    DeleteHest(name string) error
}

type InMemoryHesteService struct {
    heste map[string]string
}

func NewInMemoryHesteService() HesteService {
    return &InMemoryHesteService{
        heste: make(map[string]string),
    }
}

func (s *InMemoryHesteService) CreateHest(name string) error {
    s.heste[name] = "heeeeest"
    return nil
}

func (s *InMemoryHesteService) DeleteHest(name string) error {
    delete(s.heste, name)
    return nil
}

type mockHesteService struct {
    // returns this error on all ops
    err error
}

func NewMockHesteService(err error) HesteService {
    return &mockHesteService{
        err: err,
    }
}

func (s *mockHesteService) CreateHest(name string) error {
    return s.err
}

func (s *mockHesteService) DeleteHest(name string) error {
    return s.err
}

type App struct {
    Heste HesteService
}

func (a *App) Run() {

    if err := a.Heste.CreateHest("Pernille"); err != nil {
        log.Fatalf("error: %v", err)
    }

}

func NewApp() *App {
    return &App{
        Heste: NewInMemoryHesteService(),
    }
}

func main() {

    a := NewApp()
    a.Run()

}

func TestAppErrors(t *testing.T) {

    a := &App{
        Heste: NewMockHesteService(errors.New("virker ikke hehehe")),
    }

    a.Run()
}