github.com/rsyabuta/packer@v1.1.4-0.20180119234903-5ef0c2280f0b/provisioner/salt-masterless/provisioner_test.go (about) 1 package saltmasterless 2 3 import ( 4 "github.com/hashicorp/packer/packer" 5 "io/ioutil" 6 "os" 7 "strings" 8 "testing" 9 ) 10 11 func testConfig() map[string]interface{} { 12 return map[string]interface{}{ 13 "local_state_tree": os.TempDir(), 14 } 15 } 16 17 func TestProvisioner_Impl(t *testing.T) { 18 var raw interface{} 19 raw = &Provisioner{} 20 if _, ok := raw.(packer.Provisioner); !ok { 21 t.Fatalf("must be a Provisioner") 22 } 23 } 24 25 func TestProvisionerPrepare_Defaults(t *testing.T) { 26 var p Provisioner 27 config := testConfig() 28 29 err := p.Prepare(config) 30 if err != nil { 31 t.Fatalf("err: %s", err) 32 } 33 34 if p.config.TempConfigDir != DefaultTempConfigDir { 35 t.Errorf("unexpected temp config dir: %s", p.config.TempConfigDir) 36 } 37 } 38 39 func TestProvisionerPrepare_InvalidKey(t *testing.T) { 40 var p Provisioner 41 config := testConfig() 42 43 // Add a random key 44 config["i_should_not_be_valid"] = true 45 err := p.Prepare(config) 46 if err == nil { 47 t.Fatal("should have error") 48 } 49 } 50 51 func TestProvisionerPrepare_CustomeState(t *testing.T) { 52 var p Provisioner 53 config := testConfig() 54 55 err := p.Prepare(config) 56 if err != nil { 57 t.Fatalf("err: %s", err) 58 } 59 60 if !strings.Contains(p.config.CmdArgs, "state.") { 61 t.Fatal("a state should be specified in CmdArgs") 62 } 63 64 config["custom_state"] = "birb" 65 err = p.Prepare(config) 66 if err != nil { 67 t.Fatalf("err: %s", err) 68 } 69 70 if !strings.Contains(p.config.CmdArgs, "state.sls birb") { 71 t.Fatal("birb state should be specified in CmdArgs") 72 } 73 } 74 75 func TestProvisionerPrepare_MinionConfig(t *testing.T) { 76 var p Provisioner 77 config := testConfig() 78 79 config["minion_config"] = "/i/dont/exist/i/think" 80 err := p.Prepare(config) 81 if err == nil { 82 t.Fatal("should have error") 83 } 84 85 tf, err := ioutil.TempFile("", "minion") 86 if err != nil { 87 t.Fatalf("error tempfile: %s", err) 88 } 89 defer os.Remove(tf.Name()) 90 91 config["minion_config"] = tf.Name() 92 err = p.Prepare(config) 93 if err != nil { 94 t.Fatalf("err: %s", err) 95 } 96 } 97 98 func TestProvisionerPrepare_MinionConfig_RemoteStateTree(t *testing.T) { 99 var p Provisioner 100 config := testConfig() 101 102 config["minion_config"] = "/i/dont/exist/i/think" 103 config["remote_state_tree"] = "/i/dont/exist/remote_state_tree" 104 err := p.Prepare(config) 105 if err == nil { 106 t.Fatal("minion_config and remote_state_tree should cause error") 107 } 108 } 109 110 func TestProvisionerPrepare_MinionConfig_RemotePillarRoots(t *testing.T) { 111 var p Provisioner 112 config := testConfig() 113 114 config["minion_config"] = "/i/dont/exist/i/think" 115 config["remote_pillar_roots"] = "/i/dont/exist/remote_pillar_roots" 116 err := p.Prepare(config) 117 if err == nil { 118 t.Fatal("minion_config and remote_pillar_roots should cause error") 119 } 120 } 121 122 func TestProvisionerPrepare_GrainsFile(t *testing.T) { 123 var p Provisioner 124 config := testConfig() 125 126 config["grains_file"] = "/i/dont/exist/i/think" 127 err := p.Prepare(config) 128 if err == nil { 129 t.Fatal("should have error") 130 } 131 132 tf, err := ioutil.TempFile("", "grains") 133 if err != nil { 134 t.Fatalf("error tempfile: %s", err) 135 } 136 defer os.Remove(tf.Name()) 137 138 config["grains_file"] = tf.Name() 139 err = p.Prepare(config) 140 if err != nil { 141 t.Fatalf("err: %s", err) 142 } 143 } 144 145 func TestProvisionerPrepare_LocalStateTree(t *testing.T) { 146 var p Provisioner 147 config := testConfig() 148 149 config["local_state_tree"] = "/i/dont/exist/i/think" 150 err := p.Prepare(config) 151 if err == nil { 152 t.Fatal("should have error") 153 } 154 155 config["local_state_tree"] = os.TempDir() 156 err = p.Prepare(config) 157 if err != nil { 158 t.Fatalf("err: %s", err) 159 } 160 } 161 162 func TestProvisionerPrepare_LocalPillarRoots(t *testing.T) { 163 var p Provisioner 164 config := testConfig() 165 166 config["local_pillar_roots"] = "/i/dont/exist/i/think" 167 err := p.Prepare(config) 168 if err == nil { 169 t.Fatal("should have error") 170 } 171 172 config["local_pillar_roots"] = os.TempDir() 173 err = p.Prepare(config) 174 if err != nil { 175 t.Fatalf("err: %s", err) 176 } 177 } 178 179 func TestProvisionerSudo(t *testing.T) { 180 var p Provisioner 181 config := testConfig() 182 183 err := p.Prepare(config) 184 if err != nil { 185 t.Fatalf("err: %s", err) 186 } 187 188 withSudo := p.sudo("echo hello") 189 if withSudo != "sudo echo hello" { 190 t.Fatalf("sudo command not generated correctly") 191 } 192 193 config["disable_sudo"] = true 194 err = p.Prepare(config) 195 if err != nil { 196 t.Fatalf("err: %s", err) 197 } 198 withoutSudo := p.sudo("echo hello") 199 if withoutSudo != "echo hello" { 200 t.Fatalf("sudo-less command not generated correctly") 201 } 202 } 203 204 func TestProvisionerPrepare_RemoteStateTree(t *testing.T) { 205 var p Provisioner 206 config := testConfig() 207 208 config["remote_state_tree"] = "/remote_state_tree" 209 err := p.Prepare(config) 210 if err != nil { 211 t.Fatalf("err: %s", err) 212 } 213 214 if !strings.Contains(p.config.CmdArgs, "--file-root=/remote_state_tree") { 215 t.Fatal("--file-root should be set in CmdArgs") 216 } 217 } 218 219 func TestProvisionerPrepare_RemotePillarRoots(t *testing.T) { 220 var p Provisioner 221 config := testConfig() 222 223 config["remote_pillar_roots"] = "/remote_pillar_roots" 224 err := p.Prepare(config) 225 if err != nil { 226 t.Fatalf("err: %s", err) 227 } 228 229 if !strings.Contains(p.config.CmdArgs, "--pillar-root=/remote_pillar_roots") { 230 t.Fatal("--pillar-root should be set in CmdArgs") 231 } 232 } 233 234 func TestProvisionerPrepare_RemoteStateTree_Default(t *testing.T) { 235 var p Provisioner 236 config := testConfig() 237 238 // no minion_config, no remote_state_tree 239 err := p.Prepare(config) 240 if err != nil { 241 t.Fatalf("err: %s", err) 242 } 243 244 if !strings.Contains(p.config.CmdArgs, "--file-root=/srv/salt") { 245 t.Fatal("--file-root should be set in CmdArgs") 246 } 247 } 248 249 func TestProvisionerPrepare_RemotePillarRoots_Default(t *testing.T) { 250 var p Provisioner 251 config := testConfig() 252 253 // no minion_config, no remote_pillar_roots 254 err := p.Prepare(config) 255 if err != nil { 256 t.Fatalf("err: %s", err) 257 } 258 259 if !strings.Contains(p.config.CmdArgs, "--pillar-root=/srv/pillar") { 260 t.Fatal("--pillar-root should be set in CmdArgs") 261 } 262 } 263 264 func TestProvisionerPrepare_NoExitOnFailure(t *testing.T) { 265 var p Provisioner 266 config := testConfig() 267 268 err := p.Prepare(config) 269 if err != nil { 270 t.Fatalf("err: %s", err) 271 } 272 273 if !strings.Contains(p.config.CmdArgs, "--retcode-passthrough") { 274 t.Fatal("--retcode-passthrough should be set in CmdArgs") 275 } 276 277 config["no_exit_on_failure"] = true 278 err = p.Prepare(config) 279 if err != nil { 280 t.Fatalf("err: %s", err) 281 } 282 283 if strings.Contains(p.config.CmdArgs, "--retcode-passthrough") { 284 t.Fatal("--retcode-passthrough should not be set in CmdArgs") 285 } 286 } 287 288 func TestProvisionerPrepare_LogLevel(t *testing.T) { 289 var p Provisioner 290 config := testConfig() 291 292 err := p.Prepare(config) 293 if err != nil { 294 t.Fatalf("err: %s", err) 295 } 296 297 if !strings.Contains(p.config.CmdArgs, "-l info") { 298 t.Fatal("-l info should be set in CmdArgs") 299 } 300 301 config["log_level"] = "debug" 302 err = p.Prepare(config) 303 if err != nil { 304 t.Fatalf("err: %s", err) 305 } 306 307 if !strings.Contains(p.config.CmdArgs, "-l debug") { 308 t.Fatal("-l debug should be set in CmdArgs") 309 } 310 }