github.com/nathanielks/terraform@v0.6.1-0.20170509030759-13e1a62319dc/builtin/provisioners/remote-exec/resource_provisioner_test.go (about) 1 package remoteexec 2 3 import ( 4 "bytes" 5 "context" 6 "errors" 7 "io" 8 "net" 9 "testing" 10 "time" 11 12 "strings" 13 14 "github.com/hashicorp/terraform/config" 15 "github.com/hashicorp/terraform/helper/schema" 16 "github.com/hashicorp/terraform/terraform" 17 ) 18 19 func TestResourceProvider_Validate_good(t *testing.T) { 20 c := testConfig(t, map[string]interface{}{ 21 "inline": "echo foo", 22 }) 23 p := Provisioner() 24 warn, errs := p.Validate(c) 25 if len(warn) > 0 { 26 t.Fatalf("Warnings: %v", warn) 27 } 28 if len(errs) > 0 { 29 t.Fatalf("Errors: %v", errs) 30 } 31 } 32 33 func TestResourceProvider_Validate_bad(t *testing.T) { 34 c := testConfig(t, map[string]interface{}{ 35 "invalid": "nope", 36 }) 37 p := Provisioner() 38 warn, errs := p.Validate(c) 39 if len(warn) > 0 { 40 t.Fatalf("Warnings: %v", warn) 41 } 42 if len(errs) == 0 { 43 t.Fatalf("Should have errors") 44 } 45 } 46 47 var expectedScriptOut = `cd /tmp 48 wget http://foobar 49 exit 0 50 ` 51 52 func TestResourceProvider_generateScript(t *testing.T) { 53 p := Provisioner().(*schema.Provisioner) 54 conf := map[string]interface{}{ 55 "inline": []interface{}{ 56 "cd /tmp", 57 "wget http://foobar", 58 "exit 0", 59 }, 60 } 61 out, err := generateScripts(schema.TestResourceDataRaw( 62 t, p.Schema, conf)) 63 if err != nil { 64 t.Fatalf("err: %v", err) 65 } 66 67 if len(out) != 1 { 68 t.Fatal("expected 1 out") 69 } 70 71 if out[0] != expectedScriptOut { 72 t.Fatalf("bad: %v", out) 73 } 74 } 75 76 func TestResourceProvider_generateScriptEmptyInline(t *testing.T) { 77 p := Provisioner().(*schema.Provisioner) 78 conf := map[string]interface{}{ 79 "inline": []interface{}{""}, 80 } 81 82 _, err := generateScripts(schema.TestResourceDataRaw( 83 t, p.Schema, conf)) 84 if err == nil { 85 t.Fatal("expected error, got none") 86 } 87 88 if !strings.Contains(err.Error(), "Error parsing") { 89 t.Fatalf("expected parsing error, got: %s", err) 90 } 91 } 92 93 func TestResourceProvider_CollectScripts_inline(t *testing.T) { 94 p := Provisioner().(*schema.Provisioner) 95 conf := map[string]interface{}{ 96 "inline": []interface{}{ 97 "cd /tmp", 98 "wget http://foobar", 99 "exit 0", 100 }, 101 } 102 103 scripts, err := collectScripts(schema.TestResourceDataRaw( 104 t, p.Schema, conf)) 105 if err != nil { 106 t.Fatalf("err: %v", err) 107 } 108 109 if len(scripts) != 1 { 110 t.Fatalf("bad: %v", scripts) 111 } 112 113 var out bytes.Buffer 114 _, err = io.Copy(&out, scripts[0]) 115 if err != nil { 116 t.Fatalf("err: %v", err) 117 } 118 119 if out.String() != expectedScriptOut { 120 t.Fatalf("bad: %v", out.String()) 121 } 122 } 123 124 func TestResourceProvider_CollectScripts_script(t *testing.T) { 125 p := Provisioner().(*schema.Provisioner) 126 conf := map[string]interface{}{ 127 "script": "test-fixtures/script1.sh", 128 } 129 130 scripts, err := collectScripts(schema.TestResourceDataRaw( 131 t, p.Schema, conf)) 132 if err != nil { 133 t.Fatalf("err: %v", err) 134 } 135 136 if len(scripts) != 1 { 137 t.Fatalf("bad: %v", scripts) 138 } 139 140 var out bytes.Buffer 141 _, err = io.Copy(&out, scripts[0]) 142 if err != nil { 143 t.Fatalf("err: %v", err) 144 } 145 146 if out.String() != expectedScriptOut { 147 t.Fatalf("bad: %v", out.String()) 148 } 149 } 150 151 func TestResourceProvider_CollectScripts_scripts(t *testing.T) { 152 p := Provisioner().(*schema.Provisioner) 153 conf := map[string]interface{}{ 154 "scripts": []interface{}{ 155 "test-fixtures/script1.sh", 156 "test-fixtures/script1.sh", 157 "test-fixtures/script1.sh", 158 }, 159 } 160 161 scripts, err := collectScripts(schema.TestResourceDataRaw( 162 t, p.Schema, conf)) 163 if err != nil { 164 t.Fatalf("err: %v", err) 165 } 166 167 if len(scripts) != 3 { 168 t.Fatalf("bad: %v", scripts) 169 } 170 171 for idx := range scripts { 172 var out bytes.Buffer 173 _, err = io.Copy(&out, scripts[idx]) 174 if err != nil { 175 t.Fatalf("err: %v", err) 176 } 177 178 if out.String() != expectedScriptOut { 179 t.Fatalf("bad: %v", out.String()) 180 } 181 } 182 } 183 184 func TestResourceProvider_CollectScripts_scriptsEmpty(t *testing.T) { 185 p := Provisioner().(*schema.Provisioner) 186 conf := map[string]interface{}{ 187 "scripts": []interface{}{""}, 188 } 189 190 _, err := collectScripts(schema.TestResourceDataRaw( 191 t, p.Schema, conf)) 192 193 if err == nil { 194 t.Fatal("expected error") 195 } 196 197 if !strings.Contains(err.Error(), "Error parsing") { 198 t.Fatalf("Expected parsing error, got: %s", err) 199 } 200 } 201 202 func TestRetryFunc(t *testing.T) { 203 // succeed on the third try 204 errs := []error{io.EOF, &net.OpError{Err: errors.New("ERROR")}, nil} 205 count := 0 206 207 err := retryFunc(context.Background(), time.Second, func() error { 208 if count >= len(errs) { 209 return errors.New("failed to stop after nil error") 210 } 211 212 err := errs[count] 213 count++ 214 215 return err 216 }) 217 218 if count != 3 { 219 t.Fatal("retry func should have been called 3 times") 220 } 221 222 if err != nil { 223 t.Fatal(err) 224 } 225 } 226 227 func testConfig( 228 t *testing.T, 229 c map[string]interface{}) *terraform.ResourceConfig { 230 r, err := config.NewRawConfig(c) 231 if err != nil { 232 t.Fatalf("bad: %s", err) 233 } 234 235 return terraform.NewResourceConfig(r) 236 }