github.com/hashicorp/packer@v1.14.3/provisioner/powershell/provisioner_acc_test.go (about)

     1  // Copyright (c) HashiCorp, Inc.
     2  // SPDX-License-Identifier: BUSL-1.1
     3  
     4  package powershell_test
     5  
     6  import (
     7  	"fmt"
     8  	"io"
     9  	"os"
    10  	"os/exec"
    11  	"path/filepath"
    12  	"regexp"
    13  	"runtime"
    14  	"testing"
    15  
    16  	"github.com/hashicorp/packer-plugin-sdk/acctest/provisioneracc"
    17  )
    18  
    19  const TestProvisionerType = "powershell"
    20  
    21  func powershellIsCompatible(builder string, vmOS string) bool {
    22  	return vmOS == "windows"
    23  }
    24  
    25  func fixtureDir() string {
    26  	_, file, _, _ := runtime.Caller(0)
    27  	return filepath.Join(filepath.Dir(file), "test-fixtures")
    28  }
    29  
    30  func LoadProvisionerFragment(templateFragmentPath string) (string, error) {
    31  	dir := fixtureDir()
    32  	fragmentAbsPath := filepath.Join(dir, templateFragmentPath)
    33  	fragmentFile, err := os.Open(fragmentAbsPath)
    34  	if err != nil {
    35  		return "", fmt.Errorf("Unable find %s", fragmentAbsPath)
    36  	}
    37  	defer fragmentFile.Close()
    38  
    39  	fragmentString, err := io.ReadAll(fragmentFile)
    40  	if err != nil {
    41  		return "", fmt.Errorf("Unable to read %s", fragmentAbsPath)
    42  	}
    43  
    44  	return string(fragmentString), nil
    45  }
    46  
    47  func TestAccPowershellProvisioner_basic(t *testing.T) {
    48  	templateString, err := LoadProvisionerFragment("powershell-provisioner-cleanup.txt")
    49  	if err != nil {
    50  		t.Fatalf("Couldn't load test fixture; %s", err.Error())
    51  	}
    52  	testCase := &provisioneracc.ProvisionerTestCase{
    53  		IsCompatible: powershellIsCompatible,
    54  		Name:         "powershell-provisioner-cleanup",
    55  		Template:     templateString,
    56  		Type:         TestProvisionerType,
    57  		Check: func(buildcommand *exec.Cmd, logfile string) error {
    58  			if buildcommand.ProcessState != nil {
    59  				if buildcommand.ProcessState.ExitCode() != 0 {
    60  					return fmt.Errorf("Bad exit code. Logfile: %s", logfile)
    61  				}
    62  			}
    63  			return nil
    64  		},
    65  	}
    66  
    67  	provisioneracc.TestProvisionersAgainstBuilders(testCase, t)
    68  }
    69  
    70  func TestAccPowershellProvisioner_Inline(t *testing.T) {
    71  	templateString, err := LoadProvisionerFragment("powershell-inline-provisioner.txt")
    72  	if err != nil {
    73  		t.Fatalf("Couldn't load test fixture; %s", err.Error())
    74  	}
    75  	testCase := &provisioneracc.ProvisionerTestCase{
    76  		IsCompatible: powershellIsCompatible,
    77  		Name:         "powershell-provisioner-inline",
    78  		Template:     templateString,
    79  		Type:         TestProvisionerType,
    80  		Check: func(buildcommand *exec.Cmd, logfile string) error {
    81  			if buildcommand.ProcessState != nil {
    82  				if buildcommand.ProcessState.ExitCode() != 0 {
    83  					return fmt.Errorf("Bad exit code. Logfile: %s", logfile)
    84  				}
    85  			}
    86  			out, err := os.ReadFile(logfile)
    87  			if err != nil {
    88  				return err
    89  			}
    90  			output := string(out)
    91  			regexMatchString := "test_env_var: TestValue"
    92  			if !regexp.MustCompile(regexp.QuoteMeta(regexMatchString)).MatchString(output) {
    93  				t.Errorf("expected env string %q in logs:\n%s", regexMatchString, output)
    94  			}
    95  
    96  			return nil
    97  		},
    98  	}
    99  
   100  	provisioneracc.TestProvisionersAgainstBuilders(testCase, t)
   101  }
   102  
   103  func TestAccPowershellProvisioner_Script(t *testing.T) {
   104  	templateString, err := LoadProvisionerFragment("powershell-script-provisioner.txt")
   105  	if err != nil {
   106  		t.Fatalf("Couldn't load test fixture; %s", err.Error())
   107  	}
   108  	testCase := &provisioneracc.ProvisionerTestCase{
   109  		IsCompatible: powershellIsCompatible,
   110  		Name:         "powershell-provisioner-script",
   111  		Template:     templateString,
   112  		Type:         TestProvisionerType,
   113  		Check: func(buildcommand *exec.Cmd, logfile string) error {
   114  			if buildcommand.ProcessState != nil {
   115  				if buildcommand.ProcessState.ExitCode() != 0 {
   116  					return fmt.Errorf("Bad exit code. Logfile: %s", logfile)
   117  				}
   118  			}
   119  
   120  			out, err := os.ReadFile(logfile)
   121  			if err != nil {
   122  				return err
   123  			}
   124  			output := string(out)
   125  			regexMatchString := "likewise, var2 is A`Backtick"
   126  			if !regexp.MustCompile(regexp.QuoteMeta(regexMatchString)).MatchString(output) {
   127  				t.Errorf("expected env string %q in logs:\n%s", regexMatchString, output)
   128  			}
   129  			return nil
   130  		},
   131  	}
   132  
   133  	provisioneracc.TestProvisionersAgainstBuilders(testCase, t)
   134  }
   135  
   136  func TestAccPowershellProvisioner_ExitCodes(t *testing.T) {
   137  	templateString, err := LoadProvisionerFragment("powershell-exit_codes-provisioner.txt")
   138  	if err != nil {
   139  		t.Fatalf("Couldn't load test fixture; %s", err.Error())
   140  	}
   141  	testCase := &provisioneracc.ProvisionerTestCase{
   142  		IsCompatible: powershellIsCompatible,
   143  		Name:         "powershell-provisioner-script",
   144  		Template:     templateString,
   145  		Type:         TestProvisionerType,
   146  		Check: func(buildcommand *exec.Cmd, logfile string) error {
   147  			if buildcommand.ProcessState != nil {
   148  				if buildcommand.ProcessState.ExitCode() != 0 {
   149  					return fmt.Errorf("Bad exit code. Logfile: %s", logfile)
   150  				}
   151  			}
   152  			return nil
   153  		},
   154  	}
   155  	provisioneracc.TestProvisionersAgainstBuilders(testCase, t)
   156  
   157  }