package services

import (
	"context"
	"database/sql/driver"
	"testing"

	"github.com/DATA-DOG/go-sqlmock"
	"github.com/stretchr/testify/assert"

	"edge-infra.dev/pkg/edge/api/graph/model"
	sqlquery "edge-infra.dev/pkg/edge/api/sql"
)

var (
	virtualMachineIDs                    = []string{"v001", "v002"}
	virtualMachineClusterEdgeIDs         = []string{"cluster-0001", "cluster-0002"}
	virtualMachineClusterNames           = []string{"cluster-name-1", "cluster-name-2"}
	virtualMachineNamespaceName          = "test-namespace"
	virtualMachineNamespaceEdgeID        = "31d51d8c-b580-4e1a-94f6-a970bae8c132"
	virtualMachineClusterNamespaceEdgeID = "61f25e90-81e7-4e44-b9f7-512cfecc2966"
	uniqueHostname                       = "ien-12345e0053ap"
	virtualMachineHostnames              = []string{"ien-00005e0053af", "ien-1a74bbfed056"}
	virtualMachineTargetPowerStates      = []bool{true, false}
	virtualMachineCpus                   = []int{1, 8}
	virtualMachineMemorys                = []string{"1024Mi", "4096Mi"}
	virtualMachineMachineTypes           = []model.MachineType{model.MachineTypeQ35, model.MachineTypeI440fx}
	containerImageURLs                   = []string{"docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.6.0", "docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/edge-ui@sha256:7b50f24825c3ecf48fd078fb3b64c6838e8a7226a56df19a93b3deef742c9c8e"}
	virtualMachines                      = []model.VirtualMachine{
		{
			VirtualMachineID: virtualMachineIDs[0],
			Namespace:        virtualMachineNamespaceName,
			ClusterEdgeID:    virtualMachineClusterEdgeIDs[0],
			ClusterName:      virtualMachineClusterNames[0],
			Hostname:         virtualMachineHostnames[0],
			TargetPowerState: virtualMachineTargetPowerStates[0],
			Cpus:             virtualMachineCpus[0],
			Memory:           virtualMachineMemorys[0],
			MachineType:      virtualMachineMachineTypes[0],
			Disks: []*model.VirtualMachineDisk{
				{
					DiskID:            "29988157-f173-4bda-85c3-ad6f9848da1f",
					VirtualMachineID:  virtualMachineIDs[0],
					Type:              model.DiskTypeCdrom,
					Bus:               model.BusTypeVirtio,
					BootOrder:         0,
					Size:              "2Gi",
					ContainerImageURL: containerImageURLs[0],
				},
				{
					DiskID:            "d5c209bc-0375-44e3-9343-82cc0ef656af",
					VirtualMachineID:  virtualMachineIDs[0],
					Type:              model.DiskTypeCdrom,
					Bus:               model.BusTypeVirtio,
					BootOrder:         1,
					Size:              "2Gi",
					ContainerImageURL: containerImageURLs[1],
				},
			},
		},
		{
			VirtualMachineID: virtualMachineIDs[1],
			Namespace:        virtualMachineNamespaceName,
			ClusterEdgeID:    virtualMachineClusterEdgeIDs[1],
			ClusterName:      virtualMachineClusterNames[1],
			Hostname:         virtualMachineHostnames[1],
			TargetPowerState: virtualMachineTargetPowerStates[1],
			Cpus:             virtualMachineCpus[1],
			Memory:           virtualMachineMemorys[1],
			MachineType:      virtualMachineMachineTypes[1],
			Disks: []*model.VirtualMachineDisk{
				{
					DiskID:           "f6db2f37-8c73-4dae-8cf9-1e4e5c6f2c9b",
					VirtualMachineID: virtualMachineIDs[1],
					Type:             model.DiskTypeDisk,
					Bus:              model.BusTypeSata,
					BootOrder:        2,
					Size:             "1024Mi",
				},
			},
		},
	}
	virtualMachineColumns     = []string{"vm_id", "namespace", "cluster_edge_id", "cluster_name", "hostname", "target_state", "cpus", "memory", "machine_type"}
	virtualMachineDiskColumns = []string{"disk_id", "vm_id", "type", "bus", "boot_order", "size", "container_image_url"}
)

func TestCreateVirtualMachine(t *testing.T) {
	mockVM := virtualMachines[0]

	createErr, mockErr := genericTestCreateVirtualMachine(t, mockVM, uniqueHostname)

	assert.NoError(t, createErr)
	assert.NoError(t, mockErr)
}

func TestCreateVirtualMachineWithDisk(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	mockVM := virtualMachines[1]
	virtualMachineHostname := uniqueHostname
	createVM := getVirtualMachineCreateInput(mockVM)

	mock.ExpectBegin()
	mock.ExpectQuery(sqlquery.GetClusterNameByClusterEdgeIDQuery).
		WithArgs(mockVM.ClusterEdgeID).
		WillReturnRows(sqlmock.NewRows([]string{"cluster_name"}).
			AddRow(mockVM.ClusterName))
	mock.ExpectQuery(sqlquery.GetNamespaceNameByNamespaceEdgeIDQuery).
		WithArgs(virtualMachineNamespaceEdgeID).
		WillReturnRows(sqlmock.NewRows([]string{"name"}).
			AddRow(mockVM.Namespace))
	namespaceEdgeID := virtualMachineNamespaceEdgeID
	clusterNamespaceEdgeID := virtualMachineClusterNamespaceEdgeID
	mockDBClusterNamespaceCreate(mock, namespaceEdgeID, mockVM.ClusterEdgeID, sqlmock.NewResult(1, 1))
	mockDBGetClusterNamespaceEdgeID(mock, namespaceEdgeID, mockVM.ClusterEdgeID, clusterNamespaceEdgeID)
	mockDBGetAllVirtualMachineHostnamesForAClusterNamespace(mock, virtualMachineClusterNamespaceEdgeID, []string{virtualMachineHostname}) // checking unique hostname
	mockDBVirtualMachineCreate(mock, mockVM, virtualMachineClusterNamespaceEdgeID, sqlmock.NewResult(1, 1))
	mockDBVirtualMachineDisksCreate(mock, createVM.Disks, sqlmock.NewResult(1, 1))
	mock.ExpectCommit()

	service := NewVirtualMachineService(db)

	createdVM, _, createErr := service.CreateVirtualMachineEntry(context.Background(), createVM)
	mockErr := mock.ExpectationsWereMet()
	assert.NoError(t, createErr)
	assert.NoError(t, mockErr)
	assert.NotNil(t, createdVM.Disks)
	assert.Equal(t, mockVM.Disks[0].BootOrder, createdVM.Disks[0].BootOrder)
}

func TestCreateVirtualMachineHostnameExists(t *testing.T) {
	mockVM := virtualMachines[0]
	virtualMachineHostname := mockVM.Hostname

	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	createVM := getVirtualMachineCreateInput(mockVM)

	mock.ExpectBegin()
	mock.ExpectQuery(sqlquery.GetClusterNameByClusterEdgeIDQuery).
		WithArgs(mockVM.ClusterEdgeID).
		WillReturnRows(sqlmock.NewRows([]string{"cluster_name"}).
			AddRow(mockVM.ClusterName))
	mock.ExpectQuery(sqlquery.GetNamespaceNameByNamespaceEdgeIDQuery).
		WithArgs(virtualMachineNamespaceEdgeID).
		WillReturnRows(sqlmock.NewRows([]string{"name"}).
			AddRow(mockVM.Namespace))
	namespaceEdgeID := virtualMachineNamespaceEdgeID
	clusterNamespaceEdgeID := virtualMachineClusterNamespaceEdgeID
	mockDBClusterNamespaceCreate(mock, namespaceEdgeID, mockVM.ClusterEdgeID, sqlmock.NewResult(1, 1))
	mockDBGetClusterNamespaceEdgeID(mock, namespaceEdgeID, mockVM.ClusterEdgeID, clusterNamespaceEdgeID)
	mockDBGetAllVirtualMachineHostnamesForAClusterNamespace(mock, virtualMachineClusterNamespaceEdgeID, []string{virtualMachineHostname}) // checking unique hostname
	mock.ExpectRollback()

	service := NewVirtualMachineService(db)

	_, _, createErr := service.CreateVirtualMachineEntry(context.Background(), createVM)
	mockErr := mock.ExpectationsWereMet()

	assert.Error(t, createErr)
	assert.NoError(t, mockErr)
}

func TestDeleteVirtualMachine(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	virtualMachineID := virtualMachines[0].VirtualMachineID

	mockDBVirtualMachineDelete(mock, virtualMachineID, sqlmock.NewResult(1, 1))
	service := NewVirtualMachineService(db)

	if err := service.DeleteVirtualMachineEntry(context.Background(), virtualMachineID); err != nil {
		t.Errorf("error was not expected while deleting vm: %s", err)
	}

	if err := mock.ExpectationsWereMet(); err != nil {
		t.Errorf("there were unfulfilled expectations: %s", err)
	}
}

func TestGetVirtualMachineByID(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	mockVM := virtualMachines[0]

	mockDBGetVirtualMachineByID(mock, mockVM.VirtualMachineID, &mockVM)

	service := NewVirtualMachineService(db)

	returnVM, err := service.GetVirtualMachine(context.Background(), mockVM.VirtualMachineID)

	assert.NoError(t, err)
	checkVirtualMachinesEqual(t, mockVM, returnVM)
	assert.NoError(t, mock.ExpectationsWereMet())
}

func TestGetVirtualMachinesByClusterEdgeID(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	mockVMs := virtualMachines[0:2]
	testVirtualMachineClusterEdgeID := mockVMs[0].ClusterEdgeID
	mockVMs[1].ClusterEdgeID = testVirtualMachineClusterEdgeID

	mockDBGetVirtualMachinesByClusterEdgeID(mock, testVirtualMachineClusterEdgeID, mockVMs)

	service := NewVirtualMachineService(db)

	returnVMs, err := service.GetVirtualMachines(context.Background(), &testVirtualMachineClusterEdgeID, nil)
	assert.NoError(t, err)
	assert.Equal(t, len(mockVMs), len(returnVMs))
	checkVirtualMachinesEqual(t, mockVMs[0], returnVMs[0])
	checkVirtualMachinesEqual(t, mockVMs[1], returnVMs[1])
	assert.NoError(t, mock.ExpectationsWereMet())
}

func TestGetVirtualMachinesWithHostname(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	mockVMs := virtualMachines[0:2]
	testVirtualMachineHostname := mockVMs[0].Hostname
	mockVMs[1].Hostname = testVirtualMachineHostname

	mockDBGetVirtualMachinesByHostname(mock, testVirtualMachineHostname, mockVMs)

	service := NewVirtualMachineService(db)

	returnVMs, err := service.GetVirtualMachines(context.Background(), nil, &testVirtualMachineHostname)
	assert.NoError(t, err)
	assert.Equal(t, len(mockVMs), len(returnVMs))
	checkVirtualMachinesEqual(t, mockVMs[0], returnVMs[0])
	checkVirtualMachinesEqual(t, mockVMs[1], returnVMs[1])
	assert.NoError(t, mock.ExpectationsWereMet())
}

func TestGetVirtualMachinesWithClusterEdgeIDAndHostname(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	mockVMs := virtualMachines[0:2]
	testVirtualMachineHostname := mockVMs[0].Hostname
	testVirtualMachineClusterEdgeID := mockVMs[0].ClusterEdgeID
	mockVMs[1].Hostname = testVirtualMachineHostname
	mockVMs[1].ClusterEdgeID = testVirtualMachineClusterEdgeID

	mockDBGetVirtualMachinesByClusterEdgeIDAndHostname(mock, testVirtualMachineClusterEdgeID, testVirtualMachineHostname, mockVMs)

	service := NewVirtualMachineService(db)

	returnVMs, err := service.GetVirtualMachines(context.Background(), &testVirtualMachineClusterEdgeID, &testVirtualMachineHostname)
	assert.NoError(t, err)
	assert.Equal(t, len(mockVMs), len(returnVMs))
	checkVirtualMachinesEqual(t, mockVMs[0], returnVMs[0])
	checkVirtualMachinesEqual(t, mockVMs[1], returnVMs[1])
	assert.NoError(t, mock.ExpectationsWereMet())
}

func TestGetVirtualMachinesWithoutClusterEdgeIDAndHostname(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	mockVMs := virtualMachines[0:2]
	testVirtualMachineHostname := mockVMs[0].Hostname
	testVirtualMachineClusterEdgeID := mockVMs[0].ClusterEdgeID
	mockVMs[1].Hostname = testVirtualMachineHostname
	mockVMs[1].ClusterEdgeID = testVirtualMachineClusterEdgeID

	mockDBGetAllVirtualMachines(mock, mockVMs)

	service := NewVirtualMachineService(db)

	returnVMs, err := service.GetVirtualMachines(context.Background(), nil, nil)
	assert.NoError(t, err)
	assert.Equal(t, len(mockVMs), len(returnVMs))
	checkVirtualMachinesEqual(t, mockVMs[0], returnVMs[0])
	checkVirtualMachinesEqual(t, mockVMs[1], returnVMs[1])
	assert.NoError(t, mock.ExpectationsWereMet())
}

func TestUpdateVirtualMachine(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	mockVM := virtualMachines[0]
	mock.ExpectBegin()
	mockDBGetVirtualMachineByID(mock, mockVM.VirtualMachineID, &mockVM) // get mock VirtualMachine to update
	newTargetPowerState := !mockVM.TargetPowerState
	mockDBVirtualMachineUpdate(mock, mockVM.VirtualMachineID, model.VirtualMachineUpdateInput{TargetPowerState: &newTargetPowerState, Cpus: &mockVM.Cpus, Memory: &mockVM.Memory, MachineType: &mockVM.MachineType}, sqlmock.NewResult(1, 1))
	mockDBGetVirtualMachineDisks(mock, mockVM.Disks)
	mock.ExpectCommit()

	service := NewVirtualMachineService(db)

	updateVMValues := model.VirtualMachineUpdateInput{
		TargetPowerState: &newTargetPowerState,
		Cpus:             &mockVM.Cpus,
		Memory:           &mockVM.Memory,
		MachineType:      &mockVM.MachineType,
	}
	updateVM := model.VirtualMachineIDInput{
		VirtualMachineID:     mockVM.VirtualMachineID,
		VirtualMachineValues: &updateVMValues,
	}

	updatedVM, err := service.UpdateVirtualMachineEntry(context.Background(), &updateVM)
	assert.NoError(t, err)
	mockVM.TargetPowerState = newTargetPowerState
	checkVirtualMachinesEqual(t, mockVM, updatedVM)

	if err := mock.ExpectationsWereMet(); err != nil {
		t.Errorf("there were unfulfilled expectations: %s", err)
	}
}

func TestUpdateVirtualMachineWithDisk(t *testing.T) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	mockVM := virtualMachines[0]
	currentDisk := mockVM.Disks[0]
	mock.ExpectBegin()
	mockDBGetVirtualMachineByID(mock, mockVM.VirtualMachineID, &mockVM) // get mock VirtualMachine to update
	mockDBVirtualMachineUpdate(mock, mockVM.VirtualMachineID, model.VirtualMachineUpdateInput{TargetPowerState: &mockVM.TargetPowerState, Cpus: &mockVM.Cpus, Memory: &mockVM.Memory, MachineType: &mockVM.MachineType}, sqlmock.NewResult(1, 1))
	newDiskType := model.DiskTypeDisk
	updateDisk := model.VirtualMachineDiskUpdateInput{
		Type:              &newDiskType,
		Bus:               &currentDisk.Bus,
		BootOrder:         &currentDisk.BootOrder,
		Size:              &currentDisk.Size,
		ContainerImageURL: &currentDisk.ContainerImageURL,
	}
	mockDBGetVirtualMachineDiskByID(mock, currentDisk.DiskID, currentDisk)
	mockDBUpdateVirtualMachineDisk(mock, currentDisk.DiskID, updateDisk, sqlmock.NewResult(1, 1))
	mockDBGetVirtualMachineDisks(mock, []*model.VirtualMachineDisk{
		{
			DiskID:            currentDisk.DiskID,
			VirtualMachineID:  currentDisk.DiskID,
			Type:              newDiskType,
			Bus:               currentDisk.Bus,
			BootOrder:         currentDisk.BootOrder,
			Size:              currentDisk.Size,
			ContainerImageURL: currentDisk.ContainerImageURL,
		},
		mockVM.Disks[1],
	})
	mock.ExpectCommit()

	service := NewVirtualMachineService(db)

	updateVMValues := model.VirtualMachineUpdateInput{
		TargetPowerState: &mockVM.TargetPowerState,
		Cpus:             &mockVM.Cpus,
		Memory:           &mockVM.Memory,
		MachineType:      &mockVM.MachineType,
		Disks: []*model.VirtualMachineDiskIDInput{
			{
				DiskID:                   currentDisk.DiskID,
				VirtualMachineDiskValues: &updateDisk,
			},
		},
	}
	updateVM := model.VirtualMachineIDInput{
		VirtualMachineID:     mockVM.VirtualMachineID,
		VirtualMachineValues: &updateVMValues,
	}

	updatedVM, err := service.UpdateVirtualMachineEntry(context.Background(), &updateVM)
	assert.NoError(t, err)
	assert.NotNil(t, updatedVM.Disks[0])
	assert.Equal(t, currentDisk.DiskID, updatedVM.Disks[0].DiskID)
	assert.Equal(t, newDiskType, updatedVM.Disks[0].Type)

	if err := mock.ExpectationsWereMet(); err != nil {
		t.Errorf("there were unfulfilled expectations: %s", err)
	}
}

func mockDBGetAllVirtualMachineHostnamesForAClusterNamespace(mock sqlmock.Sqlmock, clusterNamespaceEdgeID string, hostnames []string) {
	rows := mock.NewRows([]string{"hostname"})

	if len(hostnames) != 0 {
		for _, hostname := range hostnames {
			rows.AddRow(hostname)
		}
	}

	mock.ExpectQuery(sqlquery.GetVirtualMachineHostnamesForAClusterNamespaceQuery).
		WithArgs(clusterNamespaceEdgeID).
		WillReturnRows(rows)
}

func mockDBClusterNamespaceCreate(mock sqlmock.Sqlmock, namespaceEdgeID string, clusterEdgeID string, result driver.Result) {
	input := []driver.Value{
		namespaceEdgeID,
		clusterEdgeID,
	}

	mock.ExpectExec(sqlquery.ClusterNamespaceCreateQuery).
		WithArgs(input...).
		WillReturnResult(result)
}

func mockDBGetClusterNamespaceEdgeID(mock sqlmock.Sqlmock, namespaceEdgeID string, clusterEdgeID string, clusterNamespaceEdgeID string) {
	rows := mock.NewRows([]string{"cluster_namespace_edge_id"})
	rows.AddRow(clusterNamespaceEdgeID)

	input := []driver.Value{
		namespaceEdgeID,
		clusterEdgeID,
	}
	mock.ExpectQuery(sqlquery.GetClusterNamespaceEdgeIDQuery).
		WithArgs(input...).
		WillReturnRows(rows)
}

func mockDBVirtualMachineCreate(mock sqlmock.Sqlmock, mockVM model.VirtualMachine, clusterNamespaceEdgeID string, result driver.Result) {
	input := []driver.Value{
		sqlmock.AnyArg(),
		clusterNamespaceEdgeID,
		mockVM.Hostname,
		mockVM.TargetPowerState,
		mockVM.Cpus,
		mockVM.Memory,
		mockVM.MachineType,
	}

	mock.ExpectExec(sqlquery.VirtualMachineCreateQuery).
		WithArgs(input...).
		WillReturnResult(result)
}

func mockDBVirtualMachineDelete(mock sqlmock.Sqlmock, virtualMachineID string, result driver.Result) {
	mock.ExpectExec(sqlquery.VirtualMachineDeleteQuery).
		WithArgs(virtualMachineID).
		WillReturnResult(result)
}

func mockDBGetVirtualMachineByID(mock sqlmock.Sqlmock, virtualMachineID string, returnVM *model.VirtualMachine) {
	rows := mock.NewRows(virtualMachineColumns)

	if returnVM != nil {
		rows.AddRow(returnVM.VirtualMachineID, returnVM.Namespace, returnVM.ClusterEdgeID, returnVM.ClusterName, returnVM.Hostname, returnVM.TargetPowerState, returnVM.Cpus, returnVM.Memory, returnVM.MachineType)
	}

	mock.ExpectQuery(sqlquery.GetVirtualMachineByIDQuery).
		WithArgs(virtualMachineID).
		WillReturnRows(rows)
}

func mockDBGetVirtualMachinesByClusterEdgeID(mock sqlmock.Sqlmock, clusterEdgeID string, returnVMs []model.VirtualMachine) {
	rows := mock.NewRows(virtualMachineColumns)

	if len(returnVMs) != 0 {
		for _, returnVM := range returnVMs {
			rows.AddRow(returnVM.VirtualMachineID, returnVM.Namespace, returnVM.ClusterEdgeID, returnVM.ClusterName, returnVM.Hostname, returnVM.TargetPowerState, returnVM.Cpus, returnVM.Memory, returnVM.MachineType)
		}
	}

	mock.ExpectQuery(sqlquery.GetVirtualMachinesByClusterEdgeIDQuery).
		WithArgs(clusterEdgeID).
		WillReturnRows(rows)
}

func mockDBGetVirtualMachinesByHostname(mock sqlmock.Sqlmock, hostname string, returnVMs []model.VirtualMachine) {
	rows := mock.NewRows(virtualMachineColumns)

	if len(returnVMs) != 0 {
		for _, returnVM := range returnVMs {
			rows.AddRow(returnVM.VirtualMachineID, returnVM.Namespace, returnVM.ClusterEdgeID, returnVM.ClusterName, returnVM.Hostname, returnVM.TargetPowerState, returnVM.Cpus, returnVM.Memory, returnVM.MachineType)
		}
	}

	mock.ExpectQuery(sqlquery.GetVirtualMachinesByHostnameQuery).
		WithArgs(hostname).
		WillReturnRows(rows)
}

func mockDBGetVirtualMachinesByClusterEdgeIDAndHostname(mock sqlmock.Sqlmock, clusterEdgeID string, hostname string, returnVMs []model.VirtualMachine) {
	rows := mock.NewRows(virtualMachineColumns)

	if len(returnVMs) != 0 {
		for _, returnVM := range returnVMs {
			rows.AddRow(returnVM.VirtualMachineID, returnVM.Namespace, returnVM.ClusterEdgeID, returnVM.ClusterName, returnVM.Hostname, returnVM.TargetPowerState, returnVM.Cpus, returnVM.Memory, returnVM.MachineType)
		}
	}

	mock.ExpectQuery(sqlquery.GetVirtualMachinesByClusterEdgeIDAndHostnameQuery).
		WithArgs(clusterEdgeID, hostname).
		WillReturnRows(rows)
}

func mockDBGetAllVirtualMachines(mock sqlmock.Sqlmock, returnVMs []model.VirtualMachine) {
	rows := mock.NewRows(virtualMachineColumns)

	if len(returnVMs) != 0 {
		for _, returnVM := range returnVMs {
			rows.AddRow(returnVM.VirtualMachineID, returnVM.Namespace, returnVM.ClusterEdgeID, returnVM.ClusterName, returnVM.Hostname, returnVM.TargetPowerState, returnVM.Cpus, returnVM.Memory, returnVM.MachineType)
		}
	}

	mock.ExpectQuery(sqlquery.GetAllVirtualMachinesQuery).
		WillReturnRows(rows)
}

func mockDBVirtualMachineUpdate(mock sqlmock.Sqlmock, virtualMachineID string, updateVM model.VirtualMachineUpdateInput, result driver.Result) {
	update := []driver.Value{
		updateVM.TargetPowerState,
		updateVM.Cpus,
		updateVM.Memory,
		updateVM.MachineType,
		virtualMachineID,
	}
	mock.ExpectExec(sqlquery.VirtualMachineUpdateQuery).
		WithArgs(update...).
		WillReturnResult(result)
}

// helper for successfully creating a mock vm
func genericTestCreateVirtualMachine(t *testing.T, mockVM model.VirtualMachine, virtualMachineHostname string) (error, error) {
	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	createVM := getVirtualMachineCreateInput(mockVM)

	mock.ExpectBegin()
	mock.ExpectQuery(sqlquery.GetClusterNameByClusterEdgeIDQuery).
		WithArgs(mockVM.ClusterEdgeID).
		WillReturnRows(sqlmock.NewRows([]string{"cluster_name"}).
			AddRow(mockVM.ClusterName))
	mock.ExpectQuery(sqlquery.GetNamespaceNameByNamespaceEdgeIDQuery).
		WithArgs(virtualMachineNamespaceEdgeID).
		WillReturnRows(sqlmock.NewRows([]string{"name"}).
			AddRow(mockVM.Namespace))
	namespaceEdgeID := virtualMachineNamespaceEdgeID
	clusterNamespaceEdgeID := virtualMachineClusterNamespaceEdgeID
	mockDBClusterNamespaceCreate(mock, namespaceEdgeID, mockVM.ClusterEdgeID, sqlmock.NewResult(1, 1))
	mockDBGetClusterNamespaceEdgeID(mock, namespaceEdgeID, mockVM.ClusterEdgeID, clusterNamespaceEdgeID)
	mockDBGetAllVirtualMachineHostnamesForAClusterNamespace(mock, virtualMachineClusterNamespaceEdgeID, []string{virtualMachineHostname}) // checking unique hostname
	mockDBVirtualMachineCreate(mock, mockVM, virtualMachineClusterNamespaceEdgeID, sqlmock.NewResult(1, 1))
	mockDBVirtualMachineDisksCreate(mock, createVM.Disks, sqlmock.NewResult(1, 1))
	mock.ExpectCommit()

	service := NewVirtualMachineService(db)

	_, _, createErr := service.CreateVirtualMachineEntry(context.Background(), createVM)
	mockErr := mock.ExpectationsWereMet()

	return createErr, mockErr
}

func getVirtualMachineCreateInput(createVM model.VirtualMachine) *model.VirtualMachineCreateInput {
	createDisks := []*model.VirtualMachineDiskCreateInput{}
	for _, disk := range createVM.Disks {
		createDisks = append(createDisks, getVirtualMachineDiskCreateInput(*disk))
	}
	namespaceEdgeID := virtualMachineNamespaceEdgeID
	return &model.VirtualMachineCreateInput{
		NamespaceEdgeID:  namespaceEdgeID,
		ClusterEdgeID:    createVM.ClusterEdgeID,
		Hostname:         createVM.Hostname,
		TargetPowerState: &createVM.TargetPowerState,
		Cpus:             &createVM.Cpus,
		Memory:           &createVM.Memory,
		MachineType:      &createVM.MachineType,
		Disks:            createDisks,
	}
}

func checkVirtualMachinesEqual(t *testing.T, mockVM model.VirtualMachine, returnVM *model.VirtualMachine) {
	assert.Equal(t, mockVM.VirtualMachineID, returnVM.VirtualMachineID)
	assert.Equal(t, mockVM.Namespace, returnVM.Namespace)
	assert.Equal(t, mockVM.ClusterEdgeID, returnVM.ClusterEdgeID)
	assert.Equal(t, mockVM.ClusterName, returnVM.ClusterName)
	assert.Equal(t, mockVM.Hostname, returnVM.Hostname)
	assert.Equal(t, mockVM.TargetPowerState, returnVM.TargetPowerState)
	assert.Equal(t, mockVM.Cpus, returnVM.Cpus)
	assert.Equal(t, mockVM.Memory, returnVM.Memory)
	assert.Equal(t, mockVM.MachineType, returnVM.MachineType)
}