...

Source file src/edge-infra.dev/pkg/edge/api/graph/integration/vm_disks_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) TestCreateVirtualMachineDisk() {
    13  	integration.SkipIf(s.Framework)
    14  	var response struct{ CreateVirtualMachineDisks []*model.VirtualMachineDisk }
    15  	mutation := "mutation{createVirtualMachineDisks(virtualMachineId:\"a1654bb6-6173-4e58-9385-4ac7c16332a7\", createDisks:[{type:cdrom, bus:sata, bootOrder:4, size:\"3Gi\", containerImageUrl:\"docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.6.0\"}]){diskId, virtualMachineId, type, bus, bootOrder, size, containerImageUrl}}"
    16  	err := ResolverClient.Post(mutation, &response)
    17  
    18  	s.NoErrorf(err, "error resolving vm disk mutation")
    19  
    20  	s.NotNilf(response.CreateVirtualMachineDisks, "returned vm disk is null")
    21  	createdDisk := response.CreateVirtualMachineDisks[0]
    22  
    23  	s.Equal("a1654bb6-6173-4e58-9385-4ac7c16332a7", createdDisk.VirtualMachineID)
    24  	s.Equal(model.DiskTypeCdrom, createdDisk.Type)
    25  	s.Equal(model.BusTypeSata, createdDisk.Bus)
    26  	s.Equal(4, createdDisk.BootOrder)
    27  	s.Equal("3Gi", createdDisk.Size)
    28  	s.Equal("docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.6.0", createdDisk.ContainerImageURL)
    29  
    30  	_, err = s.DB.Exec(sqlquery.VirtualMachineDiskDeleteQuery, createdDisk.DiskID)
    31  	s.NoError(err)
    32  }
    33  
    34  func (s *Suite) TestCreateVirtualMachineDiskDefaults() {
    35  	integration.SkipIf(s.Framework)
    36  	var response struct{ CreateVirtualMachineDisks []*model.VirtualMachineDisk }
    37  	mutation := "mutation{createVirtualMachineDisks(virtualMachineId:\"a1654bb6-6173-4e58-9385-4ac7c16332a7\", createDisks:[{bootOrder:5}]){diskId, virtualMachineId, type, bus, bootOrder, size, containerImageUrl}}"
    38  	err := ResolverClient.Post(mutation, &response)
    39  
    40  	s.NoErrorf(err, "error resolving vm disk mutation")
    41  
    42  	s.NotNilf(response.CreateVirtualMachineDisks, "returned vm disk is null")
    43  	createdDisk := response.CreateVirtualMachineDisks[0]
    44  
    45  	s.Equal("a1654bb6-6173-4e58-9385-4ac7c16332a7", createdDisk.VirtualMachineID)
    46  	s.Equal(model.DiskTypeCdrom, createdDisk.Type)
    47  	s.Equal(model.BusTypeSata, createdDisk.Bus)
    48  	s.Equal(5, createdDisk.BootOrder)
    49  	s.Equal("1Gi", createdDisk.Size)
    50  	s.Empty(createdDisk.ContainerImageURL)
    51  
    52  	_, err = s.DB.Exec(sqlquery.VirtualMachineDiskDeleteQuery, createdDisk.DiskID)
    53  	s.NoError(err)
    54  }
    55  
    56  // test creating a VM disk when the specified VM does not exist
    57  func (s *Suite) TestCreateVirtualMachineDiskNoVirtualMachine() {
    58  	integration.SkipIf(s.Framework)
    59  	var response struct{ CreateVirtualMachineDisks []*model.VirtualMachineDisk }
    60  	mutation := "mutation{createVirtualMachineDisks(virtualMachineId:\"082c8a63-7457-4c42-aad9-34623150cd9b\", createDisks:[{type:cdrom, bus:sata, bootOrder:1, size:\"3Gi\", containerImageUrl:\"docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.6.0\"}]){diskId, virtualMachineId, type, bus, bootOrder, size, containerImageUrl}}"
    61  	err := ResolverClient.Post(mutation, &response)
    62  	s.Errorf(err, "no error resolving vm disk mutation")
    63  	s.Nilf(response.CreateVirtualMachineDisks, "returned vm disk is not null")
    64  }
    65  
    66  // test creating a VM disk with an invalid memory format
    67  func (s *Suite) TestCreateVirtualMachineDiskInvalidMemoryOne() {
    68  	integration.SkipIf(s.Framework)
    69  	var response struct{ CreateVirtualMachineDisks []*model.VirtualMachineDisk }
    70  
    71  	mutation := "mutation{createVirtualMachineDisks(virtualMachineId:\"a1654bb6-6173-4e58-9385-4ac7c16332a7\", createDisks:[{type:cdrom, bus:sata, bootOrder:4, size:\"10gb\", containerImageUrl:\"docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.6.0\"}]){diskId, virtualMachineId, type, bus, bootOrder, size, containerImageUrl}}"
    72  	err := ResolverClient.Post(mutation, &response)
    73  	s.Errorf(err, "should be an error resolving vm disk mutation (1)")
    74  	s.Nilf(response.CreateVirtualMachineDisks, "returned vm disk is not null (1)")
    75  }
    76  
    77  // test creating a VM disk with an invalid memory format
    78  func (s *Suite) TestCreateVirtualMachineDiskInvalidMemoryTwo() {
    79  	integration.SkipIf(s.Framework)
    80  	var response struct{ CreateVirtualMachineDisks []*model.VirtualMachineDisk }
    81  
    82  	mutation := "mutation{createVirtualMachineDisks(virtualMachineId:\"a1654bb6-6173-4e58-9385-4ac7c16332a7\", createDisks:[{type:cdrom, bus:sata, bootOrder:4, size:\"18Gb\", containerImageUrl:\"docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.6.0\"}]){diskId, virtualMachineId, type, bus, bootOrder, size, containerImageUrl}}"
    83  	err = ResolverClient.Post(mutation, &response)
    84  	s.Errorf(err, "should be an error resolving vm disk mutation (2)")
    85  	s.Nilf(response.CreateVirtualMachineDisks, "returned vm disk is not null (2)")
    86  }
    87  
    88  // test creating a VM disk when the specified VM does not exist
    89  func (s *Suite) TestCreateVirtualMachineDiskDuplicateBootOrder() {
    90  	integration.SkipIf(s.Framework)
    91  	var response struct{ CreateVirtualMachineDisks []*model.VirtualMachineDisk }
    92  	mutation := "mutation{createVirtualMachineDisks(virtualMachineId:\"a1654bb6-6173-4e58-9385-4ac7c16332a7\", createDisks:[{type:cdrom, bus:sata, bootOrder:0, size:\"3Gi\"}]){diskId, virtualMachineId, type, bus, bootOrder, size, containerImageUrl}}"
    93  	err := ResolverClient.Post(mutation, &response)
    94  	s.Errorf(err, "no error resolving vm disk mutation")
    95  	s.Nilf(response.CreateVirtualMachineDisks, "returned vm disk is not null")
    96  }
    97  
    98  // get a VM disk by its diskID
    99  func (s *Suite) TestGetVirtualMachineDiskByID() {
   100  	integration.SkipIf(s.Framework)
   101  
   102  	var response struct{ VirtualMachineDisk *model.VirtualMachineDisk }
   103  	diskID := "a8a8f270-5387-44ae-abda-6973906f3b46"
   104  	query := getVirtualMachineDiskQuery(&diskID)
   105  	err = ResolverClient.Post(query, &response)
   106  
   107  	s.NoErrorf(err, "resolver failed for get VM disk by ID")
   108  	s.NotEmptyf(response.VirtualMachineDisk, "resolver response empty for get VM disk by ID")
   109  	s.Equalf(diskID, response.VirtualMachineDisk.DiskID, "incorrect VM disk returned for get VM disk by ID")
   110  	s.Equalf("9a84dd25-da1c-455a-8100-3370050169c8", response.VirtualMachineDisk.VirtualMachineID, "incorrect VM disk returned for get VM disk by ID (VM IDs dont match)")
   111  }
   112  
   113  // try getting a VM disk that does not exist
   114  func (s *Suite) TestGetVirtualMachineDiskNoDisk() {
   115  	integration.SkipIf(s.Framework)
   116  
   117  	var response struct{ VirtualMachineDisk *model.VirtualMachineDisk }
   118  	diskID := "d5fffebf-855f-4940-ae37-fa0aab530e01"
   119  	query := getVirtualMachineDiskQuery(&diskID)
   120  	err = ResolverClient.Post(query, &response)
   121  
   122  	s.Errorf(err, "resolver didn't fail to get VM disk by ID")
   123  	s.Emptyf(response.VirtualMachineDisk, "resolver response not empty for get VM disk by ID")
   124  }
   125  
   126  // get a VM's disks with the virtualMachineID
   127  func (s *Suite) TestGetVirtualMachineDisksByVirtualMachineID() {
   128  	integration.SkipIf(s.Framework)
   129  
   130  	var response struct{ VirtualMachineDisks []*model.VirtualMachineDisk }
   131  	virtualMachineID := "9a84dd25-da1c-455a-8100-3370050169c8"
   132  	query := getVirtualMachineDisksQuery(&virtualMachineID)
   133  	err = ResolverClient.Post(query, &response)
   134  
   135  	s.NoErrorf(err, "resolver failed for get VM disks by VM ID")
   136  	s.NotEmptyf(response.VirtualMachineDisks, "resolver response empty for get VM disks by VM ID")
   137  	s.Equalf("a8a8f270-5387-44ae-abda-6973906f3b46", response.VirtualMachineDisks[0].DiskID, "incorrect VM disk returned for get VM disks by VM ID (1)")
   138  }
   139  
   140  // try getting a VM's disks on a VM that does not exist
   141  func (s *Suite) TestGetVirtualMachineDisksNoVirtualMachine() {
   142  	integration.SkipIf(s.Framework)
   143  
   144  	var response struct{ VirtualMachineDisks []*model.VirtualMachineDisk }
   145  	virtualMachineID := "2263b06e-17d0-4710-a9fd-33f39a7f1828"
   146  	query := getVirtualMachineDisksQuery(&virtualMachineID)
   147  	err = ResolverClient.Post(query, &response)
   148  
   149  	s.Errorf(err, "resolver didn't fail to get VM disks by VM ID")
   150  	s.Emptyf(response.VirtualMachineDisks, "resolver response not empty for get VM disks by VM ID")
   151  }
   152  
   153  // update the values of a VM disk
   154  func (s *Suite) TestUpdateVirtualMachineDisk() {
   155  	integration.SkipIf(s.Framework)
   156  	var response struct{ UpdateVirtualMachineDisks []*model.VirtualMachineDisk }
   157  
   158  	mutation := "mutation{updateVirtualMachineDisks(updateDisks:[{diskId:\"cbb62d9b-21b5-445d-a0e6-fce31b7257ca\",virtualMachineDiskValues:{type:cdrom, bus:virtio, bootOrder:3, size:\"16Gi\", containerImageUrl:\"docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.7.2\"}}]){diskId, virtualMachineId, type, bus, bootOrder, size, containerImageUrl}}"
   159  	err := ResolverClient.Post(mutation, &response)
   160  	s.NoError(err)
   161  	s.NotNil(response.UpdateVirtualMachineDisks)
   162  	updatedDisk := response.UpdateVirtualMachineDisks[0]
   163  	s.Equalf("cbb62d9b-21b5-445d-a0e6-fce31b7257ca", updatedDisk.DiskID, "vm disk ID update incorrect")
   164  	s.Equalf(model.DiskTypeCdrom, updatedDisk.Type, "vm disk type update incorrect")
   165  	s.Equalf(model.BusTypeVirtio, updatedDisk.Bus, "vm disk bus type update incorrect")
   166  	s.Equalf(3, updatedDisk.BootOrder, "vm disk boot order update incorrect")
   167  	s.Equalf("16Gi", updatedDisk.Size, "vm disk size update incorrect")
   168  	s.Equalf("docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.7.2", updatedDisk.ContainerImageURL, "vm disk container image URL update incorrect")
   169  }
   170  
   171  // delete a VM's disk
   172  func (s *Suite) TestDeleteVirtualMachineDisk() {
   173  	integration.SkipIf(s.Framework)
   174  	var response struct{ DeleteVirtualMachineDisk bool }
   175  	diskID := "6de1f847-4171-444f-9792-715bd7a10b2e"
   176  	mutation := deleteVirtualMachineDiskMutation(&diskID)
   177  	err := ResolverClient.Post(mutation, &response)
   178  	s.NoErrorf(err, "resolver failed for delete VM disk")
   179  	s.Truef(response.DeleteVirtualMachineDisk, "resolver returned false for delete VM disk")
   180  }
   181  
   182  // try delete a VM's last disk
   183  func (s *Suite) TestDeleteVirtualMachineDiskLast() {
   184  	integration.SkipIf(s.Framework)
   185  	var response struct{ DeleteVirtualMachineDisk bool }
   186  	diskID := "74ad9fdb-836b-49ae-a3c6-0ffd77c08e4d"
   187  	mutation := deleteVirtualMachineDiskMutation(&diskID)
   188  	err := ResolverClient.Post(mutation, &response)
   189  	s.Errorf(err, "resolver didn't fail for delete VM disk")
   190  	s.Falsef(response.DeleteVirtualMachineDisk, "resolver returned true for delete VM disk")
   191  }
   192  
   193  func deleteVirtualMachineDiskMutation(diskID *string) string {
   194  	return MustParse(graphb.Query{
   195  		Type: graphb.TypeMutation,
   196  		Fields: []*graphb.Field{
   197  			{
   198  				Name: "deleteVirtualMachineDisk",
   199  				Arguments: []graphb.Argument{
   200  					graphb.ArgumentString("diskId", utils.ConvertToString(diskID)),
   201  				},
   202  			},
   203  		},
   204  	})
   205  }
   206  
   207  func getVirtualMachineDiskQuery(diskID *string) string {
   208  	return MustParse(graphb.Query{
   209  		Type: graphb.TypeQuery,
   210  		Fields: []*graphb.Field{
   211  			{
   212  				Name: "virtualMachineDisk",
   213  				Arguments: []graphb.Argument{
   214  					graphb.ArgumentString("diskId", utils.ConvertToString(diskID)),
   215  				},
   216  				Fields: virtualMachineDiskFields,
   217  			},
   218  		},
   219  	})
   220  }
   221  
   222  func getVirtualMachineDisksQuery(virtualMachineID *string) string {
   223  	return MustParse(graphb.Query{
   224  		Type: graphb.TypeQuery,
   225  		Fields: []*graphb.Field{
   226  			{
   227  				Name: "virtualMachineDisks",
   228  				Arguments: []graphb.Argument{
   229  					graphb.ArgumentString("virtualMachineId", utils.ConvertToString(virtualMachineID)),
   230  				},
   231  				Fields: virtualMachineDiskFields,
   232  			},
   233  		},
   234  	})
   235  }
   236  
   237  var virtualMachineDiskFields = []*graphb.Field{
   238  	{
   239  		Name: "diskId",
   240  	},
   241  	{
   242  		Name: "virtualMachineId",
   243  	},
   244  	{
   245  		Name: "type",
   246  	},
   247  	{
   248  		Name: "bus",
   249  	},
   250  	{
   251  		Name: "bootOrder",
   252  	},
   253  	{
   254  		Name: "size",
   255  	},
   256  	{
   257  		Name: "containerImageUrl",
   258  	},
   259  }
   260  

View as plain text