package ensure

import (
	"fmt"
	"testing"
)

type (
	Dummy struct {
		enforced bool
		exec     func() error
	}
)

func TestRunner(t *testing.T) {
	d := &Dummy{}
	r := Runner{
		States: []Ensurer{d},
	}
	if err := r.Ensure(); err != nil {
		t.Fatalf("ensure failed with: %s", err)
	}
	if !d.enforced {
		t.Fatalf("state was not ensured")
	}
}

func TestRecursiveRunner(t *testing.T) {
	d := &Dummy{}
	r := Runner{
		States: []Ensurer{&Runner{States: []Ensurer{d}}},
	}
	if err := r.Ensure(); err != nil {
		t.Fatalf("ensure failed with: %s", err)
	}
	if !d.enforced {
		t.Fatalf("state was not ensured")
	}
}

func TestWithCheck(t *testing.T) {
	d := &Dummy{}
	r := Runner{
		Is:     func() bool { return true },
		States: []Ensurer{d},
	}
	if err := r.Ensure(); err != nil {
		t.Fatalf("ensure failed with: %s", err)
	}
	if d.enforced {
		t.Fatalf("state was ensured but shouldn't be")
	}
}

func TestWithError(t *testing.T) {
	d := &Dummy{exec: func() error { return fmt.Errorf("fail!") }}
	r := Runner{
		States: []Ensurer{d},
	}
	if err := r.Ensure(); err == nil {
		t.Fatalf("ensure should have failed")
	}
}

func TestWithParallel(t *testing.T) {
	d := &Dummy{}
	r := Runner{
		Parallel: true,
		States:   []Ensurer{d},
	}
	if err := r.Ensure(); err != nil {
		t.Fatalf("parallel should not have failed")
	}
	if !d.enforced {
		t.Fatalf("state was not enforced")
	}
}

func TestWithParallelWithError(t *testing.T) {
	d := &Dummy{exec: func() error { return fmt.Errorf("fail!") }}
	r := Runner{
		Parallel: true,
		States:   []Ensurer{d},
	}
	if err := r.Ensure(); err == nil {
		t.Fatalf("parallel should have failed")
	}
}

func (d *Dummy) Ensure() error {
	d.enforced = true
	if d.exec != nil {
		return d.exec()
	}
	return nil
}