Example #1
0
func CreateMachine(c *echo.Context) error {
	rt := &machine{}

	err := utils.ParseJSONBody(c, rt)
	if err != nil {
		log.Error(err.Error())
		return err
	}

	machineType, err := vms.Type(rt.Type)
	if err != nil {
		return errors.MachineTypeNotFound
	}

	attr := vm.MachineAttributes{
		Type:     machineType,
		Name:     rt.Name,
		Username: rt.Username,
		Password: rt.AdminPassword,
		Ip:       rt.Ip,
	}

	m, err := vms.Create(attr)
	if err != nil {
		log.Error(err)
		return errors.UnableToCreateTheMachine
	}

	rt, err = getSerializableMachine(m.Id())
	if err != nil {
		return err
	}

	return utils.JSON(c, http.StatusOK, rt)
}
Example #2
0
func TestSetNil(t *testing.T) {
	machine_attributes := vms.MachineAttributes{
		Type:     nil,
		Name:     "machine-test",
		Username: "******",
		Password: "******",
		Ip:       "127.0.0.1",
	}

	SetNil()
	new_machine, _ := connector.Create(machine_attributes)
	if new_machine != nil {
		t.Errorf("Create(): Returned value should be nil")
	}

	SetNil()
	machine_type, _ := connector.Type("default-test-machine-type")
	if machine_type != nil {
		t.Errorf("Type(): Returned value should be nil")
	}

	SetNil()
	all_machines, _ := connector.Types()
	if all_machines != nil {
		t.Errorf("Types(): Returned value should be nil")
	}
}
Example #3
0
func TestType(t *testing.T) {
	machine_type, err := connector.Type("default-test-machine-type")
	if err != nil {
		t.Fatal(err)
	}
	if machine_type == nil {
		t.Errorf("Machine type is nil")
	}
}
Example #4
0
func TestSetDelay(t *testing.T) {
	machine := getMachine()
	machine_attributes := vms.MachineAttributes{
		Type:     nil,
		Name:     "machine-test",
		Username: "******",
		Password: "******",
		Ip:       "127.0.0.1",
	}

	SetDelay(1000)
	called := time.Now()
	connector.Create(machine_attributes)
	if time.Since(called) < time.Duration(1000) {
		t.Errorf("Create(): Delay should be observed")
	}

	SetDelay(1000)
	called = time.Now()
	connector.Type("default-test-machine-type")
	if time.Since(called) < time.Duration(1000) {
		t.Errorf("Type(): Delay should be observed")
	}

	SetDelay(1000)
	called = time.Now()
	connector.Types()
	if time.Since(called) < time.Duration(1000) {
		t.Errorf("Types(): Delay should be observed")
	}

	SetDelay(1000)
	called = time.Now()
	machine.Start()
	if time.Since(called) < time.Duration(1000) {
		t.Errorf("Start(): Delay should be observed")
	}

	SetDelay(1000)
	called = time.Now()
	machine.Stop()
	if time.Since(called) < time.Duration(1000) {
		t.Errorf("Stop(): Delay should be observed")
	}

	SetDelay(1000)
	called = time.Now()
	machine.Terminate()
	if time.Since(called) < time.Duration(1000) {
		t.Errorf("Terminate(): Delay should be observed")
	}
}
Example #5
0
func TestSetFail(t *testing.T) {
	machine := getMachine()
	machine_attributes := vms.MachineAttributes{
		Type:     nil,
		Name:     "machine-test",
		Username: "******",
		Password: "******",
		Ip:       "127.0.0.1",
	}

	SetFail()
	_, err := connector.Create(machine_attributes)
	if err == nil {
		t.Errorf("Create(): Error should not be nil")
	}

	SetFail()
	_, err = connector.Type("default-test-machine-type")
	if err == nil {
		t.Errorf("Type(): Error should not be nil")
	}

	SetFail()
	_, err = connector.Types()
	if err == nil {
		t.Errorf("Types(): Error should not be nil")
	}

	SetFail()
	err = machine.Start()
	if err == nil {
		t.Errorf("Start(): Error should not be nil")
	}

	SetFail()
	err = machine.Stop()
	if err == nil {
		t.Errorf("Stop(): Error should not be nil")
	}

	SetFail()
	err = machine.Terminate()
	if err == nil {
		t.Errorf("Terminate(): Error should not be nil")
	}
}