Linode Interfaces: Consolidate InterfaceGeneration and LinodeInterfaces fields into InstanceCreateOptions

[lgarber-akamai]

📝 Description

This pull request consolidates the InterfaceGeneration and Interfaces fields from InstanceCreateOptionsWithLinodeInterfaces into the InstanceCreateOptions struct, overriding MarshalJSON and UnmarshalJSON to dynamically determine how fields should be serialized to and deserialized according to the API implementation.

This is necessary because the composition-based approach required significant flow changes in consumers due to the need to use a separate function and options struct. Additionally, the previous implementation did not allow the InterfaceGeneration to be specified when not using the composited struct.

✔️ How to Test

The following test steps assume you have pulled down this PR locally and are pointing at an account with access to Linode Interfaces.

Integration Testing

make fixtures TEST_ARGS="-run Interface"

Manual Testing

1. In a linodego sandbox environment (e.g. dx-devenv), run the following:

package main

import (
	"encoding/json"
	"fmt"

	"github.com/davecgh/go-spew/spew"
	"github.com/linode/linodego"
)

func main() {
	withLinodeInterface, err := json.Marshal(
		linodego.InstanceCreateOptions{
			Label:               "test-instance",
			Region:              "us-mia",
			Type:                "g6-nanode-1",
			InterfaceGeneration: linodego.GenerationLinode,
			LinodeInterfaces: []linodego.LinodeInterfaceCreateOptions{
				{
					Public: &linodego.PublicInterfaceCreateOptions{},
				},
				{
					VLAN: &linodego.VLANInterface{
						Label: "test-vlan",
					},
				},
			},
		},
	)
	if err != nil {
		panic(err)
	}

	withConfigInterface, err := json.Marshal(
		linodego.InstanceCreateOptions{
			Label:               "test-instance",
			Region:              "us-mia",
			Type:                "g6-nanode-1",
			InterfaceGeneration: linodego.GenerationLegacyConfig,
			Interfaces: []linodego.InstanceConfigInterfaceCreateOptions{
				{
					Purpose: "public",
				},
				{
					Purpose: "vlan",
					Label:   "test-vlan",
				},
			},
		},
	)
	if err != nil {
		panic(err)
	}

	fmt.Printf("With Linode Interface: %s\n", string(withLinodeInterface))
	fmt.Printf("With Config Interface: %s\n", string(withConfigInterface))

	var withLinodeInterfaceParsed, withConfigInterfaceParsed linodego.InstanceCreateOptions

	if err := json.Unmarshal(withLinodeInterface, &withLinodeInterfaceParsed); err != nil {
		panic(err)
	}

	if err := json.Unmarshal(withConfigInterface, &withConfigInterfaceParsed); err != nil {
		panic(err)
	}

	fmt.Printf("With Linode Interface (parsed): %s\n", spew.Sdump(withLinodeInterfaceParsed.LinodeInterfaces))
	fmt.Printf("With Config Interface (parsed): %s\n", spew.Sdump(withConfigInterfaceParsed.Interfaces))
}

2. Ensure the output matches the following:

With Linode Interface: {"region":"us-mia","type":"g6-nanode-1","label":"test-instance","interface_generation":"linode","interfaces":[{"public":{"ipv4":{},"ipv6":{}}},{"vlan":{"vlan_label":"test-vlan"}}]}
With Config Interface: {"region":"us-mia","type":"g6-nanode-1","label":"test-instance","interface_generation":"legacy_config","interfaces":[{"purpose":"public"},{"label":"test-vlan","purpose":"vlan"}]}

With Linode Interface (parsed): ([]linodego.LinodeInterfaceCreateOptions) (len=2 cap=2) {
 (linodego.LinodeInterfaceCreateOptions) {
  FirewallID: (*int)(<nil>),
  DefaultRoute: (*linodego.InterfaceDefaultRoute)(<nil>),
  Public: (*linodego.PublicInterfaceCreateOptions)(0x140001b51d0)({
   IPv4: (linodego.PublicInterfaceIPv4CreateOptions) {
    Addresses: ([]linodego.PublicInterfaceIPv4AddressCreateOptions) <nil>
   },
   IPv6: (linodego.PublicInterfaceIPv6CreateOptions) {
    Ranges: ([]linodego.PublicInterfaceIPv6RangeCreateOptions) <nil>
   }
  }),
  VPC: (*linodego.VPCInterfaceCreateOptions)(<nil>),
  VLAN: (*linodego.VLANInterface)(<nil>)
 },
 (linodego.LinodeInterfaceCreateOptions) {
  FirewallID: (*int)(<nil>),
  DefaultRoute: (*linodego.InterfaceDefaultRoute)(<nil>),
  Public: (*linodego.PublicInterfaceCreateOptions)(<nil>),
  VPC: (*linodego.VPCInterfaceCreateOptions)(<nil>),
  VLAN: (*linodego.VLANInterface)(0x14000130768)({
   Label: (string) (len=9) "test-vlan",
   IPAMAddress: (*string)(<nil>)
  })
 }
}

With Config Interface (parsed): ([]linodego.InstanceConfigInterfaceCreateOptions) (len=2 cap=2) {
 (linodego.InstanceConfigInterfaceCreateOptions) {
  IPAMAddress: (string) "",
  Label: (string) "",
  Purpose: (linodego.ConfigInterfacePurpose) (len=6) "public",
  Primary: (bool) false,
  SubnetID: (*int)(<nil>),
  IPv4: (*linodego.VPCIPv4)(<nil>),
  IPRanges: ([]string) <nil>
 },
 (linodego.InstanceConfigInterfaceCreateOptions) {
  IPAMAddress: (string) "",
  Label: (string) (len=9) "test-vlan",
  Purpose: (linodego.ConfigInterfacePurpose) (len=4) "vlan",
  Primary: (bool) false,
  SubnetID: (*int)(<nil>),
  IPv4: (*linodego.VPCIPv4)(<nil>),
  IPRanges: ([]string) <nil>
 }
}

[ezilber-akamai]

Nice work! Integration and manual testing is working locally.

[ykim-akamai]

LGTM, all tests pass locally