package declaration

import (
	"strings"
	"testing"
)

func aDaemon() *Daemon {
	return &Daemon{
		ID: "server", Type: TypeDaemon, Name: "greeter",
		Source: "https://store.invalid/greeter/daemon",
		Digest: "sha256:" + strings.Repeat("a", 64),
		Run:    []string{"node", "index.js"},
	}
}

// A daemon is part of the vocabulary, or a declaration carrying one is refused whole.
func TestADaemonIsSomethingTheHostSpeaks(t *testing.T) {
	var found bool
	for _, kind := range Vocabulary() {
		if kind == TypeDaemon {
			found = true
		}
	}
	if !found {
		t.Fatal("a daemon cannot be declared, so a module that declares one is refused")
	}
	if newOf(TypeDaemon) == nil {
		t.Fatal("the decoder has no daemon, so one would be refused as an unknown kind")
	}
}

// **Pinned by digest, like everything else that crosses a network.** A bundle fetched by a
// reference somebody can repoint is not pinned, and it is the one thing on a machine that would
// then be running code nobody reviewed.
func TestADaemonsBundleMustBePinned(t *testing.T) {
	for _, bad := range []string{"", "latest", "sha256:short", strings.Repeat("a", 64)} {
		d := aDaemon()
		d.Digest = bad
		if problems := d.validate("a daemon", false); len(problems) == 0 {
			t.Fatalf("a daemon pinned by %q was accepted", bad)
		}
	}
}

// What to run is named, never inferred. Guessing an entrypoint from which files are present makes
// a daemon change what it runs when somebody adds a file.
func TestADaemonMustSayWhatToRun(t *testing.T) {
	d := aDaemon()
	d.Run = nil
	if problems := d.validate("a daemon", false); len(problems) == 0 {
		t.Fatal("a daemon with no command was accepted")
	}
}

// Its name becomes a unit name and a path, so a separator in it would write somewhere nobody meant.
func TestADaemonsNameCannotEscapeItsUnit(t *testing.T) {
	for _, bad := range []string{"", "../escape", "two words", "a/b"} {
		d := aDaemon()
		d.Name = bad
		if problems := d.validate("a daemon", false); len(problems) == 0 {
			t.Fatalf("a daemon called %q was accepted", bad)
		}
	}
}

// And a well-formed one is accepted, or the tests above prove only that everything is refused.
func TestAWellFormedDaemonIsAccepted(t *testing.T) {
	if problems := aDaemon().validate("a daemon", false); len(problems) != 0 {
		t.Fatalf("a well-formed daemon was refused: %v", problems)
	}
}