/dev/null is a character device but not a terminal. Treating it as a TTY made docker run -it fail under docker exec without -t, which broke the Dokku-in-Docker storage bats job in CI.
266 lines
8.7 KiB
Go
266 lines
8.7 KiB
Go
package storage
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
. "github.com/onsi/gomega"
|
|
)
|
|
|
|
func TestEnsureDockerLocalPathCreatesDefaultPath(t *testing.T) {
|
|
RegisterTestingT(t)
|
|
withTempLibRoot(t)
|
|
|
|
hostPath := filepath.Join(GetStorageDirectory(), "demo")
|
|
entry := &Entry{Name: "demo", Scheduler: SchedulerDockerLocal, HostPath: hostPath}
|
|
|
|
Expect(ensureDockerLocalPath(entry)).To(Succeed())
|
|
Expect(hostPath).To(BeADirectory())
|
|
|
|
// Idempotent: a second run leaves the existing directory in place.
|
|
Expect(ensureDockerLocalPath(entry)).To(Succeed())
|
|
Expect(hostPath).To(BeADirectory())
|
|
}
|
|
|
|
// TestEnsureDockerLocalPathSkipsNamedVolumes guards the docker named-volume
|
|
// case: the host path is a token the docker engine resolves, not a path on
|
|
// disk, so stat'ing and creating it would produce a stray directory in
|
|
// whatever working directory the command happened to run from.
|
|
func TestEnsureDockerLocalPathSkipsNamedVolumes(t *testing.T) {
|
|
RegisterTestingT(t)
|
|
withTempLibRoot(t)
|
|
|
|
cwd := t.TempDir()
|
|
t.Chdir(cwd)
|
|
|
|
entry := &Entry{Name: "demo", Scheduler: SchedulerDockerLocal, HostPath: "myvolume"}
|
|
Expect(ensureDockerLocalPath(entry)).To(Succeed())
|
|
Expect(filepath.Join(cwd, "myvolume")).NotTo(BeADirectory())
|
|
}
|
|
|
|
func TestEnsureDockerLocalPathRefusesModeOnCustomPath(t *testing.T) {
|
|
RegisterTestingT(t)
|
|
withTempLibRoot(t)
|
|
|
|
entry := &Entry{
|
|
Name: "demo",
|
|
Scheduler: SchedulerDockerLocal,
|
|
HostPath: filepath.Join(t.TempDir(), "custom"),
|
|
Mode: "0777",
|
|
}
|
|
|
|
err := ensureDockerLocalPath(entry)
|
|
Expect(err).To(HaveOccurred())
|
|
Expect(err.Error()).To(ContainSubstring("--mode is only supported when the storage entry uses the default host path"))
|
|
Expect(entry.HostPath).NotTo(BeADirectory())
|
|
}
|
|
|
|
func TestEnsureDockerLocalPathRefusesChownOnCustomPath(t *testing.T) {
|
|
RegisterTestingT(t)
|
|
withTempLibRoot(t)
|
|
|
|
entry := &Entry{
|
|
Name: "demo",
|
|
Scheduler: SchedulerDockerLocal,
|
|
HostPath: filepath.Join(t.TempDir(), "custom"),
|
|
Chown: "herokuish",
|
|
}
|
|
|
|
err := ensureDockerLocalPath(entry)
|
|
Expect(err).To(HaveOccurred())
|
|
Expect(err.Error()).To(ContainSubstring("--chown is only supported when the storage entry uses the default host path"))
|
|
}
|
|
|
|
// TestEnsureDockerLocalPathAllowsChownFalseOnCustomPath documents that the
|
|
// escape hatch the refusal message points at actually works.
|
|
func TestEnsureDockerLocalPathAllowsChownFalseOnCustomPath(t *testing.T) {
|
|
RegisterTestingT(t)
|
|
withTempLibRoot(t)
|
|
|
|
hostPath := filepath.Join(t.TempDir(), "custom")
|
|
entry := &Entry{Name: "demo", Scheduler: SchedulerDockerLocal, HostPath: hostPath, Chown: "false"}
|
|
|
|
Expect(ensureDockerLocalPath(entry)).To(Succeed())
|
|
Expect(hostPath).To(BeADirectory())
|
|
}
|
|
|
|
func TestApplyPropertyChangeScalars(t *testing.T) {
|
|
RegisterTestingT(t)
|
|
|
|
entry := &Entry{Name: "demo", Scheduler: SchedulerDockerLocal}
|
|
|
|
Expect(applyPropertyChange(entry, PropertyChange{Property: "chown", Value: "herokuish"})).To(Succeed())
|
|
Expect(entry.Chown).To(Equal("herokuish"))
|
|
|
|
Expect(applyPropertyChange(entry, PropertyChange{Property: "namespace", Value: "dokku"})).To(Succeed())
|
|
Expect(entry.Namespace).To(Equal("dokku"))
|
|
|
|
Expect(applyPropertyChange(entry, PropertyChange{Property: "reclaim-policy", Value: ReclaimPolicyDelete})).To(Succeed())
|
|
Expect(entry.ReclaimPolicy).To(Equal(ReclaimPolicyDelete))
|
|
|
|
Expect(applyPropertyChange(entry, PropertyChange{Property: "size", Value: "2Gi"})).To(Succeed())
|
|
Expect(entry.Size).To(Equal("2Gi"))
|
|
|
|
// mode is canonicalized on the way in
|
|
Expect(applyPropertyChange(entry, PropertyChange{Property: "mode", Value: "770"})).To(Succeed())
|
|
Expect(entry.Mode).To(Equal("0770"))
|
|
}
|
|
|
|
// TestApplyPropertyChangeUnsets is the hole this shape exists to close: an
|
|
// empty value clears the field rather than being indistinguishable from an
|
|
// omitted flag.
|
|
func TestApplyPropertyChangeUnsets(t *testing.T) {
|
|
RegisterTestingT(t)
|
|
|
|
entry := &Entry{
|
|
Name: "demo",
|
|
Scheduler: SchedulerDockerLocal,
|
|
Chown: "herokuish",
|
|
Mode: "0770",
|
|
Namespace: "dokku",
|
|
ReclaimPolicy: ReclaimPolicyDelete,
|
|
Size: "2Gi",
|
|
}
|
|
|
|
for _, property := range []string{"chown", "mode", "namespace", "reclaim-policy", "size"} {
|
|
Expect(applyPropertyChange(entry, PropertyChange{Property: property})).To(Succeed(), "unsetting %q", property)
|
|
}
|
|
|
|
Expect(entry.Chown).To(BeEmpty())
|
|
Expect(entry.Mode).To(BeEmpty())
|
|
Expect(entry.Namespace).To(BeEmpty())
|
|
Expect(entry.ReclaimPolicy).To(BeEmpty())
|
|
Expect(entry.Size).To(BeEmpty())
|
|
}
|
|
|
|
func TestApplyPropertyChangeRejectsInvalidInput(t *testing.T) {
|
|
RegisterTestingT(t)
|
|
|
|
entry := &Entry{Name: "demo", Scheduler: SchedulerDockerLocal}
|
|
|
|
err := applyPropertyChange(entry, PropertyChange{Property: "bogus", Value: "x"})
|
|
Expect(err).To(HaveOccurred())
|
|
Expect(err.Error()).To(ContainSubstring("Invalid property specified, valid properties include: access-mode, chown, mode, namespace, reclaim-policy, size, storage-class-name"))
|
|
|
|
err = applyPropertyChange(entry, PropertyChange{Property: "", Value: "x"})
|
|
Expect(err).To(HaveOccurred())
|
|
Expect(err.Error()).To(ContainSubstring("No property specified"))
|
|
|
|
err = applyPropertyChange(entry, PropertyChange{Property: "mode", Value: "0888"})
|
|
Expect(err).To(HaveOccurred())
|
|
Expect(err.Error()).To(ContainSubstring("Unsupported directory mode"))
|
|
}
|
|
|
|
// TestApplyPropertyChangeRefusesInPlaceSwaps covers both a differing value
|
|
// and an empty one, since clearing a bound PVC's access-mode or storage
|
|
// class is equally a change Kubernetes cannot apply.
|
|
func TestApplyPropertyChangeRefusesInPlaceSwaps(t *testing.T) {
|
|
RegisterTestingT(t)
|
|
|
|
entry := &Entry{
|
|
Name: "demo",
|
|
Scheduler: SchedulerK3s,
|
|
Size: "2Gi",
|
|
AccessMode: "ReadWriteOnce",
|
|
StorageClass: "longhorn",
|
|
}
|
|
|
|
err := applyPropertyChange(entry, PropertyChange{Property: "access-mode", Value: "ReadWriteMany"})
|
|
Expect(err).To(HaveOccurred())
|
|
Expect(err.Error()).To(ContainSubstring("cannot change access-mode in place"))
|
|
|
|
err = applyPropertyChange(entry, PropertyChange{Property: "access-mode"})
|
|
Expect(err).To(HaveOccurred())
|
|
Expect(err.Error()).To(ContainSubstring("cannot change access-mode in place"))
|
|
|
|
err = applyPropertyChange(entry, PropertyChange{Property: "storage-class-name", Value: "other"})
|
|
Expect(err).To(HaveOccurred())
|
|
Expect(err.Error()).To(ContainSubstring("cannot change storage-class-name in place"))
|
|
|
|
err = applyPropertyChange(entry, PropertyChange{Property: "storage-class-name"})
|
|
Expect(err).To(HaveOccurred())
|
|
Expect(err.Error()).To(ContainSubstring("cannot change storage-class-name in place"))
|
|
|
|
// Re-stating the current value is a no-op, not a change.
|
|
Expect(applyPropertyChange(entry, PropertyChange{Property: "access-mode", Value: "ReadWriteOnce"})).To(Succeed())
|
|
Expect(applyPropertyChange(entry, PropertyChange{Property: "storage-class-name", Value: "longhorn"})).To(Succeed())
|
|
}
|
|
|
|
func TestCommandSetPersistsAndValidates(t *testing.T) {
|
|
RegisterTestingT(t)
|
|
withTempLibRoot(t)
|
|
stageDockerLocalEntry(t, "demo")
|
|
|
|
Expect(CommandSet(CommandSetInput{
|
|
Name: "demo",
|
|
Changes: []PropertyChange{{Property: "namespace", Value: "dokku"}},
|
|
})).To(Succeed())
|
|
|
|
loaded, err := LoadEntry("demo")
|
|
Expect(err).NotTo(HaveOccurred())
|
|
Expect(loaded.Namespace).To(Equal("dokku"))
|
|
|
|
// An invalid change leaves the stored entry untouched.
|
|
err = CommandSet(CommandSetInput{
|
|
Name: "demo",
|
|
Changes: []PropertyChange{{Property: "bogus", Value: "x"}},
|
|
})
|
|
Expect(err).To(HaveOccurred())
|
|
|
|
loaded, err = LoadEntry("demo")
|
|
Expect(err).NotTo(HaveOccurred())
|
|
Expect(loaded.Namespace).To(Equal("dokku"))
|
|
|
|
err = CommandSet(CommandSetInput{
|
|
Name: "missing",
|
|
Changes: []PropertyChange{{Property: "namespace", Value: "dokku"}},
|
|
})
|
|
Expect(err).To(HaveOccurred())
|
|
Expect(err.Error()).To(ContainSubstring("does not exist"))
|
|
}
|
|
|
|
// TestStdinModesDevNullIsNotTTY guards the CI / docker-exec path: stdin is
|
|
// often /dev/null, which is a character device but not a terminal. ModeCharDevice
|
|
// alone would request docker run -it and fail attach.
|
|
func TestStdinModesDevNullIsNotTTY(t *testing.T) {
|
|
devNull, err := os.Open(os.DevNull)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer devNull.Close()
|
|
|
|
old := os.Stdin
|
|
os.Stdin = devNull
|
|
t.Cleanup(func() { os.Stdin = old })
|
|
|
|
interactive, tty := stdinModes()
|
|
if tty {
|
|
t.Fatalf("expected tty=false for /dev/null, got tty=true interactive=%v", interactive)
|
|
}
|
|
if interactive {
|
|
t.Fatalf("expected interactive=false for /dev/null, got interactive=true")
|
|
}
|
|
}
|
|
|
|
func TestStdinModesNamedPipeIsInteractiveWithoutTTY(t *testing.T) {
|
|
r, w, err := os.Pipe()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer r.Close()
|
|
defer w.Close()
|
|
|
|
old := os.Stdin
|
|
os.Stdin = r
|
|
t.Cleanup(func() { os.Stdin = old })
|
|
|
|
interactive, tty := stdinModes()
|
|
if tty {
|
|
t.Fatalf("expected tty=false for a pipe, got tty=true")
|
|
}
|
|
if !interactive {
|
|
t.Fatalf("expected interactive=true for a named pipe")
|
|
}
|
|
}
|