Esempio n. 1
0
func TestDeleteExceptDisk(t *testing.T) {
	s := os.Getenv("DRONE")
	if s != "" {
		t.Skip("Skipping: test must be run in a VM")
	}

	ctx := context.Background()

	session := test.Session(ctx, t)
	defer session.Logout(ctx)

	host := test.PickRandomHost(ctx, session, t)

	uuid, err := sys.UUID()
	if err != nil {
		t.Fatalf("unable to get UUID for guest - used for VM name: %s", err)
	}
	name := fmt.Sprintf("%s-%d", uuid, rand.Intn(math.MaxInt32))

	moref, err := CreateVM(ctx, session, host, name)
	if err != nil {
		t.Fatalf("ERROR: %s", err)
	}
	// Wrap the result with our version of VirtualMachine
	vm := NewVirtualMachine(ctx, session, *moref)

	folder, err := vm.FolderName(ctx)
	if err != nil {
		t.Fatalf("ERROR: %s", err)
	}

	// generate the disk name
	diskName := fmt.Sprintf("%s/%s.vmdk", folder, folder)

	// Delete the VM but not it's disk
	_, err = tasks.WaitForResult(ctx, func(ctx context.Context) (tasks.ResultWaiter, error) {
		return vm.DeleteExceptDisks(ctx)
	})
	if err != nil {
		t.Fatalf("ERROR: %s", err)
	}

	// check that the disk still exists
	session.Datastore.Stat(ctx, diskName)
	if err != nil {
		t.Fatalf("Disk does not exist")
	}

	// clean up
	dm := object.NewVirtualDiskManager(session.Client.Client)

	task, err := dm.DeleteVirtualDisk(context.TODO(), diskName, nil)
	if err != nil {
		t.Fatalf("Unable to locate orphan vmdk: %s", err)
	}

	if err = task.Wait(context.TODO()); err != nil {
		t.Fatalf("Unable to remove orphan vmdk: %s", err)
	}
}
Esempio n. 2
0
func TestVM(t *testing.T) {

	s := os.Getenv("DRONE")
	if s != "" {
		t.Skip("Skipping: test must be run in a VM")
	}

	ctx := context.Background()

	session := test.Session(ctx, t)
	defer session.Logout(ctx)

	host := test.PickRandomHost(ctx, session, t)

	uuid, err := sys.UUID()
	if err != nil {
		t.Fatalf("unable to get UUID for guest - used for VM name: %s", err)
		return
	}
	name := fmt.Sprintf("%s-%d", uuid, rand.Intn(math.MaxInt32))

	moref, err := CreateVM(ctx, session, host, name)
	if err != nil {
		t.Fatalf("ERROR: %s", err)
	}
	// Wrap the result with our version of VirtualMachine
	vm := NewVirtualMachine(ctx, session, *moref)

	// Check the state
	state, err := vm.PowerState(ctx)
	if err != nil {
		t.Fatalf("ERROR: %s", err)
	}

	assert.Equal(t, types.VirtualMachinePowerStatePoweredOff, state)

	// Check VM name
	rname, err := vm.Name(ctx)
	if err != nil {
		t.Errorf("Failed to load VM name: %s", err)
	}
	assert.Equal(t, name, rname)

	// Get VM UUID
	ruuid, err := vm.UUID(ctx)
	if err != nil {
		t.Errorf("Failed to load VM UUID: %s", err)
	}
	t.Logf("Got UUID: %s", ruuid)

	// Destroy the vm
	_, err = tasks.WaitForResult(ctx, func(ctx context.Context) (tasks.ResultWaiter, error) {
		return vm.Destroy(ctx)
	})
	if err != nil {
		t.Fatalf("ERROR: %s", err)
	}
}
Esempio n. 3
0
func TestNewLinuxGuest(t *testing.T) {

	ctx := context.Background()

	session := test.Session(ctx, t)
	defer session.Logout(ctx)

	specconfig := test.SpecConfig(session)

	root, _ := NewLinuxGuest(ctx, session, specconfig)
	assert.Equal(t, "other3xLinux64Guest", root.GuestID())
}
Esempio n. 4
0
func TestVMFailureWithTimeout(t *testing.T) {
	ctx := context.Background()

	session := test.Session(ctx, t)
	defer session.Logout(ctx)

	host := test.PickRandomHost(ctx, session, t)

	ctx, cancel := context.WithTimeout(ctx, 1*time.Microsecond)
	defer cancel()

	uuid, err := sys.UUID()
	if err != nil {
		t.Fatalf("unable to get UUID for guest - used for VM name: %s", err)
		return
	}
	name := fmt.Sprintf("%s-%d", uuid, rand.Intn(math.MaxInt32))

	_, err = CreateVM(ctx, session, host, name)
	if err != nil && err != context.DeadlineExceeded {
		t.Fatalf("ERROR: %s", err)
	}
}
Esempio n. 5
0
func TestBfsSnapshotTree(t *testing.T) {
	ref := &types.ManagedObjectReference{
		Type:  "Snapshot",
		Value: "12131",
	}
	rootList := createSnapshotTree("", 5, 5)

	ctx := context.Background()

	session := test.Session(ctx, t)
	defer session.Logout(ctx)
	vm := NewVirtualMachine(ctx, session, *ref)
	q := list.New()
	for _, c := range rootList {
		q.PushBack(c)
	}

	compareID := func(node types.VirtualMachineSnapshotTree) bool {
		if node.Snapshot == *ref {
			t.Logf("Found match")
			return true
		}
		return false
	}
	current := vm.bfsSnapshotTree(q, compareID)
	if current == nil {
		t.Errorf("Should found current snapshot")
	}
	q = list.New()
	for _, c := range rootList {
		q.PushBack(c)
	}

	ref = &types.ManagedObjectReference{
		Type:  "Snapshot",
		Value: "185",
	}
	current = vm.bfsSnapshotTree(q, compareID)
	if current != nil {
		t.Errorf("Should not found snapshot")
	}

	name := "12131"
	compareName := func(node types.VirtualMachineSnapshotTree) bool {
		if node.Name == name {
			t.Logf("Found match")
			return true
		}
		return false
	}
	q = list.New()
	for _, c := range rootList {
		q.PushBack(c)
	}
	found := vm.bfsSnapshotTree(q, compareName)
	if found == nil {
		t.Errorf("Should found snapshot %q", name)
	}
	q = list.New()
	for _, c := range rootList {
		q.PushBack(c)
	}
	name = "185"
	found = vm.bfsSnapshotTree(q, compareName)
	if found != nil {
		t.Errorf("Should not found snapshot")
	}
}
Esempio n. 6
0
func TestVMAttributes(t *testing.T) {

	ctx := context.Background()

	session := test.Session(ctx, t)
	defer session.Logout(ctx)

	host := test.PickRandomHost(ctx, session, t)

	uuid, err := sys.UUID()
	if err != nil {
		t.Fatalf("unable to get UUID for guest - used for VM name: %s", err)
		return
	}
	ID := fmt.Sprintf("%s-%d", uuid, rand.Intn(math.MaxInt32))

	moref, err := CreateVM(ctx, session, host, ID)
	if err != nil {
		t.Fatalf("ERROR: %s", err)
	}
	// Wrap the result with our version of VirtualMachine
	vm := NewVirtualMachine(ctx, session, *moref)

	folder, err := vm.FolderName(ctx)
	if err != nil {
		t.Fatalf("ERROR: %s", err)
	}

	name, err := vm.Name(ctx)
	if err != nil {
		t.Fatalf("ERROR: %s", err)
	}
	assert.Equal(t, name, folder)
	task, err := vm.PowerOn(ctx)
	if err != nil {
		t.Fatalf("ERROR: %s", err)
	}
	_, err = task.WaitForResult(ctx, nil)
	if err != nil {
		t.Fatalf("ERROR: %s", err)
	}

	if guest, err := vm.FetchExtraConfig(ctx); err != nil {
		t.Fatalf("ERROR: %s", err)
	} else {
		assert.NotEmpty(t, guest)
	}
	defer func() {
		// Destroy the vm
		task, err := vm.PowerOff(ctx)
		if err != nil {
			t.Fatalf("ERROR: %s", err)
		}
		_, err = task.WaitForResult(ctx, nil)
		if err != nil {
			t.Fatalf("ERROR: %s", err)
		}
		task, err = vm.Destroy(ctx)
		if err != nil {
			t.Fatalf("ERROR: %s", err)
		}
		_, err = task.WaitForResult(ctx, nil)
		if err != nil {
			t.Fatalf("ERROR: %s", err)
		}
	}()
}