...

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

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

     1  package integration_test
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"github.com/udacity/graphb"
     7  
     8  	"edge-infra.dev/pkg/edge/api/graph/model"
     9  	"edge-infra.dev/pkg/edge/api/services"
    10  	sqlquery "edge-infra.dev/pkg/edge/api/sql"
    11  	"edge-infra.dev/pkg/edge/api/utils"
    12  	"edge-infra.dev/test/framework/integration"
    13  )
    14  
    15  var terminalID = "c4aa6450-3b2a-11ed-a261-0242ac12c101"
    16  
    17  func (s *Suite) TestCreateTerminal() {
    18  	integration.SkipIf(s.Framework)
    19  	var response struct{ CreateTerminal *model.Terminal }
    20  	mutation := "mutation{createTerminal(newTerminal:{lane:\"lane01\",role:worker,class:touchpoint,discoverDisks:empty,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"178.102.156.9\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,class,discoverDisks,bootDisk,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
    21  	err := ResolverClient.Post(mutation, &response)
    22  	s.NoError(err)
    23  
    24  	s.NotNil(response.CreateTerminal)
    25  	terminal := response.CreateTerminal
    26  	s.NotEmpty(terminal.Interfaces)
    27  	s.Equal(1, len(terminal.Interfaces))
    28  	terminalInterface := terminal.Interfaces[0]
    29  	s.NotEmpty(terminalInterface.Addresses)
    30  	s.Equal(1, len(terminalInterface.Addresses))
    31  	terminalAddress := terminalInterface.Addresses[0]
    32  
    33  	s.Equal("3396a52c-6a22-4049-9593-5a63b596a101", terminal.ClusterEdgeID)
    34  	s.Equal(model.TerminalRoleTypeWorker, terminal.Role)
    35  	s.Equal("lane01", *terminal.Lane)
    36  	s.Equal(model.TerminalClassTypeTouchpoint, *terminal.Class)
    37  	s.Equal(model.TerminalDiscoverDisksTypeEmpty, *terminal.DiscoverDisks)
    38  	s.Nil(terminal.BootDisk)
    39  
    40  	s.Equal("00:00:5e:00:53:bb", terminalInterface.MacAddress)
    41  	s.False(terminalInterface.Dhcp4)
    42  	s.True(terminalInterface.Dhcp6)
    43  
    44  	s.Equal("192.168.2.10", *terminalAddress.IP)
    45  	s.Equal(16, terminalAddress.PrefixLen)
    46  	s.Equal(model.InetTypeInet, terminalAddress.Family)
    47  
    48  	_, err = s.DB.Exec(sqlquery.TerminalDeleteQuery, terminal.TerminalID)
    49  	s.NoError(err)
    50  }
    51  
    52  func (s *Suite) TestCreateTerminalWithSpecifiedBootDisk() {
    53  	integration.SkipIf(s.Framework)
    54  	var response struct{ CreateTerminal *model.Terminal }
    55  	mutation := "mutation{createTerminal(newTerminal:{lane:\"lane01\",role:worker,class:touchpoint,discoverDisks:empty,bootDisk:\"/dev/sda\",clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"178.102.156.9\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,class,discoverDisks,bootDisk,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
    56  	err := ResolverClient.Post(mutation, &response)
    57  	s.NoError(err)
    58  
    59  	s.NotNil(response.CreateTerminal)
    60  	terminal := response.CreateTerminal
    61  	s.NotEmpty(terminal.Interfaces)
    62  	s.Equal(1, len(terminal.Interfaces))
    63  	terminalInterface := terminal.Interfaces[0]
    64  	s.NotEmpty(terminalInterface.Addresses)
    65  	s.Equal(1, len(terminalInterface.Addresses))
    66  	terminalAddress := terminalInterface.Addresses[0]
    67  
    68  	s.Equal("3396a52c-6a22-4049-9593-5a63b596a101", terminal.ClusterEdgeID)
    69  	s.Equal(model.TerminalRoleTypeWorker, terminal.Role)
    70  	s.Equal("lane01", *terminal.Lane)
    71  	s.Equal(model.TerminalClassTypeTouchpoint, *terminal.Class)
    72  	s.Equal(model.TerminalDiscoverDisksTypeEmpty, *terminal.DiscoverDisks)
    73  	s.Equal("/dev/sda", *terminal.BootDisk)
    74  
    75  	s.Equal("00:00:5e:00:53:bb", terminalInterface.MacAddress)
    76  	s.False(terminalInterface.Dhcp4)
    77  	s.True(terminalInterface.Dhcp6)
    78  
    79  	s.Equal("192.168.2.10", *terminalAddress.IP)
    80  	s.Equal(16, terminalAddress.PrefixLen)
    81  	s.Equal(model.InetTypeInet, terminalAddress.Family)
    82  
    83  	_, err = s.DB.Exec(sqlquery.TerminalDeleteQuery, terminal.TerminalID)
    84  	s.NoError(err)
    85  }
    86  
    87  func (s *Suite) TestCreateTerminalWithDefaultDiscoverDisks() {
    88  	integration.SkipIf(s.Framework)
    89  	var response struct{ CreateTerminal *model.Terminal }
    90  	mutation := "mutation{createTerminal(newTerminal:{lane:\"lane01\",role:worker,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"178.102.156.9\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,class,discoverDisks,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
    91  	err := ResolverClient.Post(mutation, &response)
    92  	s.NoError(err)
    93  
    94  	// assert terminal was created with default discoverDisks value (empty)
    95  	s.NotNil(response.CreateTerminal)
    96  	terminal := response.CreateTerminal
    97  	s.Equal(model.TerminalDiscoverDisksTypeEmpty, *terminal.DiscoverDisks)
    98  
    99  	_, err = s.DB.Exec(sqlquery.TerminalDeleteQuery, terminal.TerminalID)
   100  	s.NoError(err)
   101  }
   102  
   103  func (s *Suite) TestCreateTerminalAddress() {
   104  	integration.SkipIf(s.Framework)
   105  	var response struct{ CreateTerminalAddress *model.TerminalAddress }
   106  	mutation := "mutation{createTerminalAddress(terminalInterfaceId:\"3396a52c-6a22-4049-9593-5a63b596a203\",newTerminalAddress:{ip:\"192.168.2.10\",prefixLen:16,family:inet}){family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}"
   107  	err := ResolverClient.Post(mutation, &response)
   108  	s.NoError(err)
   109  	s.Equal("3396a52c-6a22-4049-9593-5a63b596a203", response.CreateTerminalAddress.TerminalInterfaceID)
   110  	s.Equal("192.168.2.10", *response.CreateTerminalAddress.IP)
   111  
   112  	_, err = s.DB.Exec(sqlquery.TerminalAddressDeleteQuery, response.CreateTerminalAddress.TerminalAddressID)
   113  	s.NoError(err)
   114  }
   115  
   116  func (s *Suite) TestCreateTerminalError() {
   117  	integration.SkipIf(s.Framework)
   118  	var response struct{ CreateTerminal *model.Terminal }
   119  
   120  	mutation := "mutation{createTerminal(newTerminal:{lane:\"\",role:worker,discoverDisks:all,interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"x.x.x.x\",gateway6:\"x.x.x.x\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
   121  	err := ResolverClient.Post(mutation, &response)
   122  	s.Error(err)
   123  	s.Nil(response.CreateTerminal)
   124  }
   125  
   126  func (s *Suite) TestCreateTerminalInterface() {
   127  	integration.SkipIf(s.Framework)
   128  	var response struct{ CreateTerminalInterface *model.TerminalInterface }
   129  	mutation := "mutation{createTerminalInterface(terminalId:\"c4aa6450-3b2a-11ed-a261-0242ac12c101\",newTerminalInterface:{macAddress:\"00:00:5e:00:53:bb\",dhcp4:true,dhcp6:true,addresses:[]}){dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId}}"
   130  	err := ResolverClient.Post(mutation, &response)
   131  	s.NoError(err)
   132  	s.Equal(terminalID, response.CreateTerminalInterface.TerminalID)
   133  	s.Equal("00:00:5e:00:53:bb", response.CreateTerminalInterface.MacAddress)
   134  
   135  	_, err = s.DB.Exec(sqlquery.TerminalInterfaceDeleteQuery, response.CreateTerminalInterface.TerminalInterfaceID)
   136  	s.NoError(err)
   137  }
   138  
   139  func (s *Suite) TestCreateTerminalInterfaceError() {
   140  	integration.SkipIf(s.Framework)
   141  	var response struct{ CreateTerminalInterface *model.TerminalInterface }
   142  	mutation := "mutation{createTerminalInterface(terminalId:\"c4aa6450-3b2a-11ed-a261-0242ac12c101\",newTerminalInterface:{macAddress:\"0000:5e:00:53:bb\",dhcp4:false,dhcp6:false,gateway4:\"178.102.156.9\",gateway6:\"22.234.148.200\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}){dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}"
   143  	err := ResolverClient.Post(mutation, &response)
   144  	s.Error(err)
   145  }
   146  
   147  func (s *Suite) TestCreateTerminalInvalidCIDR() {
   148  	integration.SkipIf(s.Framework)
   149  	var response struct{ CreateTerminal *model.Terminal }
   150  
   151  	mutation := "mutation{createTerminal(newTerminal:{lane:\"\",role:worker,discoverDisks:all,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"1.1.1.1\",gateway6:\"2.2.2.2\",addresses:[{ip:\"192.168.2.10\",prefixLen:-1,family:inet}]}]}){clusterEdgeId,lane,role,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
   152  	err := ResolverClient.Post(mutation, &response)
   153  	s.Error(err)
   154  	s.Nil(response.CreateTerminal)
   155  }
   156  
   157  func (s *Suite) TestCreateTerminalInvalidIP() {
   158  	integration.SkipIf(s.Framework)
   159  	var response struct{ CreateTerminal *model.Terminal }
   160  
   161  	mutation := "mutation{createTerminal(newTerminal:{lane:\"\",role:worker,discoverDisks:all,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"x.x.x.x\",gateway6:\"x.x.x.x\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
   162  	err := ResolverClient.Post(mutation, &response)
   163  	s.Error(err)
   164  	s.Nil(response.CreateTerminal)
   165  }
   166  
   167  func (s *Suite) TestCreateTerminalInvalidMac() {
   168  	integration.SkipIf(s.Framework)
   169  	var response struct{ CreateTerminal *model.Terminal }
   170  
   171  	mutation := "mutation{createTerminal(newTerminal:{lane:\"\",role:worker,discoverDisks:all,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"005e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"1.1.1.1\",gateway6:\"2.2.2.2\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
   172  	err := ResolverClient.Post(mutation, &response)
   173  	s.Error(err)
   174  	s.Nil(response.CreateTerminal)
   175  }
   176  
   177  func (s *Suite) TestCreateTerminalDHCPNotSet() {
   178  	integration.SkipIf(s.Framework)
   179  	var response struct{ CreateTerminal *model.Terminal }
   180  	mutation := "mutation{createTerminal(newTerminal:{lane:\"lane01\",role:worker,discoverDisks:all,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:false,gateway4:\"178.102.156.9\",gateway6:\"f886:c601:c61b:8eb1:ae5b:a21e:4332:f119\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet},{ip:\"a8ec:2b0c:05ac:27be:88e2:de7a:3c81:f439\",prefixLen:24,family:inet}]}]}){clusterEdgeId,lane,role,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
   181  	err := ResolverClient.Post(mutation, &response)
   182  	s.NoError(err)
   183  	terminal := response.CreateTerminal
   184  
   185  	s.NotEmpty(terminal.Interfaces)
   186  	s.Equal(1, len(terminal.Interfaces))
   187  	s.False(terminal.Interfaces[0].Dhcp4)
   188  	s.False(terminal.Interfaces[0].Dhcp6)
   189  	s.NotEmpty(terminal.Interfaces[0].Addresses)
   190  	s.Equal(2, len(terminal.Interfaces[0].Addresses))
   191  	s.Equal("192.168.2.10", *terminal.Interfaces[0].Addresses[0].IP)
   192  	s.Equal("a8ec:2b0c:05ac:27be:88e2:de7a:3c81:f439", *terminal.Interfaces[0].Addresses[1].IP)
   193  
   194  	_, err = s.DB.Exec(sqlquery.TerminalDeleteQuery, terminal.TerminalID)
   195  	s.NoError(err)
   196  }
   197  
   198  func (s *Suite) TestCreateTerminalWithDuplicateDiskPaths() {
   199  	integration.SkipIf(s.Framework)
   200  	var response struct{ CreateTerminal *model.Terminal }
   201  	mutation := "mutation{createTerminal(newTerminal:{role:worker,discoverDisks:empty,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:cc\",dhcp4:true,dhcp6:false}],disks:[{devicePath:\"/dev/sda1\",expectEmpty:true,includeDisk:true},{devicePath:\"/dev/sda1\",expectEmpty:true,includeDisk:true}]}){clusterEdgeId,disks{usePart,terminalId,terminalDiskId,includeDisk,expectEmpty,devicePath}}}"
   202  	err := ResolverClient.Post(mutation, &response)
   203  	s.ErrorContains(err, services.ErrDuplicateTerminalDiskDevicePaths.Error())
   204  }
   205  
   206  func (s *Suite) TestDeleteTerminal() {
   207  	integration.SkipIf(s.Framework)
   208  	var response struct{ DeleteTerminal bool }
   209  	terminalID := "c4aa6450-3b2a-11ed-a261-0242ac12c201"
   210  	mutation := deleteTerminalMutation(&terminalID)
   211  	err := ResolverClient.Post(mutation, &response)
   212  	s.NoError(err)
   213  	s.True(response.DeleteTerminal)
   214  }
   215  
   216  func (s *Suite) TestDeleteTerminalAddress() {
   217  	integration.SkipIf(s.Framework)
   218  
   219  	createAddressArgs := []interface{}{
   220  		"523f8d69-c76e-4592-a9bf-442fdb15e474",
   221  		"203.236.49.66",
   222  		16,
   223  		model.InetTypeInet.String(),
   224  		"3396a52c-6a22-4049-9593-5a63b596a203",
   225  	}
   226  	_, err := s.DB.Exec(sqlquery.TerminalAddressCreateQuery, createAddressArgs...)
   227  	s.NoError(err)
   228  
   229  	createAddressArgsv6 := []interface{}{
   230  		"3a291185-286d-4693-8792-f1a719d0f442",
   231  		"0538:928e:a40b:9529:f72c:599a:6e6e:cfe9",
   232  		16,
   233  		model.InetTypeInet.String(),
   234  		"3396a52c-6a22-4049-9593-5a63b596a203",
   235  	}
   236  	_, err = s.DB.Exec(sqlquery.TerminalAddressCreateQuery, createAddressArgsv6...)
   237  	s.NoError(err)
   238  
   239  	var response struct{ DeleteTerminalAddress bool }
   240  	addressID := "523f8d69-c76e-4592-a9bf-442fdb15e474"
   241  	mutation := deleteTerminalAddressMutation(&addressID)
   242  	err = ResolverClient.Post(mutation, &response)
   243  	s.NoError(err)
   244  	s.True(response.DeleteTerminalAddress)
   245  
   246  	// leave test db unchanged
   247  	_, err = s.DB.Exec(sqlquery.TerminalAddressDeleteQuery, createAddressArgsv6[0])
   248  	s.NoError(err)
   249  }
   250  
   251  func (s *Suite) TestDeleteTerminalError() {
   252  	integration.SkipIf(s.Framework)
   253  	var response struct{ DeleteTerminal bool }
   254  	query := deleteTerminalMutation(nil)
   255  	err := ResolverClient.Post(query, &response)
   256  	s.Error(err)
   257  }
   258  
   259  func (s *Suite) TestDeleteTerminalInterface() {
   260  	integration.SkipIf(s.Framework)
   261  
   262  	createIfaceArgs := []interface{}{
   263  		"55fb8510-3d78-4f8d-a43a-cae429109c6c",
   264  		"02:e8:55:57:bd:80",
   265  		false,
   266  		true,
   267  		"213.170.59.248",
   268  		"252.51.27.170",
   269  		terminalID,
   270  	}
   271  	_, err := s.DB.Exec(sqlquery.TerminalInterfaceCreateQuery, createIfaceArgs...)
   272  	s.NoError(err)
   273  
   274  	var response struct{ DeleteTerminalInterface bool }
   275  	ifaceID := "55fb8510-3d78-4f8d-a43a-cae429109c6c"
   276  	mutation := deleteTerminalInterfaceMutation(&ifaceID)
   277  	err = ResolverClient.Post(mutation, &response)
   278  	s.NoError(err)
   279  	s.True(response.DeleteTerminalInterface)
   280  }
   281  
   282  func (s *Suite) TestDeleteTerminalInterfaceError() {
   283  	integration.SkipIf(s.Framework)
   284  	var response struct{ DeleteTerminalInterface bool }
   285  	ifaceID := "3396a52c-6a22-4049-9593-5a63b596a203"
   286  	mutation := deleteTerminalInterfaceMutation(&ifaceID)
   287  	err = ResolverClient.Post(mutation, &response)
   288  	s.Error(err)
   289  	s.False(response.DeleteTerminalInterface)
   290  }
   291  
   292  func (s *Suite) TestGetTerminal() {
   293  	integration.SkipIf(s.Framework)
   294  
   295  	var response struct{ Terminal *model.Terminal }
   296  	query := getTerminalQuery(&terminalID)
   297  	err = ResolverClient.Post(query, &response)
   298  
   299  	s.NoError(err)
   300  	s.NotEmpty(response.Terminal)
   301  	s.Equal(terminalID, response.Terminal.TerminalID)
   302  	s.NotEmpty(response.Terminal.Interfaces)
   303  	terminalInterface := response.Terminal.Interfaces[0]
   304  	s.Equal("3396a52c-6a22-4049-9593-5a63b596a203", terminalInterface.TerminalInterfaceID)
   305  	s.NotEmpty(terminalInterface.Addresses)
   306  	terminalAddress := terminalInterface.Addresses[0]
   307  	s.Equal("1ad40dca-3b2d-11ed-a261-0242ac12a101", terminalAddress.TerminalAddressID)
   308  }
   309  
   310  func (s *Suite) TestGetTerminalError() {
   311  	integration.SkipIf(s.Framework)
   312  	var response struct{ Terminal *model.Terminal }
   313  	terminalID := "does-not-exist"
   314  	query := getTerminalQuery(&terminalID)
   315  	err := ResolverClient.Post(query, &response)
   316  	s.Error(err)
   317  }
   318  
   319  func (s *Suite) TestGetTerminals() {
   320  	integration.SkipIf(s.Framework)
   321  
   322  	var response struct{ Terminals []*model.Terminal }
   323  	clusterEdgeID := "3396a52c-6a22-4049-9593-5a63b596a200"
   324  	query := getTerminalsQuery(&clusterEdgeID, nil)
   325  	err = ResolverClient.Post(query, &response)
   326  	s.NoError(err)
   327  	s.NotEmpty(response.Terminals)
   328  	s.Equal(1, len(response.Terminals))
   329  	terminal := response.Terminals[0]
   330  	s.Equal(terminalID, terminal.TerminalID)
   331  	terminalInterface := terminal.Interfaces[0]
   332  	s.NotEmpty(terminalInterface.Addresses)
   333  	s.Equal(clusterEdgeID, terminal.ClusterEdgeID)
   334  	s.Equal("lane01", *terminal.Lane)
   335  	s.Equal("00:00:5e:00:53:af", terminal.Interfaces[0].MacAddress)
   336  	s.Equal("192.168.1.1", *terminal.Interfaces[0].Addresses[0].IP)
   337  
   338  	query = getTerminalsQuery(nil, nil)
   339  	err = ResolverClient.Post(query, &response)
   340  	s.NoError(err)
   341  	s.NotEmpty(response.Terminals)
   342  	s.Equal(6, len(response.Terminals))
   343  	s.Equal(terminalID, response.Terminals[0].TerminalID)
   344  }
   345  
   346  func (s *Suite) TestGetTerminalsError() {
   347  	integration.SkipIf(s.Framework)
   348  	var response struct{ Terminals []*model.Terminal }
   349  	clusterEdgeID := "does-not-exist"
   350  	query := getTerminalsQuery(&clusterEdgeID, nil)
   351  	err := ResolverClient.Post(query, &response)
   352  	s.Error(err)
   353  }
   354  
   355  func (s *Suite) TestUpdateTerminal() {
   356  	integration.SkipIf(s.Framework)
   357  
   358  	var response struct{ UpdateTerminal *model.Terminal }
   359  	terminalArgs := []interface{}{
   360  		terminalID,
   361  		"lane01",
   362  		model.TerminalRoleTypeWorker.String(),
   363  		model.TerminalClassTypeTouchpoint,
   364  		model.TerminalDiscoverDisksTypeEmpty,
   365  		nil,
   366  		nil,
   367  		nil,
   368  		false,
   369  		"3396a52c-6a22-4049-9593-5a63b596a200",
   370  	}
   371  
   372  	mutation := fmt.Sprintf("mutation{updateTerminal(terminal:{terminalId:\"%s\",terminalValues:{lane:\"lane20\",class:touchpoint,discoverDisks:empty}}){terminalId,lane,role,class,discoverDisks,clusterEdgeId}}", terminalArgs[0])
   373  	err = ResolverClient.Post(mutation, &response)
   374  	s.NoError(err)
   375  	s.Equal(terminalArgs[0], response.UpdateTerminal.TerminalID)
   376  	s.Equal("lane20", *response.UpdateTerminal.Lane)
   377  	s.Equal(terminalArgs[2], response.UpdateTerminal.Role.String())
   378  	s.Equal(terminalArgs[3], *response.UpdateTerminal.Class)
   379  	s.Equal(terminalArgs[4], *response.UpdateTerminal.DiscoverDisks)
   380  	s.Nil(response.UpdateTerminal.BootDisk)
   381  	s.Nil(response.UpdateTerminal.PrimaryInterface)
   382  	s.Equal(terminalArgs[8], response.UpdateTerminal.SwapEnabled)
   383  	s.Equal(terminalArgs[9], response.UpdateTerminal.ClusterEdgeID)
   384  
   385  	_, err = s.DB.Exec(sqlquery.TerminalUpdateQuery, terminalArgs[2], terminalArgs[2], terminalArgs[3], terminalArgs[4], terminalArgs[5], terminalArgs[6], terminalArgs[7], terminalArgs[8], terminalArgs[0])
   386  	s.NoError(err)
   387  }
   388  
   389  func (s *Suite) TestUpdateTerminalWithBootDisk() {
   390  	integration.SkipIf(s.Framework)
   391  
   392  	var response struct{ UpdateTerminal *model.Terminal }
   393  	terminalArgs := []interface{}{
   394  		terminalID,
   395  		"lane01",
   396  		model.TerminalRoleTypeWorker.String(),
   397  		model.TerminalClassTypeTouchpoint,
   398  		model.TerminalDiscoverDisksTypeEmpty,
   399  		"/dev/sdx",
   400  		nil,
   401  		nil,
   402  		false,
   403  	}
   404  
   405  	mutation := fmt.Sprintf("mutation{updateTerminal(terminal:{terminalId:\"%s\",terminalValues:{bootDisk:\"%s\"}}){bootDisk}}", terminalArgs[0], terminalArgs[5])
   406  	err = ResolverClient.Post(mutation, &response)
   407  	s.NoError(err)
   408  	s.Equal(terminalArgs[5], *response.UpdateTerminal.BootDisk)
   409  
   410  	_, err = s.DB.Exec(sqlquery.TerminalUpdateQuery, terminalArgs[2], terminalArgs[2], terminalArgs[3], terminalArgs[4], terminalArgs[5], terminalArgs[6], terminalArgs[7], terminalArgs[8], terminalArgs[0])
   411  	s.NoError(err)
   412  }
   413  
   414  func (s *Suite) TestUpdateTerminalWithSpecifiedInterface() {
   415  	integration.SkipIf(s.Framework)
   416  
   417  	var response struct{ UpdateTerminal *model.Terminal }
   418  	terminalArgs := []interface{}{
   419  		terminalID,
   420  		"lane01",
   421  		model.TerminalRoleTypeWorker.String(),
   422  		model.TerminalClassTypeTouchpoint,
   423  		model.TerminalDiscoverDisksTypeEmpty,
   424  		nil,
   425  		"3396a52c-6a22-4049-9593-5a63b596a203",
   426  		nil,
   427  		false,
   428  	}
   429  	mutation := fmt.Sprintf("mutation{updateTerminal(terminal:{terminalId:\"%s\",terminalValues:{primaryInterface:\"%s\"}}){primaryInterface}}", terminalArgs[0], terminalArgs[6])
   430  	err = ResolverClient.Post(mutation, &response)
   431  	s.NoError(err)
   432  
   433  	s.Equal(terminalArgs[6], *response.UpdateTerminal.PrimaryInterface)
   434  
   435  	_, err = s.DB.Exec(sqlquery.TerminalUpdateQuery, terminalArgs[2], terminalArgs[2], terminalArgs[3], terminalArgs[4], terminalArgs[5], terminalArgs[6], terminalArgs[7], terminalArgs[8], terminalArgs[0])
   436  	s.NoError(err)
   437  }
   438  
   439  func (s *Suite) TestUpdateTerminalWhenRemovingPrimaryInterface() {
   440  	integration.SkipIf(s.Framework)
   441  
   442  	ifaceID := "55fb8510-3d78-4f8d-a43a-cae429109c6c"
   443  
   444  	createIfaceArgs := []interface{}{
   445  		ifaceID,
   446  		"02:e8:55:57:bd:80",
   447  		false,
   448  		true,
   449  		"213.170.59.248",
   450  		"252.51.27.170",
   451  		terminalID,
   452  	}
   453  	_, err = s.DB.Exec(sqlquery.TerminalInterfaceCreateQuery, createIfaceArgs...)
   454  	s.NoError(err)
   455  
   456  	var updateResponse struct{ UpdateTerminal *model.Terminal }
   457  	terminalArgs := []interface{}{
   458  		terminalID,
   459  		"lane01",
   460  		model.TerminalRoleTypeWorker.String(),
   461  		model.TerminalClassTypeTouchpoint,
   462  		model.TerminalDiscoverDisksTypeEmpty,
   463  		nil,
   464  		ifaceID,
   465  		nil,
   466  		false,
   467  	}
   468  	mutation := fmt.Sprintf("mutation{updateTerminal(terminal:{terminalId:\"%s\",terminalValues:{primaryInterface:\"%s\"}}){primaryInterface}}", terminalArgs[0], terminalArgs[6])
   469  	err = ResolverClient.Post(mutation, &updateResponse)
   470  	s.NoError(err)
   471  
   472  	_, err := s.DB.Exec(sqlquery.TerminalUpdateQuery, terminalArgs[2], terminalArgs[2], terminalArgs[3], terminalArgs[4], terminalArgs[5], terminalArgs[6], terminalArgs[7], terminalArgs[8], terminalArgs[0])
   473  	s.NoError(err)
   474  
   475  	var deleteResponse struct{ DeleteTerminalInterface bool }
   476  	mutation = deleteTerminalInterfaceMutation(&ifaceID)
   477  	err = ResolverClient.Post(mutation, &deleteResponse)
   478  	s.NoError(err)
   479  	s.True(deleteResponse.DeleteTerminalInterface)
   480  
   481  	_, err = s.DB.Exec(sqlquery.TerminalInterfaceDeleteQuery, ifaceID)
   482  	s.NoError(err)
   483  
   484  	var response struct{ Terminal *model.Terminal }
   485  	query := getTerminalQuery(&terminalID)
   486  	err = ResolverClient.Post(query, &response)
   487  	s.NoError(err)
   488  	s.Nil(response.Terminal.PrimaryInterface)
   489  }
   490  
   491  func (s *Suite) TestUpdateTerminalWithInvalidInterface() {
   492  	integration.SkipIf(s.Framework)
   493  	var response struct{ UpdateTerminal *model.Terminal }
   494  	terminalArgs := []interface{}{
   495  		terminalID,
   496  		"lane01",
   497  		model.TerminalRoleTypeWorker.String(),
   498  		model.TerminalClassTypeTouchpoint,
   499  		model.TerminalDiscoverDisksTypeEmpty,
   500  		nil,
   501  		"3396a52f-6a22-4049-9593-5a63b596a204",
   502  		nil,
   503  		false,
   504  	}
   505  	mutation := fmt.Sprintf("mutation{updateTerminal(terminal:{terminalId:\"%s\",terminalValues:{primaryInterface:\"%s\"}}){primaryInterface}}", terminalArgs[0], terminalArgs[6])
   506  	err = ResolverClient.Post(mutation, &response)
   507  	s.Error(err)
   508  
   509  	_, err = s.DB.Exec(sqlquery.TerminalUpdateQuery, terminalArgs[2], terminalArgs[2], terminalArgs[3], terminalArgs[4], terminalArgs[5], terminalArgs[6], terminalArgs[7], terminalArgs[8], terminalArgs[0])
   510  	s.Error(err)
   511  }
   512  
   513  // nolint
   514  func (s *Suite) TestUpdateTerminalInvalidIP() {
   515  	integration.SkipIf(s.Framework)
   516  	var response struct{ UpdateTerminal *model.Terminal }
   517  
   518  	var (
   519  		prefixLen     = 16
   520  		dhcp4         = true
   521  		terminalLane  = "lane20"
   522  		discoverDisks = model.TerminalDiscoverDisksTypeEmpty
   523  		macAddress    = "de:fa:37:f8:6a:b2"
   524  		ip            = ""
   525  	)
   526  	terminalAddressUpdateValues := []*model.TerminalAddressIDInput{
   527  		{
   528  			TerminalAddressID: "1ad40dca-3b2d-11ed-a261-0242ac12a101",
   529  			TerminalAddressValues: &model.TerminalAddressUpdateInput{
   530  				PrefixLen: &prefixLen,
   531  				IP:        &ip,
   532  			},
   533  		},
   534  	}
   535  	terminalInterfaceUpdateValues := []*model.TerminalInterfaceIDInput{
   536  		{
   537  			TerminalInterfaceID: "3396a52c-6a22-4049-9593-5a63b596a203",
   538  			TerminalInterfaceValues: &model.TerminalInterfaceUpdateInput{
   539  				Dhcp4:      &dhcp4,
   540  				MacAddress: &macAddress,
   541  				Addresses:  terminalAddressUpdateValues,
   542  			},
   543  		},
   544  	}
   545  	terminalUpdateValues := model.TerminalIDInput{
   546  		TerminalID: terminalID,
   547  		TerminalValues: &model.TerminalUpdateInput{
   548  			Lane:          &terminalLane,
   549  			DiscoverDisks: &discoverDisks,
   550  			Interfaces:    terminalInterfaceUpdateValues,
   551  		},
   552  	}
   553  
   554  	mutation := updateTerminalMutation(&terminalUpdateValues)
   555  	err := ResolverClient.Post(mutation, &response)
   556  	s.Error(err)
   557  	s.Nil(response.UpdateTerminal)
   558  }
   559  
   560  // nolint
   561  func (s *Suite) TestUpdateTerminalInvalidMac() {
   562  	integration.SkipIf(s.Framework)
   563  	var response struct{ UpdateTerminal *model.Terminal }
   564  
   565  	var (
   566  		prefixLen     = 16
   567  		dhcp4         = true
   568  		terminalLane  = "lane20"
   569  		discoverDisks = model.TerminalDiscoverDisksTypeEmpty
   570  		macAddress    = ""
   571  		ip            = "252.227.220.89"
   572  	)
   573  	terminalAddressUpdateValues := []*model.TerminalAddressIDInput{
   574  		{
   575  			TerminalAddressID: "1ad40dca-3b2d-11ed-a261-0242ac12a101",
   576  			TerminalAddressValues: &model.TerminalAddressUpdateInput{
   577  				PrefixLen: &prefixLen,
   578  				IP:        &ip,
   579  			},
   580  		},
   581  	}
   582  	terminalInterfaceUpdateValues := []*model.TerminalInterfaceIDInput{
   583  		{
   584  			TerminalInterfaceID: "3396a52c-6a22-4049-9593-5a63b596a203",
   585  			TerminalInterfaceValues: &model.TerminalInterfaceUpdateInput{
   586  				Dhcp4:      &dhcp4,
   587  				MacAddress: &macAddress,
   588  				Addresses:  terminalAddressUpdateValues,
   589  			},
   590  		},
   591  	}
   592  	terminalUpdateValues := model.TerminalIDInput{
   593  		TerminalID: terminalID,
   594  		TerminalValues: &model.TerminalUpdateInput{
   595  			Lane:          &terminalLane,
   596  			DiscoverDisks: &discoverDisks,
   597  			Interfaces:    terminalInterfaceUpdateValues,
   598  		},
   599  	}
   600  
   601  	mutation := updateTerminalMutation(&terminalUpdateValues)
   602  	err := ResolverClient.Post(mutation, &response)
   603  	s.Error(err)
   604  	s.Nil(response.UpdateTerminal)
   605  }
   606  
   607  func (s *Suite) TestUpdateTerminalError() {
   608  	integration.SkipIf(s.Framework)
   609  	var response struct{ UpdateTerminal *model.Terminal }
   610  
   611  	terminalAddressUpdateValues := []*model.TerminalAddressIDInput{
   612  		{
   613  			TerminalAddressID:     "f0984590-40b7-11ed-b878-0242ac120002",
   614  			TerminalAddressValues: &model.TerminalAddressUpdateInput{},
   615  		},
   616  	}
   617  	terminalInterfaceUpdateValues := []*model.TerminalInterfaceIDInput{
   618  		{
   619  			TerminalInterfaceID: "e9958cf8-40b7-11ed-b878-0242ac120002",
   620  			TerminalInterfaceValues: &model.TerminalInterfaceUpdateInput{
   621  				Addresses: terminalAddressUpdateValues,
   622  			},
   623  		},
   624  	}
   625  	terminalLane := "lane05"
   626  	discoverDisks := model.TerminalDiscoverDisksTypeEmpty
   627  	terminalUpdateValues := model.TerminalIDInput{
   628  		TerminalID: "e856e784-40b6-11ed-b878-0242ac120002",
   629  		TerminalValues: &model.TerminalUpdateInput{
   630  			Lane:          &terminalLane,
   631  			DiscoverDisks: &discoverDisks,
   632  			Interfaces:    terminalInterfaceUpdateValues,
   633  		},
   634  	}
   635  
   636  	mutation := updateTerminalMutation(&terminalUpdateValues)
   637  	err := ResolverClient.Post(mutation, &response)
   638  	s.Error(err)
   639  	s.Empty(response.UpdateTerminal)
   640  }
   641  
   642  // Try (and fail) to update disks with values that are the same, but are not the same as any existing disks on the terminal
   643  func (s *Suite) TestUpdateTerminalWithDuplicateDiskPaths_One() {
   644  	integration.SkipIf(s.Framework)
   645  
   646  	var response struct{ UpdateTerminal *model.Terminal }
   647  	mutation := "mutation{updateTerminal(terminal:{terminalId:\"42742ecf-55fa-467a-a3b2-174015a8109f\",terminalValues:{disks:[{terminalDiskId:\"ffd5d566-0569-4c8e-8fec-a283898fb487\",terminalDiskValues:{devicePath:\"/dev/sdd123\"}},{terminalDiskId:\"7d36aec7-dfda-49ce-8700-aa337fe74cbf\",terminalDiskValues:{devicePath:\"/dev/sdd123\"}}]}}){terminalId}}"
   648  	err = ResolverClient.Post(mutation, &response)
   649  	s.ErrorContains(err, services.ErrDuplicateTerminalDiskDevicePaths.Error())
   650  }
   651  
   652  // Try (and fail) to update disks with value that is the same as existing disk
   653  func (s *Suite) TestUpdateTerminalWithDuplicateDiskPaths_Two() {
   654  	integration.SkipIf(s.Framework)
   655  
   656  	var response struct{ UpdateTerminal *model.Terminal }
   657  	mutation := "mutation{updateTerminal(terminal:{terminalId:\"42742ecf-55fa-467a-a3b2-174015a8109f\",terminalValues:{disks:[{terminalDiskId:\"ffd5d566-0569-4c8e-8fec-a283898fb487\",terminalDiskValues:{devicePath:\"/dev/sdz\"}}]}}){terminalId}}"
   658  	err = ResolverClient.Post(mutation, &response)
   659  	s.ErrorContains(err, services.ErrDuplicateTerminalDiskDevicePaths.Error())
   660  }
   661  
   662  func (s *Suite) TestGetBannerTerminals() {
   663  	integration.SkipIf(s.Framework)
   664  	var response struct{ BannerTerminals []*model.Terminal }
   665  
   666  	bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
   667  	query := getBannerTerminalsQuery(&bannerEdgeID)
   668  	err := ResolverClient.Post(query, &response)
   669  
   670  	s.NoError(err)
   671  	s.Equal(6, len(response.BannerTerminals))
   672  }
   673  
   674  func (s *Suite) TestGetBannerTerminalsError() {
   675  	integration.SkipIf(s.Framework)
   676  	var response struct {
   677  		BannerTerminals []*model.Terminal
   678  	}
   679  	query := getBannerTerminalsQuery(nil)
   680  	err := ResolverClient.Post(query, &response)
   681  	s.Error(err)
   682  	s.Empty(response.BannerTerminals)
   683  }
   684  
   685  func (s *Suite) TestGetTerminalDevices() {
   686  	integration.SkipIf(s.Framework)
   687  
   688  	var response struct{ TerminalDevices *model.TerminalDevices }
   689  	query := getTerminalDevicesQuery(&terminalID)
   690  	err = ResolverClient.Post(query, &response)
   691  	s.NoError(err)
   692  
   693  	s.NotEmpty(response.TerminalDevices)
   694  	s.Len(response.TerminalDevices.Classes, 1)
   695  	s.Len(response.TerminalDevices.Classes[0].Devices, 1)
   696  	s.Equal(response.TerminalDevices.Classes[0].Devices[0].Name, "card0-VGA-1 ACR-2199")
   697  }
   698  
   699  var terminalFields = []*graphb.Field{
   700  	{
   701  		Name: "clusterEdgeId",
   702  	},
   703  	{
   704  		Name: "clusterName",
   705  	},
   706  	{
   707  		Name: "hostname",
   708  	},
   709  	{
   710  		Name: "lane",
   711  	},
   712  	{
   713  		Name: "role",
   714  	},
   715  	{
   716  		Name: "terminalId",
   717  	},
   718  	{
   719  		Name: "class",
   720  	},
   721  	{
   722  		Name: "discoverDisks",
   723  	},
   724  	{
   725  		Name: "interfaces",
   726  		Fields: []*graphb.Field{
   727  			{
   728  				Name: "dhcp4",
   729  			},
   730  			{
   731  				Name: "dhcp6",
   732  			},
   733  			{
   734  				Name: "gateway4",
   735  			},
   736  			{
   737  				Name: "gateway6",
   738  			},
   739  			{
   740  				Name: "macAddress",
   741  			},
   742  			{
   743  				Name: "terminalId",
   744  			},
   745  			{
   746  				Name: "terminalInterfaceId",
   747  			},
   748  			{
   749  				Name: "addresses",
   750  				Fields: []*graphb.Field{
   751  					{
   752  						Name: "family",
   753  					},
   754  					{
   755  						Name: "terminalInterfaceId",
   756  					},
   757  					{
   758  						Name: "ip",
   759  					},
   760  					{
   761  						Name: "prefixLen",
   762  					},
   763  					{
   764  						Name: "terminalAddressId",
   765  					},
   766  				},
   767  			},
   768  		},
   769  	},
   770  }
   771  
   772  func updateTerminalMutation(updateTerminal *model.TerminalIDInput) string {
   773  	terminalValues := updateTerminal.TerminalValues
   774  	terminalInterfaceValues := terminalValues.Interfaces[0].TerminalInterfaceValues
   775  	terminalAddressValues := terminalInterfaceValues.Addresses[0].TerminalAddressValues
   776  	return MustParse(graphb.Query{
   777  		Type: graphb.TypeMutation,
   778  		Fields: []*graphb.Field{
   779  			{
   780  				Name: "updateTerminal",
   781  				Arguments: []graphb.Argument{
   782  					graphb.ArgumentCustomType("terminal",
   783  						graphb.ArgumentString("terminalId", updateTerminal.TerminalID),
   784  						graphb.ArgumentCustomType("terminalValues",
   785  							graphb.ArgumentString("lane", utils.ConvertToString(terminalValues.Lane)),
   786  							graphb.ArgumentString("discoverDisks", terminalValues.DiscoverDisks.String()),
   787  							graphb.ArgumentCustomTypeSlice("interfaces",
   788  								graphb.ArgumentCustomTypeSliceElem(
   789  									graphb.ArgumentString("terminalInterfaceId", terminalValues.Interfaces[0].TerminalInterfaceID),
   790  									graphb.ArgumentCustomType("terminalInterfaceValues",
   791  										graphb.ArgumentString("macAddress", utils.ConvertToString(terminalInterfaceValues.MacAddress)),
   792  										graphb.ArgumentBool("dhcp4", utils.ConvertToBool(terminalInterfaceValues.Dhcp4)),
   793  										graphb.ArgumentCustomTypeSlice("addresses",
   794  											graphb.ArgumentCustomTypeSliceElem(
   795  												graphb.ArgumentString("terminalAddressId", terminalInterfaceValues.Addresses[0].TerminalAddressID),
   796  												graphb.ArgumentCustomType("terminalAddressValues",
   797  													graphb.ArgumentString("ip", utils.ConvertToString(terminalAddressValues.IP)),
   798  													graphb.ArgumentInt("prefixLen", utils.ConvertToInt(terminalAddressValues.PrefixLen)),
   799  												),
   800  											),
   801  										),
   802  									),
   803  								),
   804  							),
   805  						),
   806  					),
   807  				},
   808  				Fields: terminalFields,
   809  			},
   810  		},
   811  	})
   812  }
   813  
   814  func deleteTerminalMutation(terminalID *string) string {
   815  	return MustParse(graphb.Query{
   816  		Type: graphb.TypeMutation,
   817  		Fields: []*graphb.Field{
   818  			{
   819  				Name: "deleteTerminal",
   820  				Arguments: []graphb.Argument{
   821  					graphb.ArgumentString("terminalId", utils.ConvertToString(terminalID)),
   822  				},
   823  			},
   824  		},
   825  	})
   826  }
   827  
   828  func deleteTerminalInterfaceMutation(terminalInterfaceID *string) string {
   829  	return MustParse(graphb.Query{
   830  		Type: graphb.TypeMutation,
   831  		Fields: []*graphb.Field{
   832  			{
   833  				Name: "deleteTerminalInterface",
   834  				Arguments: []graphb.Argument{
   835  					graphb.ArgumentString("terminalInterfaceId", utils.ConvertToString(terminalInterfaceID)),
   836  				},
   837  			},
   838  		},
   839  	})
   840  }
   841  
   842  func deleteTerminalAddressMutation(terminalAddressID *string) string {
   843  	return MustParse(graphb.Query{
   844  		Type: graphb.TypeMutation,
   845  		Fields: []*graphb.Field{
   846  			{
   847  				Name: "deleteTerminalAddress",
   848  				Arguments: []graphb.Argument{
   849  					graphb.ArgumentString("terminalAddressId", utils.ConvertToString(terminalAddressID)),
   850  				},
   851  			},
   852  		},
   853  	})
   854  }
   855  
   856  func getTerminalQuery(terminalID *string) string {
   857  	return MustParse(graphb.Query{
   858  		Type: graphb.TypeQuery,
   859  		Fields: []*graphb.Field{
   860  			{
   861  				Name: "terminal",
   862  				Arguments: []graphb.Argument{
   863  					graphb.ArgumentString("terminalId", utils.ConvertToString(terminalID)),
   864  				},
   865  				Fields: terminalFields,
   866  			},
   867  		},
   868  	})
   869  }
   870  
   871  func getTerminalDevicesQuery(terminalID *string) string {
   872  	return MustParse(graphb.Query{
   873  		Type: graphb.TypeQuery,
   874  		Fields: []*graphb.Field{
   875  			{
   876  				Name: "terminalDevices",
   877  				Arguments: []graphb.Argument{
   878  					graphb.ArgumentString("terminalId", utils.ConvertToString(terminalID)),
   879  				},
   880  				Fields: terminalDeviceFields(),
   881  			},
   882  		},
   883  	})
   884  }
   885  
   886  func terminalDeviceFields() []*graphb.Field {
   887  	return []*graphb.Field{
   888  		{
   889  			Name: "classes",
   890  			Fields: []*graphb.Field{
   891  				{
   892  					Name: "devices",
   893  					Fields: []*graphb.Field{
   894  						{
   895  							Name: "name",
   896  						},
   897  					},
   898  				},
   899  				{
   900  					Name: "name",
   901  				},
   902  			},
   903  		},
   904  	}
   905  }
   906  
   907  func getTerminalsQuery(clusterEdgeID *string, terminalHostname *string) string {
   908  	getTerminalsArg := []graphb.Argument{}
   909  	if clusterEdgeID != nil {
   910  		getTerminalsArg = append(getTerminalsArg, graphb.ArgumentString("clusterEdgeId", utils.ConvertToString(clusterEdgeID)))
   911  	}
   912  	if terminalHostname != nil {
   913  		getTerminalsArg = append(getTerminalsArg, graphb.ArgumentString("hostname", utils.ConvertToString(terminalHostname)))
   914  	}
   915  	return MustParse(graphb.Query{
   916  		Type: graphb.TypeQuery,
   917  		Fields: []*graphb.Field{
   918  			{
   919  				Name:      "terminals",
   920  				Arguments: getTerminalsArg,
   921  				Fields:    terminalFields,
   922  			},
   923  		},
   924  	})
   925  }
   926  
   927  func getBannerTerminalsQuery(bannerEdgeID *string) string {
   928  	getBannerTerminalsArg := []graphb.Argument{}
   929  	if bannerEdgeID != nil {
   930  		getBannerTerminalsArg = append(getBannerTerminalsArg, graphb.ArgumentString("bannerEdgeId", utils.ConvertToString(bannerEdgeID)))
   931  	}
   932  	return MustParse(graphb.Query{
   933  		Type: graphb.TypeQuery,
   934  		Fields: []*graphb.Field{
   935  			{
   936  				Name:      "bannerTerminals",
   937  				Arguments: getBannerTerminalsArg,
   938  				Fields:    terminalFields,
   939  			},
   940  		},
   941  	})
   942  }
   943  

View as plain text