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 }