github.com/daniellockard/packer@v0.7.6-0.20141210173435-5a9390934716/post-processor/vagrant/post-processor_test.go (about)

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