github.com/amanya/packer@v0.12.1-0.20161117214323-902ac5ab2eb6/provisioner/puppet-masterless/provisioner_test.go (about) 1 package puppetmasterless 2 3 import ( 4 "io/ioutil" 5 "os" 6 "strings" 7 "testing" 8 9 "github.com/mitchellh/packer/packer" 10 ) 11 12 func testConfig() map[string]interface{} { 13 tf, err := ioutil.TempFile("", "packer") 14 if err != nil { 15 panic(err) 16 } 17 18 return map[string]interface{}{ 19 "manifest_file": tf.Name(), 20 } 21 } 22 23 func TestProvisioner_Impl(t *testing.T) { 24 var raw interface{} 25 raw = &Provisioner{} 26 if _, ok := raw.(packer.Provisioner); !ok { 27 t.Fatalf("must be a Provisioner") 28 } 29 } 30 31 func TestProvisionerPrepare_puppetBinDir(t *testing.T) { 32 config := testConfig() 33 34 delete(config, "puppet_bin_dir") 35 p := new(Provisioner) 36 err := p.Prepare(config) 37 if err != nil { 38 t.Fatalf("err: %s", err) 39 } 40 41 // Test with a good one 42 tf, err := ioutil.TempFile("", "packer") 43 if err != nil { 44 t.Fatalf("error tempfile: %s", err) 45 } 46 defer os.Remove(tf.Name()) 47 48 config["puppet_bin_dir"] = tf.Name() 49 p = new(Provisioner) 50 err = p.Prepare(config) 51 if err != nil { 52 t.Fatalf("err: %s", err) 53 } 54 } 55 56 func TestProvisionerPrepare_hieraConfigPath(t *testing.T) { 57 config := testConfig() 58 59 delete(config, "hiera_config_path") 60 p := new(Provisioner) 61 err := p.Prepare(config) 62 if err != nil { 63 t.Fatalf("err: %s", err) 64 } 65 66 // Test with a good one 67 tf, err := ioutil.TempFile("", "packer") 68 if err != nil { 69 t.Fatalf("error tempfile: %s", err) 70 } 71 defer os.Remove(tf.Name()) 72 73 config["hiera_config_path"] = tf.Name() 74 p = new(Provisioner) 75 err = p.Prepare(config) 76 if err != nil { 77 t.Fatalf("err: %s", err) 78 } 79 } 80 81 func TestProvisionerPrepare_manifestFile(t *testing.T) { 82 config := testConfig() 83 84 delete(config, "manifest_file") 85 p := new(Provisioner) 86 err := p.Prepare(config) 87 if err == nil { 88 t.Fatal("should be an error") 89 } 90 91 // Test with a good one 92 tf, err := ioutil.TempFile("", "packer") 93 if err != nil { 94 t.Fatalf("error tempfile: %s", err) 95 } 96 defer os.Remove(tf.Name()) 97 98 config["manifest_file"] = tf.Name() 99 p = new(Provisioner) 100 err = p.Prepare(config) 101 if err != nil { 102 t.Fatalf("err: %s", err) 103 } 104 } 105 106 func TestProvisionerPrepare_manifestDir(t *testing.T) { 107 config := testConfig() 108 109 delete(config, "manifestdir") 110 p := new(Provisioner) 111 err := p.Prepare(config) 112 if err != nil { 113 t.Fatalf("err: %s", err) 114 } 115 116 // Test with a good one 117 td, err := ioutil.TempDir("", "packer") 118 if err != nil { 119 t.Fatalf("error: %s", err) 120 } 121 defer os.RemoveAll(td) 122 123 config["manifest_dir"] = td 124 p = new(Provisioner) 125 err = p.Prepare(config) 126 if err != nil { 127 t.Fatalf("err: %s", err) 128 } 129 } 130 131 func TestProvisionerPrepare_modulePaths(t *testing.T) { 132 config := testConfig() 133 134 delete(config, "module_paths") 135 p := new(Provisioner) 136 err := p.Prepare(config) 137 if err != nil { 138 t.Fatalf("err: %s", err) 139 } 140 141 // Test with bad paths 142 config["module_paths"] = []string{"i-should-not-exist"} 143 p = new(Provisioner) 144 err = p.Prepare(config) 145 if err == nil { 146 t.Fatal("should be an error") 147 } 148 149 // Test with a good one 150 td, err := ioutil.TempDir("", "packer") 151 if err != nil { 152 t.Fatalf("error: %s", err) 153 } 154 defer os.RemoveAll(td) 155 156 config["module_paths"] = []string{td} 157 p = new(Provisioner) 158 err = p.Prepare(config) 159 if err != nil { 160 t.Fatalf("err: %s", err) 161 } 162 } 163 164 func TestProvisionerPrepare_facterFacts(t *testing.T) { 165 config := testConfig() 166 167 delete(config, "facter") 168 p := new(Provisioner) 169 err := p.Prepare(config) 170 if err != nil { 171 t.Fatalf("err: %s", err) 172 } 173 174 // Test with malformed fact 175 config["facter"] = "fact=stringified" 176 p = new(Provisioner) 177 err = p.Prepare(config) 178 if err == nil { 179 t.Fatal("should be an error") 180 } 181 182 // Test with a good one 183 td, err := ioutil.TempDir("", "packer") 184 if err != nil { 185 t.Fatalf("error: %s", err) 186 } 187 defer os.RemoveAll(td) 188 189 facts := make(map[string]string) 190 facts["fact_name"] = "fact_value" 191 config["facter"] = facts 192 193 p = new(Provisioner) 194 err = p.Prepare(config) 195 if err != nil { 196 t.Fatalf("err: %s", err) 197 } 198 199 // Make sure the default facts are present 200 delete(config, "facter") 201 p = new(Provisioner) 202 err = p.Prepare(config) 203 if p.config.Facter == nil { 204 t.Fatalf("err: Default facts are not set in the Puppet provisioner!") 205 } 206 } 207 208 func TestProvisionerPrepare_extraArguments(t *testing.T) { 209 config := testConfig() 210 211 // Test with missing parameter 212 delete(config, "extra_arguments") 213 p := new(Provisioner) 214 err := p.Prepare(config) 215 if err != nil { 216 t.Fatalf("err: %s", err) 217 } 218 219 // Test with malformed value 220 config["extra_arguments"] = "{{}}" 221 p = new(Provisioner) 222 err = p.Prepare(config) 223 if err == nil { 224 t.Fatal("should be an error") 225 } 226 227 // Test with valid values 228 config["extra_arguments"] = []string{ 229 "arg", 230 } 231 232 p = new(Provisioner) 233 err = p.Prepare(config) 234 if err != nil { 235 t.Fatalf("err: %s", err) 236 } 237 } 238 239 func TestProvisionerProvision_extraArguments(t *testing.T) { 240 config := testConfig() 241 ui := &packer.MachineReadableUi{ 242 Writer: ioutil.Discard, 243 } 244 comm := new(packer.MockCommunicator) 245 246 extraArguments := []string{ 247 "--some-arg=yup", 248 "--some-other-arg", 249 } 250 config["extra_arguments"] = extraArguments 251 252 // Test with valid values 253 p := new(Provisioner) 254 err := p.Prepare(config) 255 if err != nil { 256 t.Fatalf("err: %s", err) 257 } 258 259 err = p.Provision(ui, comm) 260 if err != nil { 261 t.Fatalf("err: %s", err) 262 } 263 264 expectedArgs := strings.Join(extraArguments, " ") 265 266 if !strings.Contains(comm.StartCmd.Command, expectedArgs) { 267 t.Fatalf("Command %q doesn't contain the expected arguments %q", comm.StartCmd.Command, expectedArgs) 268 } 269 270 // Test with missing parameter 271 delete(config, "extra_arguments") 272 273 p = new(Provisioner) 274 err = p.Prepare(config) 275 if err != nil { 276 t.Fatalf("err: %s", err) 277 } 278 279 err = p.Provision(ui, comm) 280 if err != nil { 281 t.Fatalf("err: %s", err) 282 } 283 284 // Check the expected `extra_arguments` position for an empty value 285 splitCommand := strings.Split(comm.StartCmd.Command, " ") 286 if "" == splitCommand[len(splitCommand)-2] { 287 t.Fatalf("Command %q contains an extra-space which may cause arg parsing issues", comm.StartCmd.Command) 288 } 289 }