mesh-host/internal/apply/giveback_test.go

package apply

import (
	"strings"
	"testing"

	"github.com/novox/mesh-host/internal/store"
)

// A unit the mesh found running and enabled, and held stopped and disabled by its own declaration, is
// given back running and enabled when that declaration goes (the zfs module holds the distribution's
// scrub timer stopped while its own timer scrubs the pool; unassigning it must not leave the pool with no
// schedule at all). The report says so.
func TestAUnitTheMeshStoppedAndDisabledIsGivenBackRunningAndEnabled(t *testing.T) {
	m := unitsMachine(map[string]*fakeUnit{
		"zfs-scrub-weekly@storage.timer": {active: "active", enabled: "enabled"},
	})
	_, state, err := applyOn(t, `{"declaration":1,"resources":[
	  {"id":"zfs.distribution-weekly","type":"service","unit":"zfs-scrub-weekly@storage.timer","state":"stopped","boot":"disabled"}]}`,
		store.State{}, m)
	if err != nil {
		t.Fatal(err)
	}
	if u := m.units["zfs-scrub-weekly@storage.timer"]; u.active != "inactive" || u.enabled != "disabled" {
		t.Fatalf("the fixture did not stop and disable it: %s and %s", u.active, u.enabled)
	}
	report, _, err := applyOn(t, nothingButA(t), copyOf(t, state), m)
	if err != nil {
		t.Fatal(err)
	}
	if u := m.units["zfs-scrub-weekly@storage.timer"]; u.active != "active" || u.enabled != "enabled" {
		t.Errorf("given back as %s and %s; it was found running and enabled", u.active, u.enabled)
	}
	said := ""
	for _, r := range report.Outcomes {
		if r.ID == "zfs.distribution-weekly" {
			said = r.Action + ": " + r.Detail
		}
	}
	if !strings.HasPrefix(said, "restored: ") || !strings.Contains(said, "started") || !strings.Contains(said, "enabled at boot") {
		t.Errorf("the report says %q", said)
	}
}

// Only what the mesh's own declaration did is undone: a unit the mesh held stopped that was found stopped
// stays stopped, and one found running that the mesh never stopped is left running as before.
func TestOnlyWhatTheMeshsDeclarationStoppedIsStartedAgain(t *testing.T) {
	m := unitsMachine(map[string]*fakeUnit{
		"found-stopped.timer": {active: "inactive", enabled: "disabled"},
		"left-running.timer":  {active: "active", enabled: "enabled"},
	})
	_, state, err := applyOn(t, `{"declaration":1,"resources":[
	  {"id":"a","type":"service","unit":"found-stopped.timer","state":"stopped","boot":"disabled"},
	  {"id":"b","type":"service","unit":"left-running.timer","state":"running","boot":"enabled"}]}`,
		store.State{}, m)
	if err != nil {
		t.Fatal(err)
	}
	if _, _, err := applyOn(t, nothingButA(t), state, m); err != nil {
		t.Fatal(err)
	}
	if u := m.units["found-stopped.timer"]; u.active != "inactive" || u.enabled != "disabled" {
		t.Errorf("found stopped and disabled, given back as %s and %s", u.active, u.enabled)
	}
	if u := m.units["left-running.timer"]; u.active != "active" || u.enabled != "enabled" {
		t.Errorf("found running, given back as %s and %s", u.active, u.enabled)
	}
}

// A record from before the host kept what it declared says nothing about who stopped the unit: it is
// left as it is, never started.
func TestARecordWithoutWhatWasDeclaredStartsNothing(t *testing.T) {
	m := unitsMachine(map[string]*fakeUnit{"old.timer": {active: "inactive", enabled: "disabled"}})
	state := store.State{}
	state.Record(store.Applied{ID: "old", Type: "service", Target: "old.timer", Origin: store.OriginDeclared,
		Found: &store.FoundUnit{Unit: "old.timer", State: "running", Boot: "enabled"}})
	if _, _, err := applyOn(t, nothingButA(t), state, m); err != nil {
		t.Fatal(err)
	}
	if u := m.units["old.timer"]; u.active != "inactive" || u.enabled != "disabled" {
		t.Errorf("an old record started %s and %s", u.active, u.enabled)
	}
}

// The plan says it before the apply does it.
func TestThePlanSaysAStoppedUnitIsStartedAgain(t *testing.T) {
	m := unitsMachine(map[string]*fakeUnit{"zfs-scrub-weekly@storage.timer": {active: "active", enabled: "enabled"}})
	_, state, err := applyOn(t, `{"declaration":1,"resources":[
	  {"id":"w","type":"service","unit":"zfs-scrub-weekly@storage.timer","state":"stopped","boot":"disabled"}]}`,
		store.State{}, m)
	if err != nil {
		t.Fatal(err)
	}
	said := ""
	for _, s := range Plan(parse(t, nothingButA(t)), state, store.OriginDeclared) {
		if s.ID == "w" {
			said = s.Verb + ": " + s.Why
		}
	}
	if !strings.HasPrefix(said, "restore: ") || !strings.Contains(said, "started and enabled at boot again") {
		t.Errorf("the plan says %q", said)
	}
}