new: Add support LKE, Volume, NodeBalancer, and network transfer pricing endpoints

[lgarber-akamai]

📝 Description

This pull request adds support for the following endpoints:

• https://api.linode.com/v4/lke/types
• https://api.linode.com/v4/nodebalancers/types
• https://api.linode.com/v4/volumes/types
• https://api.linode.com/v4/network-transfer/prices

✔️ How to Test

The following test steps assume you have pulled down this PR locally.

Integration Testing

make fixtures ARGS="-run TestNetworkTransferPrice -run TestLKEType -run TestNodeBalancerType -run TestVolumeType"

Manual Testing

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

package main

import (
	"context"
	"github.com/kr/pretty"
	"github.com/linode/linodego"
	"log"
	"os"
)

func main() {
	ctx := context.Background()

	client := linodego.NewClient(nil)
	client.SetToken(os.Getenv("LINODE_TOKEN"))

	lkeTypes, err := client.ListLKETypes(ctx, nil)
	if err != nil {
		log.Fatalf("failed to get LKE types: %s", err)
	}

	nbTypes, err := client.ListNodeBalancerTypes(ctx, nil)
	if err != nil {
		log.Fatalf("failed to get NodeBalancer types: %s", err)
	}

	volumeTypes, err := client.ListVolumeTypes(ctx, nil)
	if err != nil {
		log.Fatalf("failed to get Volume types: %s", err)
	}

	transferPrices, err := client.ListNetworkTransferPrices(ctx, nil)
	if err != nil {
		log.Fatalf("failed to get network transfer types: %s", err)
	}

	pretty.Println(lkeTypes)
	pretty.Println(nbTypes)
	pretty.Println(volumeTypes)
	pretty.Println(transferPrices)
}

2. Ensure the output matches the following:

Expected Output

[]linodego.LKEType{
    {
        baseType: linodego.baseType[github.com/linode/linodego.LKETypePrice,github.com/linode/linodego.LKETypeRegionPrice]{
            ID:           "lke-sa",
            Label:        "LKE Standard Availability",
            Price:        linodego.LKETypePrice{},
            RegionPrices: {
            },
            Transfer: 0,
        },
    },
    {
        baseType: linodego.baseType[github.com/linode/linodego.LKETypePrice,github.com/linode/linodego.LKETypeRegionPrice]{
            ID:    "lke-ha",
            Label: "LKE High Availability",
            Price: linodego.LKETypePrice{
                baseTypePrice: linodego.baseTypePrice{Hourly:0.09, Monthly:60},
            },
            RegionPrices: {
                {
                    baseTypeRegionPrice: linodego.baseTypeRegionPrice{
                        baseTypePrice: linodego.baseTypePrice{Hourly:0.108, Monthly:72},
                        ID:            "id-cgk",
                    },
                },
                {
                    baseTypeRegionPrice: linodego.baseTypeRegionPrice{
                        baseTypePrice: linodego.baseTypePrice{Hourly:0.126, Monthly:84},
                        ID:            "br-gru",
                    },
                },
            },
            Transfer: 0,
        },
    },
}
[]linodego.NodeBalancerType{
    {
        baseType: linodego.baseType[github.com/linode/linodego.NodeBalancerTypePrice,github.com/linode/linodego.NodeBalancerTypeRegionPrice]{
            ID:    "nodebalancer",
            Label: "NodeBalancer",
            Price: linodego.NodeBalancerTypePrice{
                baseTypePrice: linodego.baseTypePrice{Hourly:0.015, Monthly:10},
            },
            RegionPrices: {
                {
                    baseTypeRegionPrice: linodego.baseTypeRegionPrice{
                        baseTypePrice: linodego.baseTypePrice{Hourly:0.018, Monthly:12},
                        ID:            "id-cgk",
                    },
                },
                {
                    baseTypeRegionPrice: linodego.baseTypeRegionPrice{
                        baseTypePrice: linodego.baseTypePrice{Hourly:0.021, Monthly:14},
                        ID:            "br-gru",
                    },
                },
            },
            Transfer: 0,
        },
    },
}
[]linodego.VolumeType{
    {
        baseType: linodego.baseType[github.com/linode/linodego.VolumeTypePrice,github.com/linode/linodego.VolumeTypeRegionPrice]{
            ID:    "volume",
            Label: "Storage Volume",
            Price: linodego.VolumeTypePrice{
                baseTypePrice: linodego.baseTypePrice{Hourly:0.00015, Monthly:0.1},
            },
            RegionPrices: {
                {
                    baseTypeRegionPrice: linodego.baseTypeRegionPrice{
                        baseTypePrice: linodego.baseTypePrice{Hourly:0.00018, Monthly:0.12},
                        ID:            "id-cgk",
                    },
                },
                {
                    baseTypeRegionPrice: linodego.baseTypeRegionPrice{
                        baseTypePrice: linodego.baseTypePrice{Hourly:0.00021, Monthly:0.14},
                        ID:            "br-gru",
                    },
                },
            },
            Transfer: 0,
        },
    },
}
[]linodego.NetworkTransferPrice{
    {
        baseType: linodego.baseType[github.com/linode/linodego.NetworkTransferTypePrice,github.com/linode/linodego.NetworkTransferTypeRegionPrice]{
            ID:    "distributed_network_transfer",
            Label: "Distributed Network Transfer",
            Price: linodego.NetworkTransferTypePrice{
                baseTypePrice: linodego.baseTypePrice{Hourly:0.01, Monthly:0},
            },
            RegionPrices: {
            },
            Transfer: 0,
        },
    },
    {
        baseType: linodego.baseType[github.com/linode/linodego.NetworkTransferTypePrice,github.com/linode/linodego.NetworkTransferTypeRegionPrice]{
            ID:    "network_transfer",
            Label: "Network Transfer",
            Price: linodego.NetworkTransferTypePrice{
                baseTypePrice: linodego.baseTypePrice{Hourly:0.005, Monthly:0},
            },
            RegionPrices: {
                {
                    baseTypeRegionPrice: linodego.baseTypeRegionPrice{
                        baseTypePrice: linodego.baseTypePrice{Hourly:0.015, Monthly:0},
                        ID:            "id-cgk",
                    },
                },
                {
                    baseTypeRegionPrice: linodego.baseTypeRegionPrice{
                        baseTypePrice: linodego.baseTypePrice{Hourly:0.007, Monthly:0},
                        ID:            "br-gru",
                    },
                },
            },
            Transfer: 0,
        },
    },
}

[lgarber-akamai]

I decided to use a generic base struct so we can still share common type fields while allowing resource types of diverge without a breaking change if necessary.

[lgarber-akamai]

I gave each resource type its own price and region prices structs so external users can still store & access them separate from their parent struct.

[yec-akamai]

I learned this pattern and put them similarly in python-sdk as well.

[ezilber-akamai]

Is there a reason that a fixture for the lke types tests isn't included? Otherwise, everything is passing and working properly. Nice work!

[lgarber-akamai]

Is there a reason that a fixture for the lke types tests isn't included? Otherwise, everything is passing and working properly. Nice work!

Nice catch! I forgot to re-run it lol

[yec-akamai]

Tested and worked well locally!