github.com/kjmkznr/terraform@v0.5.2-0.20180216194316-1d0f5fdac99e/builtin/provisioners/remote-exec/resource_provisioner_test.go (about)

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