func TestCreateSSHShell(t *testing.T) {
api := tests.NewMockAPI()
s, _ := tests.NewSSHServer()
port, err := s.Start()
if err != nil {
t.Fatalf("Error starting ssh server: %s", err)
}
d := &tests.MockDriver{
Port: port,
CurrentState: state.Running,
BaseDriver: drivers.BaseDriver{
IPAddress: "127.0.0.1",
SSHKeyPath: "",
},
}
api.Hosts[constants.MachineName] = &host.Host{Driver: d}
cliArgs := []string{"exit"}
if err := CreateSSHShell(api, cliArgs); err != nil {
t.Fatalf("Error running ssh command: %s", err)
}
if s.HadASessionRequested != true {
t.Fatalf("Expected ssh session to be run")
}
}
func TestHostGetLogs(t *testing.T) {
api := tests.NewMockAPI()
s, _ := tests.NewSSHServer()
port, err := s.Start()
if err != nil {
t.Fatalf("Error starting ssh server: %s", err)
}
d := &tests.MockDriver{
Port: port,
BaseDriver: drivers.BaseDriver{
IPAddress: "127.0.0.1",
SSHKeyPath: "",
},
}
api.Hosts[constants.MachineName] = &host.Host{Driver: d}
if _, err := GetHostLogs(api); err != nil {
t.Fatalf("Error getting host logs: %s", err)
}
if _, ok := s.Commands[logsCommand]; !ok {
t.Fatalf("Expected command not run: %s", logsCommand)
}
}
func TestStartHost(t *testing.T) {
api := tests.NewMockAPI()
md := &tests.MockDetector{Provisioner: &tests.MockProvisioner{}}
provision.SetDetector(md)
h, err := StartHost(api, defaultMachineConfig)
if err != nil {
t.Fatal("Error starting host.")
}
if h.Name != constants.MachineName {
t.Fatalf("Machine created with incorrect name: %s", h.Name)
}
if exists, _ := api.Exists(h.Name); !exists {
t.Fatal("Machine not saved.")
}
if s, _ := h.Driver.GetState(); s != state.Running {
t.Fatalf("Machine not started.")
}
// Provision regenerates Docker certs. This happens automatically during create,
// so we should only call it again if the host already exists.
if md.Provisioner.Provisioned {
t.Fatalf("Did not expect Provision to be called")
}
}
func TestGetHostDockerEnv(t *testing.T) {
tempDir := tests.MakeTempDir()
defer os.RemoveAll(tempDir)
api := tests.NewMockAPI()
h, err := createHost(api, defaultMachineConfig)
if err != nil {
t.Fatalf("Error creating host: %v", err)
}
d := &tests.MockDriver{
BaseDriver: drivers.BaseDriver{
IPAddress: "127.0.0.1",
},
}
h.Driver = d
envMap, err := GetHostDockerEnv(api)
if err != nil {
t.Fatalf("Unexpected error getting env: %s", err)
}
dockerEnvKeys := [...]string{
"DOCKER_TLS_VERIFY",
"DOCKER_HOST",
"DOCKER_CERT_PATH",
}
for _, dockerEnvKey := range dockerEnvKeys {
if _, hasKey := envMap[dockerEnvKey]; !hasKey {
t.Fatalf("Expected envMap[\"%s\"] key to be defined", dockerEnvKey)
}
}
}
func TestStartStoppedHost(t *testing.T) {
api := tests.NewMockAPI()
// Create an initial host.
h, err := createHost(api, defaultMachineConfig)
if err != nil {
t.Fatalf("Error creating host: %v", err)
}
d := tests.MockDriver{}
h.Driver = &d
d.CurrentState = state.Stopped
md := &tests.MockDetector{Provisioner: &tests.MockProvisioner{}}
provision.SetDetector(md)
h, err = StartHost(api, defaultMachineConfig)
if err != nil {
t.Fatal("Error starting host.")
}
if h.Name != constants.MachineName {
t.Fatalf("Machine created with incorrect name: %s", h.Name)
}
if s, _ := h.Driver.GetState(); s != state.Running {
t.Fatalf("Machine not started.")
}
if !api.SaveCalled {
t.Fatalf("Machine must be saved after starting.")
}
if !md.Provisioner.Provisioned {
t.Fatalf("Expected provision to be called")
}
}
func TestStartHostExists(t *testing.T) {
api := tests.NewMockAPI()
// Create an initial host.
_, err := createHost(api, defaultMachineConfig)
if err != nil {
t.Fatalf("Error creating host: %v", err)
}
// Make sure the next call to Create will fail, to assert it doesn't get called again.
api.CreateError = true
if err := api.Create(&host.Host{}); err == nil {
t.Fatal("api.Create did not fail, but should have.")
}
md := &tests.MockDetector{Provisioner: &tests.MockProvisioner{}}
provision.SetDetector(md)
// This should pass without calling Create because the host exists already.
h, err := StartHost(api, defaultMachineConfig)
if err != nil {
t.Fatal("Error starting host.")
}
if h.Name != constants.MachineName {
t.Fatalf("Machine created with incorrect name: %s", h.Name)
}
if s, _ := h.Driver.GetState(); s != state.Running {
t.Fatalf("Machine not started.")
}
if !md.Provisioner.Provisioned {
t.Fatalf("Expected provision to be called")
}
}
func TestDeleteHost(t *testing.T) {
api := tests.NewMockAPI()
createHost(api, defaultMachineConfig)
if err := DeleteHost(api); err != nil {
t.Fatalf("Unexpected error deleting host: %s", err)
}
}
func TestDeleteHostErrorDeletingFiles(t *testing.T) {
api := tests.NewMockAPI()
api.RemoveError = true
createHost(api, defaultMachineConfig)
if err := DeleteHost(api); err == nil {
t.Fatal("Expected error deleting host.")
}
}
func TestStopHost(t *testing.T) {
api := tests.NewMockAPI()
h, _ := createHost(api, defaultMachineConfig)
if err := StopHost(api); err != nil {
t.Fatal("An error should be thrown when stopping non-existing machine.")
}
if s, _ := h.Driver.GetState(); s != state.Stopped {
t.Fatalf("Machine not stopped. Currently in state: %s", s)
}
}
func TestDeleteHostErrorDeletingVM(t *testing.T) {
api := tests.NewMockAPI()
h, _ := createHost(api, defaultMachineConfig)
d := &tests.MockDriver{RemoveError: true}
h.Driver = d
if err := DeleteHost(api); err == nil {
t.Fatal("Expected error deleting host.")
}
}
func TestGetHostStatus(t *testing.T) {
api := tests.NewMockAPI()
checkState := func(expected string) {
s, err := GetHostStatus(api)
if err != nil {
t.Fatalf("Unexpected error getting status: %s", err)
}
if s != expected {
t.Fatalf("Expected status: %s, got %s", s, expected)
}
}
checkState("Does Not Exist")
createHost(api, defaultMachineConfig)
checkState(state.Running.String())
StopHost(api)
checkState(state.Stopped.String())
}
func TestGetLocalkubeStatus(t *testing.T) {
api := tests.NewMockAPI()
s, _ := tests.NewSSHServer()
port, err := s.Start()
if err != nil {
t.Fatalf("Error starting ssh server: %s", err)
}
d := &tests.MockDriver{
Port: port,
BaseDriver: drivers.BaseDriver{
IPAddress: "127.0.0.1",
SSHKeyPath: "",
},
}
api.Hosts[constants.MachineName] = &host.Host{Driver: d}
s.CommandToOutput = map[string]string{
localkubeStatusCommand: state.Running.String(),
}
if _, err := GetLocalkubeStatus(api); err != nil {
t.Fatalf("Error getting localkube status: %s", err)
}
s.CommandToOutput = map[string]string{
localkubeStatusCommand: state.Stopped.String(),
}
if _, err := GetLocalkubeStatus(api); err != nil {
t.Fatalf("Error getting localkube status: %s", err)
}
s.CommandToOutput = map[string]string{
localkubeStatusCommand: "Bad Output",
}
if _, err := GetLocalkubeStatus(api); err == nil {
t.Fatalf("Expected error in getting localkube status as ssh returned bad output")
}
}
func TestDeleteHostMultipleErrors(t *testing.T) {
api := tests.NewMockAPI()
api.RemoveError = true
h, _ := createHost(api, defaultMachineConfig)
d := &tests.MockDriver{RemoveError: true}
h.Driver = d
err := DeleteHost(api)
if err == nil {
t.Fatal("Expected error deleting host, didn't get one.")
}
expectedErrors := []string{"Error removing " + constants.MachineName, "Error deleting machine"}
for _, expectedError := range expectedErrors {
if !strings.Contains(err.Error(), expectedError) {
t.Fatalf("Error %s expected to contain: %s.", err, expectedError)
}
}
}
func TestStartHostConfig(t *testing.T) {
api := tests.NewMockAPI()
md := &tests.MockDetector{Provisioner: &tests.MockProvisioner{}}
provision.SetDetector(md)
config := MachineConfig{
VMDriver: constants.DefaultVMDriver,
DockerEnv: []string{"FOO=BAR"},
}
h, err := StartHost(api, config)
if err != nil {
t.Fatal("Error starting host.")
}
for i := range h.HostOptions.EngineOptions.Env {
if h.HostOptions.EngineOptions.Env[i] != config.DockerEnv[i] {
t.Fatal("Docker env variables were not set!")
}
}
}
func TestCreateHost(t *testing.T) {
api := tests.NewMockAPI()
exists, _ := api.Exists(constants.MachineName)
if exists {
t.Fatal("Machine already exists.")
}
_, err := createHost(api, defaultMachineConfig)
if err != nil {
t.Fatalf("Error creating host: %v", err)
}
exists, _ = api.Exists(constants.MachineName)
if !exists {
t.Fatal("Machine does not exist, but should.")
}
h, err := api.Load(constants.MachineName)
if err != nil {
t.Fatalf("Error loading machine: %v", err)
}
if s, _ := h.Driver.GetState(); s != state.Running {
t.Fatalf("Machine is not running. State is: %s", s)
}
found := false
for _, driver := range constants.SupportedVMDrivers {
if h.DriverName == driver {
found = true
break
}
}
if !found {
t.Fatalf("Wrong driver name: %v. Should be virtualbox, vmwarefusion, kvm or xhyve.", h.DriverName)
}
}
func TestStopHostError(t *testing.T) {
api := tests.NewMockAPI()
if err := StopHost(api); err == nil {
t.Fatal("An error should be thrown when stopping non-existing machine.")
}
}