github.com/aclaygray/packer@v1.3.2/post-processor/vagrant/post-processor_test.go (about)

     1  package vagrant
     2  
     3  import (
     4  	"bytes"
     5  	"compress/flate"
     6  	"io/ioutil"
     7  	"os"
     8  	"strings"
     9  	"testing"
    10  
    11  	"github.com/hashicorp/packer/packer"
    12  )
    13  
    14  func testConfig() map[string]interface{} {
    15  	return map[string]interface{}{}
    16  }
    17  
    18  func testPP(t *testing.T) *PostProcessor {
    19  	var p PostProcessor
    20  	if err := p.Configure(testConfig()); err != nil {
    21  		t.Fatalf("err: %s", err)
    22  	}
    23  
    24  	return &p
    25  }
    26  
    27  func testUi() *packer.BasicUi {
    28  	return &packer.BasicUi{
    29  		Reader: new(bytes.Buffer),
    30  		Writer: new(bytes.Buffer),
    31  	}
    32  }
    33  
    34  func TestPostProcessor_ImplementsPostProcessor(t *testing.T) {
    35  	var _ packer.PostProcessor = new(PostProcessor)
    36  }
    37  
    38  func TestPostProcessorPrepare_compressionLevel(t *testing.T) {
    39  	var p PostProcessor
    40  
    41  	// Default
    42  	c := testConfig()
    43  	delete(c, "compression_level")
    44  	if err := p.Configure(c); err != nil {
    45  		t.Fatalf("err: %s", err)
    46  	}
    47  
    48  	config := p.configs[""]
    49  	if config.CompressionLevel != flate.DefaultCompression {
    50  		t.Fatalf("bad: %#v", config.CompressionLevel)
    51  	}
    52  
    53  	// Set
    54  	c = testConfig()
    55  	c["compression_level"] = 7
    56  	if err := p.Configure(c); err != nil {
    57  		t.Fatalf("err: %s", err)
    58  	}
    59  
    60  	config = p.configs[""]
    61  	if config.CompressionLevel != 7 {
    62  		t.Fatalf("bad: %#v", config.CompressionLevel)
    63  	}
    64  }
    65  
    66  func TestPostProcessorPrepare_outputPath(t *testing.T) {
    67  	var p PostProcessor
    68  
    69  	// Default
    70  	c := testConfig()
    71  	delete(c, "output")
    72  	err := p.Configure(c)
    73  	if err != nil {
    74  		t.Fatalf("err: %s", err)
    75  	}
    76  
    77  	// Bad template
    78  	c["output"] = "bad {{{{.Template}}}}"
    79  	err = p.Configure(c)
    80  	if err == nil {
    81  		t.Fatal("should have error")
    82  	}
    83  }
    84  
    85  func TestPostProcessorPrepare_subConfigs(t *testing.T) {
    86  	var p PostProcessor
    87  
    88  	f, err := ioutil.TempFile("", "packer")
    89  	if err != nil {
    90  		t.Fatalf("err: %s", err)
    91  	}
    92  	defer os.Remove(f.Name())
    93  
    94  	// Default
    95  	c := testConfig()
    96  	c["compression_level"] = 42
    97  	c["vagrantfile_template"] = f.Name()
    98  	c["override"] = map[string]interface{}{
    99  		"aws": map[string]interface{}{
   100  			"compression_level": 7,
   101  		},
   102  	}
   103  	err = p.Configure(c)
   104  	if err != nil {
   105  		t.Fatalf("err: %s", err)
   106  	}
   107  
   108  	if p.configs[""].CompressionLevel != 42 {
   109  		t.Fatalf("bad: %#v", p.configs[""].CompressionLevel)
   110  	}
   111  
   112  	if p.configs[""].VagrantfileTemplate != f.Name() {
   113  		t.Fatalf("bad: %#v", p.configs[""].VagrantfileTemplate)
   114  	}
   115  
   116  	if p.configs["aws"].CompressionLevel != 7 {
   117  		t.Fatalf("bad: %#v", p.configs["aws"].CompressionLevel)
   118  	}
   119  
   120  	if p.configs["aws"].VagrantfileTemplate != f.Name() {
   121  		t.Fatalf("bad: %#v", p.configs["aws"].VagrantfileTemplate)
   122  	}
   123  }
   124  
   125  func TestPostProcessorPrepare_vagrantfileTemplateExists(t *testing.T) {
   126  	f, err := ioutil.TempFile("", "packer")
   127  	if err != nil {
   128  		t.Fatalf("err: %s", err)
   129  	}
   130  
   131  	name := f.Name()
   132  	c := testConfig()
   133  	c["vagrantfile_template"] = name
   134  
   135  	if err := f.Close(); err != nil {
   136  		t.Fatalf("err: %s", err)
   137  	}
   138  
   139  	if err := os.Remove(name); err != nil {
   140  		t.Fatalf("err: %s", err)
   141  	}
   142  
   143  	var p PostProcessor
   144  	if err := p.Configure(c); err == nil {
   145  		t.Fatal("expected an error since vagrantfile_template does not exist")
   146  	}
   147  }
   148  
   149  func TestPostProcessorPostProcess_badId(t *testing.T) {
   150  	artifact := &packer.MockArtifact{
   151  		BuilderIdValue: "invalid.packer",
   152  	}
   153  
   154  	_, _, err := testPP(t).PostProcess(testUi(), artifact)
   155  	if !strings.Contains(err.Error(), "artifact type") {
   156  		t.Fatalf("err: %s", err)
   157  	}
   158  }
   159  
   160  func TestPostProcessorPostProcess_vagrantfileUserVariable(t *testing.T) {
   161  	var p PostProcessor
   162  
   163  	f, err := ioutil.TempFile("", "packer")
   164  	if err != nil {
   165  		t.Fatalf("err: %s", err)
   166  	}
   167  	defer os.Remove(f.Name())
   168  
   169  	c := map[string]interface{}{
   170  		"packer_user_variables": map[string]string{
   171  			"foo": f.Name(),
   172  		},
   173  
   174  		"vagrantfile_template": "{{user `foo`}}",
   175  	}
   176  	err = p.Configure(c)
   177  	if err != nil {
   178  		t.Fatalf("err: %s", err)
   179  	}
   180  
   181  	a := &packer.MockArtifact{
   182  		BuilderIdValue: "packer.parallels",
   183  	}
   184  	a2, _, err := p.PostProcess(testUi(), a)
   185  	if a2 != nil {
   186  		for _, fn := range a2.Files() {
   187  			defer os.Remove(fn)
   188  		}
   189  	}
   190  	if err != nil {
   191  		t.Fatalf("err: %s", err)
   192  	}
   193  }
   194  
   195  func TestProviderForName(t *testing.T) {
   196  	if v, ok := providerForName("virtualbox").(*VBoxProvider); !ok {
   197  		t.Fatalf("bad: %#v", v)
   198  	}
   199  
   200  	if providerForName("nope") != nil {
   201  		t.Fatal("should be nil if bad provider")
   202  	}
   203  }