github.com/rahart/packer@v0.12.2-0.20161229105310-282bb6ad370f/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  	f, err := ioutil.TempFile("", "packer")
   126  	if err != nil {
   127  		t.Fatalf("err: %s", err)
   128  	}
   129  
   130  	name := f.Name()
   131  	c := testConfig()
   132  	c["vagrantfile_template"] = name
   133  
   134  	if err := f.Close(); err != nil {
   135  		t.Fatalf("err: %s", err)
   136  	}
   137  
   138  	if err := os.Remove(name); err != nil {
   139  		t.Fatalf("err: %s", err)
   140  	}
   141  
   142  	var p PostProcessor
   143  	if err := p.Configure(c); err == nil {
   144  		t.Fatal("expected an error since vagrantfile_template does not exist")
   145  	}
   146  }
   147  
   148  func TestPostProcessorPostProcess_badId(t *testing.T) {
   149  	artifact := &packer.MockArtifact{
   150  		BuilderIdValue: "invalid.packer",
   151  	}
   152  
   153  	_, _, err := testPP(t).PostProcess(testUi(), artifact)
   154  	if !strings.Contains(err.Error(), "artifact type") {
   155  		t.Fatalf("err: %s", err)
   156  	}
   157  }
   158  
   159  func TestPostProcessorPostProcess_vagrantfileUserVariable(t *testing.T) {
   160  	var p PostProcessor
   161  
   162  	f, err := ioutil.TempFile("", "packer")
   163  	if err != nil {
   164  		t.Fatalf("err: %s", err)
   165  	}
   166  	defer os.Remove(f.Name())
   167  
   168  	c := map[string]interface{}{
   169  		"packer_user_variables": map[string]string{
   170  			"foo": f.Name(),
   171  		},
   172  
   173  		"vagrantfile_template": "{{user `foo`}}",
   174  	}
   175  	err = p.Configure(c)
   176  	if err != nil {
   177  		t.Fatalf("err: %s", err)
   178  	}
   179  
   180  	a := &packer.MockArtifact{
   181  		BuilderIdValue: "packer.parallels",
   182  	}
   183  	a2, _, err := p.PostProcess(testUi(), a)
   184  	if a2 != nil {
   185  		for _, fn := range a2.Files() {
   186  			defer os.Remove(fn)
   187  		}
   188  	}
   189  	if err != nil {
   190  		t.Fatalf("err: %s", err)
   191  	}
   192  }
   193  
   194  func TestProviderForName(t *testing.T) {
   195  	if v, ok := providerForName("virtualbox").(*VBoxProvider); !ok {
   196  		t.Fatalf("bad: %#v", v)
   197  	}
   198  
   199  	if providerForName("nope") != nil {
   200  		t.Fatal("should be nil if bad provider")
   201  	}
   202  }