0785c2f6fc
This follows #8232 which added the code to generate the code required to parse HCL files for each packer component. All old config files of packer will keep on working the same. Packer takes one argument. When a directory is passed, all files in the folder with a name ending with “.pkr.hcl” or “.pkr.json” will be parsed using the HCL2 format. When a file ending with “.pkr.hcl” or “.pkr.json” is passed it will be parsed using the HCL2 format. For every other case; the old packer style will be used. ## 1. the hcl2template pkg can create a packer.Build from a set of HCL (v2) files I had to make the packer.coreBuild (which is our one and only packer.Build ) a public struct with public fields ## 2. Components interfaces get a new ConfigSpec Method to read a file from an HCL file. This is a breaking change for packer plugins. a packer component can be a: builder/provisioner/post-processor each component interface now gets a `ConfigSpec() hcldec.ObjectSpec` which allows packer to tell what is the layout of the hcl2 config meant to configure that specific component. This ObjectSpec is sent through the wire (RPC) and a cty.Value is now sent through the already existing configuration entrypoints: Provisioner.Prepare(raws ...interface{}) error Builder.Prepare(raws ...interface{}) ([]string, error) PostProcessor.Configure(raws ...interface{}) error close #1768 Example hcl files: ```hcl // file amazon-ebs-kms-key/run.pkr.hcl build { sources = [ "source.amazon-ebs.first", ] provisioner "shell" { inline = [ "sleep 5" ] } post-processor "shell-local" { inline = [ "sleep 5" ] } } // amazon-ebs-kms-key/source.pkr.hcl source "amazon-ebs" "first" { ami_name = "hcl2-test" region = "us-east-1" instance_type = "t2.micro" kms_key_id = "c729958f-c6ba-44cd-ab39-35ab68ce0a6c" encrypt_boot = true source_ami_filter { filters { virtualization-type = "hvm" name = "amzn-ami-hvm-????.??.?.????????-x86_64-gp2" root-device-type = "ebs" } most_recent = true owners = ["amazon"] } launch_block_device_mappings { device_name = "/dev/xvda" volume_size = 20 volume_type = "gp2" delete_on_termination = "true" } launch_block_device_mappings { device_name = "/dev/xvdf" volume_size = 500 volume_type = "gp2" delete_on_termination = true encrypted = true } ami_regions = ["eu-central-1"] run_tags { Name = "packer-solr-something" stack-name = "DevOps Tools" } communicator = "ssh" ssh_pty = true ssh_username = "ec2-user" associate_public_ip_address = true } ```
626 lines
18 KiB
Go
626 lines
18 KiB
Go
package arm
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"testing"
|
|
|
|
"github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2018-02-01/resources"
|
|
approvaltests "github.com/approvals/go-approval-tests"
|
|
"github.com/hashicorp/packer/builder/azure/common/constants"
|
|
"github.com/hashicorp/packer/builder/azure/common/template"
|
|
)
|
|
|
|
// Ensure the link values are not set, and the concrete values are set.
|
|
func TestVirtualMachineDeployment00(t *testing.T) {
|
|
var c Config
|
|
c.Prepare(getArmBuilderConfiguration(), getPackerConfiguration())
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if deployment.Properties.Mode != resources.Incremental {
|
|
t.Errorf("Expected deployment.Properties.Mode to be %s, but got %s", resources.Incremental, deployment.Properties.Mode)
|
|
}
|
|
|
|
if deployment.Properties.ParametersLink != nil {
|
|
t.Error("Expected the ParametersLink to be nil!")
|
|
}
|
|
|
|
if deployment.Properties.TemplateLink != nil {
|
|
t.Error("Expected the TemplateLink to be nil!")
|
|
}
|
|
|
|
if deployment.Properties.Parameters == nil {
|
|
t.Error("Expected the Parameters to not be nil!")
|
|
}
|
|
|
|
if deployment.Properties.Template == nil {
|
|
t.Error("Expected the Template to not be nil!")
|
|
}
|
|
}
|
|
|
|
// Ensure the Virtual Machine template is a valid JSON document.
|
|
func TestVirtualMachineDeployment01(t *testing.T) {
|
|
var c Config
|
|
c.Prepare(getArmBuilderConfiguration(), getPackerConfiguration())
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
_, err = json.Marshal(deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Ensure the Virtual Machine template parameters are correct.
|
|
func TestVirtualMachineDeployment02(t *testing.T) {
|
|
var c Config
|
|
c.Prepare(getArmBuilderConfiguration(), getPackerConfiguration())
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
bs, err := json.Marshal(deployment.Properties.Parameters)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
var params template.TemplateParameters
|
|
err = json.Unmarshal(bs, ¶ms)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if params.AdminUsername.Value != c.UserName {
|
|
t.Errorf("Expected template parameter 'AdminUsername' to be %s, but got %s.", params.AdminUsername.Value, c.UserName)
|
|
}
|
|
if params.AdminPassword.Value != c.tmpAdminPassword {
|
|
t.Errorf("Expected template parameter 'AdminPassword' to be %s, but got %s.", params.AdminPassword.Value, c.tmpAdminPassword)
|
|
}
|
|
if params.DnsNameForPublicIP.Value != c.tmpComputeName {
|
|
t.Errorf("Expected template parameter 'DnsNameForPublicIP' to be %s, but got %s.", params.DnsNameForPublicIP.Value, c.tmpComputeName)
|
|
}
|
|
if params.OSDiskName.Value != c.tmpOSDiskName {
|
|
t.Errorf("Expected template parameter 'OSDiskName' to be %s, but got %s.", params.OSDiskName.Value, c.tmpOSDiskName)
|
|
}
|
|
if params.StorageAccountBlobEndpoint.Value != c.storageAccountBlobEndpoint {
|
|
t.Errorf("Expected template parameter 'StorageAccountBlobEndpoint' to be %s, but got %s.", params.StorageAccountBlobEndpoint.Value, c.storageAccountBlobEndpoint)
|
|
}
|
|
if params.VMSize.Value != c.VMSize {
|
|
t.Errorf("Expected template parameter 'VMSize' to be %s, but got %s.", params.VMSize.Value, c.VMSize)
|
|
}
|
|
if params.VMName.Value != c.tmpComputeName {
|
|
t.Errorf("Expected template parameter 'VMName' to be %s, but got %s.", params.VMName.Value, c.tmpComputeName)
|
|
}
|
|
}
|
|
|
|
// Ensure the VM template is correct when using a market place image.
|
|
func TestVirtualMachineDeployment03(t *testing.T) {
|
|
m := getArmBuilderConfiguration()
|
|
m["image_publisher"] = "ImagePublisher"
|
|
m["image_offer"] = "ImageOffer"
|
|
m["image_sku"] = "ImageSku"
|
|
m["image_version"] = "ImageVersion"
|
|
|
|
var c Config
|
|
c.Prepare(m, getPackerConfiguration())
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = approvaltests.VerifyJSONStruct(t, deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Ensure the VM template is correct when using a custom image.
|
|
func TestVirtualMachineDeployment04(t *testing.T) {
|
|
config := map[string]string{
|
|
"capture_name_prefix": "ignore",
|
|
"capture_container_name": "ignore",
|
|
"location": "ignore",
|
|
"image_url": "https://localhost/custom.vhd",
|
|
"resource_group_name": "ignore",
|
|
"storage_account": "ignore",
|
|
"subscription_id": "ignore",
|
|
"os_type": constants.Target_Linux,
|
|
"communicator": "none",
|
|
}
|
|
|
|
var c Config
|
|
_, err := c.Prepare(config, getPackerConfiguration())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = approvaltests.VerifyJSONStruct(t, deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestVirtualMachineDeployment05(t *testing.T) {
|
|
config := map[string]string{
|
|
"capture_name_prefix": "ignore",
|
|
"capture_container_name": "ignore",
|
|
"location": "ignore",
|
|
"image_url": "https://localhost/custom.vhd",
|
|
"resource_group_name": "ignore",
|
|
"storage_account": "ignore",
|
|
"subscription_id": "ignore",
|
|
"os_type": constants.Target_Linux,
|
|
"communicator": "none",
|
|
"virtual_network_name": "virtualNetworkName",
|
|
"virtual_network_resource_group_name": "virtualNetworkResourceGroupName",
|
|
"virtual_network_subnet_name": "virtualNetworkSubnetName",
|
|
}
|
|
|
|
var c Config
|
|
_, err := c.Prepare(config, getPackerConfiguration())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = approvaltests.VerifyJSONStruct(t, deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Verify that tags are properly applied to every resource
|
|
func TestVirtualMachineDeployment06(t *testing.T) {
|
|
config := map[string]interface{}{
|
|
"capture_name_prefix": "ignore",
|
|
"capture_container_name": "ignore",
|
|
"location": "ignore",
|
|
"image_url": "https://localhost/custom.vhd",
|
|
"resource_group_name": "ignore",
|
|
"storage_account": "ignore",
|
|
"subscription_id": "ignore",
|
|
"os_type": constants.Target_Linux,
|
|
"communicator": "none",
|
|
"azure_tags": map[string]string{
|
|
"tag01": "value01",
|
|
"tag02": "value02",
|
|
"tag03": "value03",
|
|
},
|
|
}
|
|
|
|
var c Config
|
|
_, err := c.Prepare(config, getPackerConfiguration())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = approvaltests.VerifyJSONStruct(t, deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Verify that custom data are properly inserted
|
|
func TestVirtualMachineDeployment07(t *testing.T) {
|
|
config := map[string]interface{}{
|
|
"capture_name_prefix": "ignore",
|
|
"capture_container_name": "ignore",
|
|
"location": "ignore",
|
|
"image_url": "https://localhost/custom.vhd",
|
|
"resource_group_name": "ignore",
|
|
"storage_account": "ignore",
|
|
"subscription_id": "ignore",
|
|
"os_type": constants.Target_Linux,
|
|
"communicator": "none",
|
|
}
|
|
|
|
var c Config
|
|
_, err := c.Prepare(config, getPackerConfiguration())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// The user specifies a configuration value for the setting custom_data_file.
|
|
// The config type will read that file, and base64 encode it. The encoded
|
|
// contents are then assigned to Config's customData property, which are directly
|
|
// injected into the template.
|
|
//
|
|
// I am not aware of an easy to mimic this situation in a test without having
|
|
// a file on disk, which I am loathe to do. The alternative is to inject base64
|
|
// encoded data myself, which is what I am doing here.
|
|
customData := `#cloud-config
|
|
growpart:
|
|
mode: off
|
|
`
|
|
base64CustomData := base64.StdEncoding.EncodeToString([]byte(customData))
|
|
c.customData = base64CustomData
|
|
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = approvaltests.VerifyJSONStruct(t, deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Ensure the VM template is correct when building from a custom managed image.
|
|
func TestVirtualMachineDeployment08(t *testing.T) {
|
|
config := map[string]interface{}{
|
|
"location": "ignore",
|
|
"subscription_id": "ignore",
|
|
"os_type": constants.Target_Linux,
|
|
"communicator": "none",
|
|
"custom_managed_image_resource_group_name": "CustomManagedImageResourceGroupName",
|
|
"custom_managed_image_name": "CustomManagedImageName",
|
|
"managed_image_name": "ManagedImageName",
|
|
"managed_image_resource_group_name": "ManagedImageResourceGroupName",
|
|
}
|
|
|
|
var c Config
|
|
_, err := c.Prepare(config, getPackerConfiguration())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = approvaltests.VerifyJSONStruct(t, deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Ensure the VM template is correct when building from a platform managed image.
|
|
func TestVirtualMachineDeployment09(t *testing.T) {
|
|
config := map[string]interface{}{
|
|
"location": "ignore",
|
|
"subscription_id": "ignore",
|
|
"os_type": constants.Target_Linux,
|
|
"communicator": "none",
|
|
"image_publisher": "--image-publisher--",
|
|
"image_offer": "--image-offer--",
|
|
"image_sku": "--image-sku--",
|
|
"image_version": "--version--",
|
|
"managed_image_name": "ManagedImageName",
|
|
"managed_image_resource_group_name": "ManagedImageResourceGroupName",
|
|
}
|
|
|
|
var c Config
|
|
_, err := c.Prepare(config, getPackerConfiguration())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = approvaltests.VerifyJSONStruct(t, deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Ensure the VM template is correct when building with PublicIp and connect to Private Network
|
|
func TestVirtualMachineDeployment10(t *testing.T) {
|
|
config := map[string]interface{}{
|
|
"location": "ignore",
|
|
"subscription_id": "ignore",
|
|
"os_type": constants.Target_Linux,
|
|
"communicator": "none",
|
|
"image_publisher": "--image-publisher--",
|
|
"image_offer": "--image-offer--",
|
|
"image_sku": "--image-sku--",
|
|
"image_version": "--version--",
|
|
|
|
"virtual_network_resource_group_name": "--virtual_network_resource_group_name--",
|
|
"virtual_network_name": "--virtual_network_name--",
|
|
"virtual_network_subnet_name": "--virtual_network_subnet_name--",
|
|
"private_virtual_network_with_public_ip": true,
|
|
|
|
"managed_image_name": "ManagedImageName",
|
|
"managed_image_resource_group_name": "ManagedImageResourceGroupName",
|
|
}
|
|
|
|
var c Config
|
|
_, err := c.Prepare(config, getPackerConfiguration())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = approvaltests.VerifyJSONStruct(t, deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Ensure the VM template is correct when building with additional unmanaged disks
|
|
func TestVirtualMachineDeployment11(t *testing.T) {
|
|
config := map[string]interface{}{
|
|
"location": "ignore",
|
|
"subscription_id": "ignore",
|
|
"os_type": constants.Target_Linux,
|
|
"communicator": "none",
|
|
"image_publisher": "--image-publisher--",
|
|
"image_offer": "--image-offer--",
|
|
"image_sku": "--image-sku--",
|
|
"image_version": "--version--",
|
|
|
|
"disk_additional_size": []uint{32},
|
|
|
|
"resource_group_name": "packergroup",
|
|
"storage_account": "packerartifacts",
|
|
"capture_name_prefix": "packer",
|
|
"capture_container_name": "packerimages",
|
|
}
|
|
|
|
var c Config
|
|
_, err := c.Prepare(config, getPackerConfiguration())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = approvaltests.VerifyJSONStruct(t, deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Ensure the VM template is correct when building with additional managed disks
|
|
func TestVirtualMachineDeployment12(t *testing.T) {
|
|
config := map[string]interface{}{
|
|
"location": "ignore",
|
|
"subscription_id": "ignore",
|
|
"os_type": constants.Target_Linux,
|
|
"communicator": "none",
|
|
"image_publisher": "--image-publisher--",
|
|
"image_offer": "--image-offer--",
|
|
"image_sku": "--image-sku--",
|
|
"image_version": "--version--",
|
|
|
|
"disk_additional_size": []uint{32},
|
|
|
|
"managed_image_name": "ManagedImageName",
|
|
"managed_image_resource_group_name": "ManagedImageResourceGroupName",
|
|
}
|
|
|
|
var c Config
|
|
_, err := c.Prepare(config, getPackerConfiguration())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = approvaltests.VerifyJSONStruct(t, deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Ensure the VM template is correct when building with list of allowed IP addresses
|
|
func TestVirtualMachineDeployment13(t *testing.T) {
|
|
config := map[string]interface{}{
|
|
"location": "ignore",
|
|
"subscription_id": "ignore",
|
|
"os_type": constants.Target_Windows,
|
|
"communicator": "winrm",
|
|
"winrm_username": "ignore",
|
|
"image_publisher": "--image-publisher--",
|
|
"image_offer": "--image-offer--",
|
|
"image_sku": "--image-sku--",
|
|
"image_version": "--version--",
|
|
"managed_image_name": "ManagedImageName",
|
|
"managed_image_resource_group_name": "ManagedImageResourceGroupName",
|
|
"allowed_inbound_ip_addresses": []string{"127.0.0.1", "192.168.100.0/24"},
|
|
}
|
|
|
|
var c Config
|
|
_, err := c.Prepare(config, getPackerConfiguration())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
c.tmpKeyVaultName = "--keyvault-name--"
|
|
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = approvaltests.VerifyJSONStruct(t, deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Ensure the link values are not set, and the concrete values are set.
|
|
func TestKeyVaultDeployment00(t *testing.T) {
|
|
var c Config
|
|
c.Prepare(getArmBuilderConfiguration(), getPackerConfiguration())
|
|
deployment, err := GetKeyVaultDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if deployment.Properties.Mode != resources.Incremental {
|
|
t.Errorf("Expected deployment.Properties.Mode to be %s, but got %s", resources.Incremental, deployment.Properties.Mode)
|
|
}
|
|
|
|
if deployment.Properties.ParametersLink != nil {
|
|
t.Error("Expected the ParametersLink to be nil!")
|
|
}
|
|
|
|
if deployment.Properties.TemplateLink != nil {
|
|
t.Error("Expected the TemplateLink to be nil!")
|
|
}
|
|
|
|
if deployment.Properties.Parameters == nil {
|
|
t.Error("Expected the Parameters to not be nil!")
|
|
}
|
|
|
|
if deployment.Properties.Template == nil {
|
|
t.Error("Expected the Template to not be nil!")
|
|
}
|
|
}
|
|
|
|
// Ensure the KeyVault template is a valid JSON document.
|
|
func TestKeyVaultDeployment01(t *testing.T) {
|
|
var c Config
|
|
c.Prepare(getArmBuilderConfiguration(), getPackerConfiguration())
|
|
deployment, err := GetKeyVaultDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
_, err = json.Marshal(deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Ensure the KeyVault template parameters are correct.
|
|
func TestKeyVaultDeployment02(t *testing.T) {
|
|
var c Config
|
|
c.Prepare(getArmBuilderConfigurationWithWindows(), getPackerConfiguration())
|
|
|
|
deployment, err := GetKeyVaultDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
bs, err := json.Marshal(deployment.Properties.Parameters)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
var params template.TemplateParameters
|
|
err = json.Unmarshal(bs, ¶ms)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if params.ObjectId.Value != c.ClientConfig.ObjectID {
|
|
t.Errorf("Expected template parameter 'ObjectId' to be %s, but got %s.", params.ObjectId.Value, c.ClientConfig.ObjectID)
|
|
}
|
|
if params.TenantId.Value != c.ClientConfig.TenantID {
|
|
t.Errorf("Expected template parameter 'TenantId' to be %s, but got %s.", params.TenantId.Value, c.ClientConfig.TenantID)
|
|
}
|
|
if params.KeyVaultName.Value != c.tmpKeyVaultName {
|
|
t.Errorf("Expected template parameter 'KeyVaultName' to be %s, but got %s.", params.KeyVaultName.Value, c.tmpKeyVaultName)
|
|
}
|
|
if params.KeyVaultSecretValue.Value != c.winrmCertificate {
|
|
t.Errorf("Expected template parameter 'KeyVaultSecretValue' to be %s, but got %s.", params.KeyVaultSecretValue.Value, c.winrmCertificate)
|
|
}
|
|
}
|
|
|
|
// Ensure the KeyVault template is correct when tags are supplied.
|
|
func TestKeyVaultDeployment03(t *testing.T) {
|
|
tags := map[string]interface{}{
|
|
"azure_tags": map[string]string{
|
|
"tag01": "value01",
|
|
"tag02": "value02",
|
|
"tag03": "value03",
|
|
},
|
|
}
|
|
|
|
var c Config
|
|
c.Prepare(tags, getArmBuilderConfigurationWithWindows(), getPackerConfiguration())
|
|
deployment, err := GetKeyVaultDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = approvaltests.VerifyJSONStruct(t, deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestPlanInfo01(t *testing.T) {
|
|
planInfo := map[string]interface{}{
|
|
"plan_info": map[string]string{
|
|
"plan_name": "planName00",
|
|
"plan_product": "planProduct00",
|
|
"plan_publisher": "planPublisher00",
|
|
},
|
|
}
|
|
|
|
var c Config
|
|
c.Prepare(planInfo, getArmBuilderConfiguration(), getPackerConfiguration())
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = approvaltests.VerifyJSONStruct(t, deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestPlanInfo02(t *testing.T) {
|
|
planInfo := map[string]interface{}{
|
|
"azure_tags": map[string]string{
|
|
"dept": "engineering",
|
|
},
|
|
"plan_info": map[string]string{
|
|
"plan_name": "planName00",
|
|
"plan_product": "planProduct00",
|
|
"plan_publisher": "planPublisher00",
|
|
"plan_promotion_code": "planPromotionCode00",
|
|
},
|
|
}
|
|
|
|
var c Config
|
|
c.Prepare(planInfo, getArmBuilderConfiguration(), getPackerConfiguration())
|
|
deployment, err := GetVirtualMachineDeployment(&c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = approvaltests.VerifyJSONStruct(t, deployment.Properties.Template)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|