github.com/rothwerx/packer@v0.9.0/builder/digitalocean/builder_test.go (about)

     1  package digitalocean
     2  
     3  import (
     4  	"strconv"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/mitchellh/packer/packer"
     9  )
    10  
    11  func testConfig() map[string]interface{} {
    12  	return map[string]interface{}{
    13  		"api_token": "bar",
    14  		"region":    "nyc2",
    15  		"size":      "512mb",
    16  		"image":     "foo",
    17  	}
    18  }
    19  
    20  func TestBuilder_ImplementsBuilder(t *testing.T) {
    21  	var raw interface{}
    22  	raw = &Builder{}
    23  	if _, ok := raw.(packer.Builder); !ok {
    24  		t.Fatalf("Builder should be a builder")
    25  	}
    26  }
    27  
    28  func TestBuilder_Prepare_BadType(t *testing.T) {
    29  	b := &Builder{}
    30  	c := map[string]interface{}{
    31  		"api_key": []string{},
    32  	}
    33  
    34  	warnings, err := b.Prepare(c)
    35  	if len(warnings) > 0 {
    36  		t.Fatalf("bad: %#v", warnings)
    37  	}
    38  	if err == nil {
    39  		t.Fatalf("prepare should fail")
    40  	}
    41  }
    42  
    43  func TestBuilderPrepare_InvalidKey(t *testing.T) {
    44  	var b Builder
    45  	config := testConfig()
    46  
    47  	// Add a random key
    48  	config["i_should_not_be_valid"] = true
    49  	warnings, err := b.Prepare(config)
    50  	if len(warnings) > 0 {
    51  		t.Fatalf("bad: %#v", warnings)
    52  	}
    53  	if err == nil {
    54  		t.Fatal("should have error")
    55  	}
    56  }
    57  
    58  func TestBuilderPrepare_Region(t *testing.T) {
    59  	var b Builder
    60  	config := testConfig()
    61  
    62  	// Test default
    63  	delete(config, "region")
    64  	warnings, err := b.Prepare(config)
    65  	if len(warnings) > 0 {
    66  		t.Fatalf("bad: %#v", warnings)
    67  	}
    68  	if err == nil {
    69  		t.Fatalf("should error")
    70  	}
    71  
    72  	expected := "sfo1"
    73  
    74  	// Test set
    75  	config["region"] = expected
    76  	b = Builder{}
    77  	warnings, err = b.Prepare(config)
    78  	if len(warnings) > 0 {
    79  		t.Fatalf("bad: %#v", warnings)
    80  	}
    81  	if err != nil {
    82  		t.Fatalf("should not have error: %s", err)
    83  	}
    84  
    85  	if b.config.Region != expected {
    86  		t.Errorf("found %s, expected %s", b.config.Region, expected)
    87  	}
    88  }
    89  
    90  func TestBuilderPrepare_Size(t *testing.T) {
    91  	var b Builder
    92  	config := testConfig()
    93  
    94  	// Test default
    95  	delete(config, "size")
    96  	warnings, err := b.Prepare(config)
    97  	if len(warnings) > 0 {
    98  		t.Fatalf("bad: %#v", warnings)
    99  	}
   100  	if err == nil {
   101  		t.Fatalf("should error")
   102  	}
   103  
   104  	expected := "1024mb"
   105  
   106  	// Test set
   107  	config["size"] = expected
   108  	b = Builder{}
   109  	warnings, err = b.Prepare(config)
   110  	if len(warnings) > 0 {
   111  		t.Fatalf("bad: %#v", warnings)
   112  	}
   113  	if err != nil {
   114  		t.Fatalf("should not have error: %s", err)
   115  	}
   116  
   117  	if b.config.Size != expected {
   118  		t.Errorf("found %s, expected %s", b.config.Size, expected)
   119  	}
   120  }
   121  
   122  func TestBuilderPrepare_Image(t *testing.T) {
   123  	var b Builder
   124  	config := testConfig()
   125  
   126  	// Test default
   127  	delete(config, "image")
   128  	warnings, err := b.Prepare(config)
   129  	if len(warnings) > 0 {
   130  		t.Fatalf("bad: %#v", warnings)
   131  	}
   132  	if err == nil {
   133  		t.Fatal("should error")
   134  	}
   135  
   136  	expected := "ubuntu-14-04-x64"
   137  
   138  	// Test set
   139  	config["image"] = expected
   140  	b = Builder{}
   141  	warnings, err = b.Prepare(config)
   142  	if len(warnings) > 0 {
   143  		t.Fatalf("bad: %#v", warnings)
   144  	}
   145  	if err != nil {
   146  		t.Fatalf("should not have error: %s", err)
   147  	}
   148  
   149  	if b.config.Image != expected {
   150  		t.Errorf("found %s, expected %s", b.config.Image, expected)
   151  	}
   152  }
   153  
   154  func TestBuilderPrepare_SSHUsername(t *testing.T) {
   155  	var b Builder
   156  	config := testConfig()
   157  
   158  	// Test default
   159  	warnings, err := b.Prepare(config)
   160  	if len(warnings) > 0 {
   161  		t.Fatalf("bad: %#v", warnings)
   162  	}
   163  	if err != nil {
   164  		t.Fatalf("should not have error: %s", err)
   165  	}
   166  
   167  	if b.config.Comm.SSHUsername != "root" {
   168  		t.Errorf("invalid: %s", b.config.Comm.SSHUsername)
   169  	}
   170  
   171  	// Test set
   172  	config["ssh_username"] = "foo"
   173  	b = Builder{}
   174  	warnings, err = b.Prepare(config)
   175  	if len(warnings) > 0 {
   176  		t.Fatalf("bad: %#v", warnings)
   177  	}
   178  	if err != nil {
   179  		t.Fatalf("should not have error: %s", err)
   180  	}
   181  
   182  	if b.config.Comm.SSHUsername != "foo" {
   183  		t.Errorf("invalid: %s", b.config.Comm.SSHUsername)
   184  	}
   185  }
   186  
   187  func TestBuilderPrepare_StateTimeout(t *testing.T) {
   188  	var b Builder
   189  	config := testConfig()
   190  
   191  	// Test default
   192  	warnings, err := b.Prepare(config)
   193  	if len(warnings) > 0 {
   194  		t.Fatalf("bad: %#v", warnings)
   195  	}
   196  	if err != nil {
   197  		t.Fatalf("should not have error: %s", err)
   198  	}
   199  
   200  	if b.config.StateTimeout != 6*time.Minute {
   201  		t.Errorf("invalid: %s", b.config.StateTimeout)
   202  	}
   203  
   204  	// Test set
   205  	config["state_timeout"] = "5m"
   206  	b = Builder{}
   207  	warnings, err = b.Prepare(config)
   208  	if len(warnings) > 0 {
   209  		t.Fatalf("bad: %#v", warnings)
   210  	}
   211  	if err != nil {
   212  		t.Fatalf("should not have error: %s", err)
   213  	}
   214  
   215  	// Test bad
   216  	config["state_timeout"] = "tubes"
   217  	b = Builder{}
   218  	warnings, err = b.Prepare(config)
   219  	if len(warnings) > 0 {
   220  		t.Fatalf("bad: %#v", warnings)
   221  	}
   222  	if err == nil {
   223  		t.Fatal("should have error")
   224  	}
   225  
   226  }
   227  
   228  func TestBuilderPrepare_PrivateNetworking(t *testing.T) {
   229  	var b Builder
   230  	config := testConfig()
   231  
   232  	// Test default
   233  	warnings, err := b.Prepare(config)
   234  	if len(warnings) > 0 {
   235  		t.Fatalf("bad: %#v", warnings)
   236  	}
   237  	if err != nil {
   238  		t.Fatalf("should not have error: %s", err)
   239  	}
   240  
   241  	if b.config.PrivateNetworking != false {
   242  		t.Errorf("invalid: %t", b.config.PrivateNetworking)
   243  	}
   244  
   245  	// Test set
   246  	config["private_networking"] = true
   247  	b = Builder{}
   248  	warnings, err = b.Prepare(config)
   249  	if len(warnings) > 0 {
   250  		t.Fatalf("bad: %#v", warnings)
   251  	}
   252  	if err != nil {
   253  		t.Fatalf("should not have error: %s", err)
   254  	}
   255  
   256  	if b.config.PrivateNetworking != true {
   257  		t.Errorf("invalid: %t", b.config.PrivateNetworking)
   258  	}
   259  }
   260  
   261  func TestBuilderPrepare_SnapshotName(t *testing.T) {
   262  	var b Builder
   263  	config := testConfig()
   264  
   265  	// Test default
   266  	warnings, err := b.Prepare(config)
   267  	if len(warnings) > 0 {
   268  		t.Fatalf("bad: %#v", warnings)
   269  	}
   270  	if err != nil {
   271  		t.Fatalf("should not have error: %s", err)
   272  	}
   273  
   274  	if b.config.SnapshotName == "" {
   275  		t.Errorf("invalid: %s", b.config.SnapshotName)
   276  	}
   277  
   278  	// Test set
   279  	config["snapshot_name"] = "foobarbaz"
   280  	b = Builder{}
   281  	warnings, err = b.Prepare(config)
   282  	if len(warnings) > 0 {
   283  		t.Fatalf("bad: %#v", warnings)
   284  	}
   285  	if err != nil {
   286  		t.Fatalf("should not have error: %s", err)
   287  	}
   288  
   289  	// Test set with template
   290  	config["snapshot_name"] = "{{timestamp}}"
   291  	b = Builder{}
   292  	warnings, err = b.Prepare(config)
   293  	if len(warnings) > 0 {
   294  		t.Fatalf("bad: %#v", warnings)
   295  	}
   296  	if err != nil {
   297  		t.Fatalf("should not have error: %s", err)
   298  	}
   299  
   300  	_, err = strconv.ParseInt(b.config.SnapshotName, 0, 0)
   301  	if err != nil {
   302  		t.Fatalf("failed to parse int in template: %s", err)
   303  	}
   304  
   305  }
   306  
   307  func TestBuilderPrepare_DropletName(t *testing.T) {
   308  	var b Builder
   309  	config := testConfig()
   310  
   311  	// Test default
   312  	warnings, err := b.Prepare(config)
   313  	if len(warnings) > 0 {
   314  		t.Fatalf("bad: %#v", warnings)
   315  	}
   316  	if err != nil {
   317  		t.Fatalf("should not have error: %s", err)
   318  	}
   319  
   320  	if b.config.DropletName == "" {
   321  		t.Errorf("invalid: %s", b.config.DropletName)
   322  	}
   323  
   324  	// Test normal set
   325  	config["droplet_name"] = "foobar"
   326  	b = Builder{}
   327  	warnings, err = b.Prepare(config)
   328  	if len(warnings) > 0 {
   329  		t.Fatalf("bad: %#v", warnings)
   330  	}
   331  	if err != nil {
   332  		t.Fatalf("should not have error: %s", err)
   333  	}
   334  
   335  	// Test with template
   336  	config["droplet_name"] = "foobar-{{timestamp}}"
   337  	b = Builder{}
   338  	warnings, err = b.Prepare(config)
   339  	if len(warnings) > 0 {
   340  		t.Fatalf("bad: %#v", warnings)
   341  	}
   342  	if err != nil {
   343  		t.Fatalf("should not have error: %s", err)
   344  	}
   345  
   346  	// Test with bad template
   347  	config["droplet_name"] = "foobar-{{"
   348  	b = Builder{}
   349  	warnings, err = b.Prepare(config)
   350  	if len(warnings) > 0 {
   351  		t.Fatalf("bad: %#v", warnings)
   352  	}
   353  	if err == nil {
   354  		t.Fatal("should have error")
   355  	}
   356  
   357  }