...

Source file src/edge-infra.dev/pkg/edge/api/graph/integration/vm_queries_test.go

Documentation: edge-infra.dev/pkg/edge/api/graph/integration

     1  package integration_test
     2  
     3  import (
     4  	"github.com/udacity/graphb"
     5  
     6  	"edge-infra.dev/pkg/edge/api/graph/model"
     7  	sqlquery "edge-infra.dev/pkg/edge/api/sql"
     8  	"edge-infra.dev/pkg/edge/api/utils"
     9  	"edge-infra.dev/test/framework/integration"
    10  )
    11  
    12  func (s *Suite) TestCreateVirtualMachine() {
    13  	integration.SkipIf(s.Framework)
    14  	var response struct{ CreateVirtualMachine *model.VirtualMachine }
    15  
    16  	mutation := "mutation{createVirtualMachine(createVM:{namespaceEdgeId:\"31d51d8c-b580-4e1a-94f6-a970bae8c132\",clusterEdgeId:\"618648c8-56f4-4578-a4ff-ae88782b0b9f\",hostname:\"ien-00005e0053ba\",memory:\"1024\",disks:[{bootOrder:1},{bootOrder:2}]}){virtualMachineId,namespace,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType,disks{diskId,bootOrder}}}"
    17  
    18  	err := ResolverClient.Post(mutation, &response)
    19  	s.NoErrorf(err, "error resolving vm mutation")
    20  
    21  	s.NotNilf(response.CreateVirtualMachine, "returned vm is null")
    22  	virtualMachine := response.CreateVirtualMachine
    23  
    24  	s.Len(virtualMachine.Disks, 2)
    25  	s.Equal(1, virtualMachine.Disks[0].BootOrder)
    26  	s.Equal("618648c8-56f4-4578-a4ff-ae88782b0b9f", virtualMachine.ClusterEdgeID)
    27  	s.Equal("ien-00005e0053ba", virtualMachine.Hostname)
    28  	s.Equal(false, virtualMachine.TargetPowerState)
    29  	s.Equal(1, virtualMachine.Cpus)
    30  	s.Equal("1024", virtualMachine.Memory)
    31  	s.Equal(model.MachineTypeQ35, virtualMachine.MachineType)
    32  	_, err = s.DB.Exec(sqlquery.VirtualMachineDeleteQuery, virtualMachine.VirtualMachineID)
    33  	s.NoError(err)
    34  }
    35  
    36  func (s *Suite) TestCreateVirtualMachineDefaults() {
    37  	integration.SkipIf(s.Framework)
    38  	var response struct{ CreateVirtualMachine *model.VirtualMachine }
    39  	mutation := "mutation{createVirtualMachine(createVM:{namespaceEdgeId:\"31d51d8c-b580-4e1a-94f6-a970bae8c132\",clusterEdgeId:\"618648c8-56f4-4578-a4ff-ae88782b0b9f\",hostname:\"ien-00005e0053bb\",disks:[{bootOrder:1},{bootOrder:2}]}){virtualMachineId,namespace,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType}}"
    40  	err := ResolverClient.Post(mutation, &response)
    41  
    42  	s.NoErrorf(err, "error resolving vm mutation")
    43  
    44  	s.NotNilf(response.CreateVirtualMachine, "returned vm is null")
    45  	virtualMachine := response.CreateVirtualMachine
    46  
    47  	s.Equal(model.MachineTypeQ35, virtualMachine.MachineType)
    48  	s.Equal(false, virtualMachine.TargetPowerState)
    49  	s.Equal(1, virtualMachine.Cpus)
    50  	s.Equal("1024Mi", virtualMachine.Memory)
    51  
    52  	_, err = s.DB.Exec(sqlquery.VirtualMachineDeleteQuery, virtualMachine.VirtualMachineID)
    53  	s.NoError(err)
    54  }
    55  
    56  func (s *Suite) TestCreateVirtualMachineInvalidMemoryOne() {
    57  	integration.SkipIf(s.Framework)
    58  	var response struct{ CreateVirtualMachine *model.VirtualMachine }
    59  
    60  	mutation := "mutation{createVirtualMachine(createVM:{namespaceEdgeId:\"31d51d8c-b580-4e1a-94f6-a970bae8c132\",clusterEdgeId:\"618648c8-56f4-4578-a4ff-ae88782b0b9f\",hostname:\"ien-00005e0053bc\",memory:\"1024Gb\",disks:[{bootOrder:1},{bootOrder:2}]}){virtualMachineId,namespace,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType}}"
    61  	err := ResolverClient.Post(mutation, &response)
    62  	s.Errorf(err, "should be an error resolving vm mutation")
    63  	s.Nilf(response.CreateVirtualMachine, "returned vm is not null")
    64  }
    65  
    66  func (s *Suite) TestCreateVirtualMachineInvalidMemoryTwo() {
    67  	integration.SkipIf(s.Framework)
    68  	var response struct{ CreateVirtualMachine *model.VirtualMachine }
    69  
    70  	mutation := "mutation{createVirtualMachine(createVM:{namespaceEdgeId:\"31d51d8c-b580-4e1a-94f6-a970bae8c132\",clusterEdgeId:\"618648c8-56f4-4578-a4ff-ae88782b0b9f\",hostname:\"ien-00005e0053bc\",memory:\"1024mb\",disks:[{bootOrder:1},{bootOrder:2}]}){virtualMachineId,namespace,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType}}"
    71  	err = ResolverClient.Post(mutation, &response)
    72  	s.Errorf(err, "should be an error resolving vm mutation")
    73  	s.Nilf(response.CreateVirtualMachine, "returned vm is not null")
    74  }
    75  
    76  func (s *Suite) TestCreateVirtualMachineHostnameExistsOnDifferentClusterNamespace() {
    77  	integration.SkipIf(s.Framework)
    78  	var response struct{ CreateVirtualMachine *model.VirtualMachine }
    79  
    80  	mutation := "mutation{createVirtualMachine(createVM:{namespaceEdgeId:\"31d51d8c-b580-4e1a-94f6-a970bae8c132\",clusterEdgeId:\"618648c8-56f4-4578-a4ff-ae88782b0b9f\",hostname:\"ien-00005e0053aa\",disks:[{bootOrder:1},{bootOrder:2}]}){virtualMachineId,namespace,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType}}"
    81  	err := ResolverClient.Post(mutation, &response)
    82  	s.NoErrorf(err, "error resolving vm mutation")
    83  	s.NotNilf(response.CreateVirtualMachine, "returned vm is null")
    84  
    85  	virtualMachine := response.CreateVirtualMachine
    86  	s.Equal("618648c8-56f4-4578-a4ff-ae88782b0b9f", virtualMachine.ClusterEdgeID)
    87  	s.Equal("test-namespace", virtualMachine.Namespace)
    88  
    89  	_, err = s.DB.Exec(sqlquery.VirtualMachineDeleteQuery, virtualMachine.VirtualMachineID)
    90  	s.NoError(err)
    91  }
    92  
    93  func (s *Suite) TestGetVirtualMachineByID() {
    94  	integration.SkipIf(s.Framework)
    95  
    96  	var response struct{ VirtualMachine *model.VirtualMachine }
    97  	virtualMachineID := "9a84dd25-da1c-455a-8100-3370050169c8"
    98  	query := getVirtualMachineQuery(&virtualMachineID)
    99  	err := ResolverClient.Post(query, &response)
   100  
   101  	s.NoErrorf(err, "resolver failed for get VM by ID")
   102  	s.NotEmptyf(response.VirtualMachine, "resolver response empty for get VM by ID")
   103  	s.NotEmptyf(response.VirtualMachine.Disks, "failed to return VM's disks")
   104  	s.Equalf(virtualMachineID, response.VirtualMachine.VirtualMachineID, "incorrect VM returned for get VM by ID")
   105  }
   106  
   107  func (s *Suite) TestGetVirtualMachinesByClusterEdgeID() {
   108  	integration.SkipIf(s.Framework)
   109  	var response struct{ VirtualMachines []*model.VirtualMachine }
   110  	clusterEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
   111  	query := getVirtualMachinesQuery(&clusterEdgeID, nil)
   112  	err := ResolverClient.Post(query, &response)
   113  	s.NoErrorf(err, "resolver failed for get VMs by clusterEdgeID")
   114  	s.NotEmpty(response.VirtualMachines, "resolver response empty for get VMs by clusterEdgeID")
   115  	s.Equalf(2, len(response.VirtualMachines), "resolver response != 2 for get VMs by clusterEdgeID")
   116  }
   117  
   118  func (s *Suite) TestGetVirtualMachines() {
   119  	integration.SkipIf(s.Framework)
   120  	var response struct{ VirtualMachines []*model.VirtualMachine }
   121  	query := getVirtualMachinesQuery(nil, nil)
   122  	err := ResolverClient.Post(query, &response)
   123  	s.NoErrorf(err, "resolver failed for get VMs without input")
   124  	s.NotEmptyf(response.VirtualMachines, "resolver response empty for get VMs without input")
   125  }
   126  
   127  func (s *Suite) TestGetVirtualMachinesByHostname() {
   128  	integration.SkipIf(s.Framework)
   129  	var response struct{ VirtualMachines []*model.VirtualMachine }
   130  	virtualMachineHostname := "ien-00005e0053ab"
   131  	query := getVirtualMachinesQuery(nil, &virtualMachineHostname)
   132  	err := ResolverClient.Post(query, &response)
   133  	s.NoErrorf(err, "resolver failed for get VMs by hostname")
   134  	s.NotEmptyf(response.VirtualMachines, "resolver response empty for get VMs by hostname")
   135  	s.Equalf(1, len(response.VirtualMachines), "resolver response != 1 for get VMs by hostname")
   136  	virtualMachine := response.VirtualMachines[0]
   137  	s.Equal("d4d79814-149c-4120-892e-b2a38b4dca21", virtualMachine.VirtualMachineID, "incorrect VM returned for get VMs by hostname")
   138  }
   139  
   140  func (s *Suite) TestGetVirtualMachinesByClusterEdgeIDAndHostname() {
   141  	integration.SkipIf(s.Framework)
   142  	var response struct{ VirtualMachines []*model.VirtualMachine }
   143  	clusterEdgeID := "6e04c043-89ca-4dc2-a2ea-4605dbdd4c65"
   144  	virtualMachineHostname := "ien-00005e0053ac"
   145  	query := getVirtualMachinesQuery(&clusterEdgeID, &virtualMachineHostname)
   146  	err := ResolverClient.Post(query, &response)
   147  	s.NoErrorf(err, "resolver failed for get VMs by clusterEdgeID and hostname")
   148  	s.NotEmptyf(response.VirtualMachines, "resolver response empty for get VMs by clusterEdgeID and hostname")
   149  	s.Equalf(1, len(response.VirtualMachines), "resolver response != 1 for get VMs by clusterEdgeID and hostname")
   150  	virtualMachine := response.VirtualMachines[0]
   151  	s.Equalf("830389ef-186f-405b-b3e4-44875a624604", virtualMachine.VirtualMachineID, "incorrect VM returned for get VMs by clusterEdgeID and hostname")
   152  }
   153  
   154  func (s *Suite) TestUpdateVirtualMachine() {
   155  	integration.SkipIf(s.Framework)
   156  	var response struct{ UpdateVirtualMachine *model.VirtualMachine }
   157  
   158  	mutation := "mutation{updateVirtualMachine(updateVM:{virtualMachineId:\"9297e9b5-d5f5-43a7-a517-e8c4f3cdb166\",virtualMachineValues:{targetPowerState:true,cpus:2,memory:\"1024Mi\",machineType:i440fx}}){virtualMachineId,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType}}"
   159  	err := ResolverClient.Post(mutation, &response)
   160  	s.NoError(err)
   161  	s.NotNil(response.UpdateVirtualMachine)
   162  	virtualMachine := response.UpdateVirtualMachine
   163  	s.Equal("9297e9b5-d5f5-43a7-a517-e8c4f3cdb166", virtualMachine.VirtualMachineID)
   164  	s.Equal(true, virtualMachine.TargetPowerState)
   165  	s.Equal(2, virtualMachine.Cpus)
   166  	s.Equal("1024Mi", virtualMachine.Memory)
   167  	s.Equal(model.MachineTypeI440fx, virtualMachine.MachineType)
   168  	s.Nil(virtualMachine.Disks) // shouldn't be returning disks when we don't ask for them
   169  }
   170  
   171  func (s *Suite) TestUpdateVirtualMachineWithDisks() {
   172  	integration.SkipIf(s.Framework)
   173  	var response struct{ UpdateVirtualMachine *model.VirtualMachine }
   174  
   175  	mutation := "mutation{updateVirtualMachine(updateVM:{virtualMachineId:\"9297e9b5-d5f5-43a7-a517-e8c4f3cdb166\",virtualMachineValues:{disks:{diskId:\"cbb62d9b-21b5-445d-a0e6-fce31b7257ca\",virtualMachineDiskValues:{containerImageUrl:\"docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.7.2\"}}}}){virtualMachineId,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType,disks{diskId,containerImageUrl}}}"
   176  
   177  	err := ResolverClient.Post(mutation, &response)
   178  	s.NoErrorf(err, "error resolving vm mutation")
   179  
   180  	s.NotNilf(response.UpdateVirtualMachine, "returned vm is null")
   181  	virtualMachine := response.UpdateVirtualMachine
   182  
   183  	s.NotNil(virtualMachine.Disks)
   184  	s.Equal("cbb62d9b-21b5-445d-a0e6-fce31b7257ca", virtualMachine.Disks[0].DiskID)
   185  	s.Equal("docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.7.2", virtualMachine.Disks[0].ContainerImageURL)
   186  }
   187  
   188  func (s *Suite) TestDeleteVirtualMachine() {
   189  	integration.SkipIf(s.Framework)
   190  	var response struct{ DeleteVirtualMachine bool }
   191  	virtualMachineID := "cda453a6-1773-4161-8959-21c3c9586c7b"
   192  	mutation := deleteVirtualMachineMutation(&virtualMachineID)
   193  	err := ResolverClient.Post(mutation, &response)
   194  	s.NoErrorf(err, "resolver failed for delete VM")
   195  	s.Truef(response.DeleteVirtualMachine, "resolver returned false for delete VM")
   196  }
   197  
   198  func deleteVirtualMachineMutation(virtualMachineID *string) string {
   199  	return MustParse(graphb.Query{
   200  		Type: graphb.TypeMutation,
   201  		Fields: []*graphb.Field{
   202  			{
   203  				Name: "deleteVirtualMachine",
   204  				Arguments: []graphb.Argument{
   205  					graphb.ArgumentString("virtualMachineId", utils.ConvertToString(virtualMachineID)),
   206  				},
   207  			},
   208  		},
   209  	})
   210  }
   211  
   212  func getVirtualMachineQuery(virtualMachineID *string) string {
   213  	return MustParse(graphb.Query{
   214  		Type: graphb.TypeQuery,
   215  		Fields: []*graphb.Field{
   216  			{
   217  				Name: "virtualMachine",
   218  				Arguments: []graphb.Argument{
   219  					graphb.ArgumentString("virtualMachineId", utils.ConvertToString(virtualMachineID)),
   220  				},
   221  				Fields: virtualMachineFields,
   222  			},
   223  		},
   224  	})
   225  }
   226  
   227  func getVirtualMachinesQuery(clusterEdgeID *string, virtualMachineHostname *string) string {
   228  	getVirtualMachinesArg := []graphb.Argument{}
   229  	if clusterEdgeID != nil {
   230  		getVirtualMachinesArg = append(getVirtualMachinesArg, graphb.ArgumentString("clusterEdgeId", utils.ConvertToString(clusterEdgeID)))
   231  	}
   232  	if virtualMachineHostname != nil {
   233  		getVirtualMachinesArg = append(getVirtualMachinesArg, graphb.ArgumentString("hostname", utils.ConvertToString(virtualMachineHostname)))
   234  	}
   235  	return MustParse(graphb.Query{
   236  		Type: graphb.TypeQuery,
   237  		Fields: []*graphb.Field{
   238  			{
   239  				Name:      "virtualMachines",
   240  				Arguments: getVirtualMachinesArg,
   241  				Fields:    virtualMachineFields,
   242  			},
   243  		},
   244  	})
   245  }
   246  
   247  var virtualMachineFields = []*graphb.Field{
   248  	{
   249  		Name: "virtualMachineId",
   250  	},
   251  	{
   252  		Name: "namespace",
   253  	},
   254  	{
   255  		Name: "clusterEdgeId",
   256  	},
   257  	{
   258  		Name: "clusterName",
   259  	},
   260  	{
   261  		Name: "hostname",
   262  	},
   263  	{
   264  		Name: "targetPowerState",
   265  	},
   266  	{
   267  		Name: "cpus",
   268  	},
   269  	{
   270  		Name: "memory",
   271  	},
   272  	{
   273  		Name: "machineType",
   274  	},
   275  	{
   276  		Name:   "disks",
   277  		Fields: virtualMachineDiskFields,
   278  	},
   279  }
   280  

View as plain text