github.com/askholme/packer@v0.7.2-0.20140924152349-70d9566a6852/builder/digitalocean/builder_test.go (about)

     1  package digitalocean
     2  
     3  import (
     4  	"github.com/mitchellh/packer/packer"
     5  	"os"
     6  	"strconv"
     7  	"testing"
     8  )
     9  
    10  func init() {
    11  	// Clear out the credential env vars
    12  	os.Setenv("DIGITALOCEAN_API_KEY", "")
    13  	os.Setenv("DIGITALOCEAN_CLIENT_ID", "")
    14  }
    15  
    16  func testConfig() map[string]interface{} {
    17  	return map[string]interface{}{
    18  		"client_id": "foo",
    19  		"api_key":   "bar",
    20  	}
    21  }
    22  
    23  func TestBuilder_ImplementsBuilder(t *testing.T) {
    24  	var raw interface{}
    25  	raw = &Builder{}
    26  	if _, ok := raw.(packer.Builder); !ok {
    27  		t.Fatalf("Builder should be a builder")
    28  	}
    29  }
    30  
    31  func TestBuilder_Prepare_BadType(t *testing.T) {
    32  	b := &Builder{}
    33  	c := map[string]interface{}{
    34  		"api_key": []string{},
    35  	}
    36  
    37  	warnings, err := b.Prepare(c)
    38  	if len(warnings) > 0 {
    39  		t.Fatalf("bad: %#v", warnings)
    40  	}
    41  	if err == nil {
    42  		t.Fatalf("prepare should fail")
    43  	}
    44  }
    45  
    46  func TestBuilderPrepare_APIKey(t *testing.T) {
    47  	var b Builder
    48  	config := testConfig()
    49  
    50  	// Test good
    51  	config["api_key"] = "foo"
    52  	warnings, err := b.Prepare(config)
    53  	if len(warnings) > 0 {
    54  		t.Fatalf("bad: %#v", warnings)
    55  	}
    56  	if err != nil {
    57  		t.Fatalf("should not have error: %s", err)
    58  	}
    59  
    60  	if b.config.APIKey != "foo" {
    61  		t.Errorf("access key invalid: %s", b.config.APIKey)
    62  	}
    63  
    64  	// Test bad
    65  	delete(config, "api_key")
    66  	b = Builder{}
    67  	warnings, err = b.Prepare(config)
    68  	if len(warnings) > 0 {
    69  		t.Fatalf("bad: %#v", warnings)
    70  	}
    71  	if err == nil {
    72  		t.Fatal("should have error")
    73  	}
    74  
    75  	// Test env variable
    76  	delete(config, "api_key")
    77  	os.Setenv("DIGITALOCEAN_API_KEY", "foo")
    78  	defer os.Setenv("DIGITALOCEAN_API_KEY", "")
    79  	warnings, err = b.Prepare(config)
    80  	if len(warnings) > 0 {
    81  		t.Fatalf("bad: %#v", warnings)
    82  	}
    83  	if err != nil {
    84  		t.Fatalf("should not have error: %s", err)
    85  	}
    86  }
    87  
    88  func TestBuilderPrepare_ClientID(t *testing.T) {
    89  	var b Builder
    90  	config := testConfig()
    91  
    92  	// Test good
    93  	config["client_id"] = "foo"
    94  	warnings, err := b.Prepare(config)
    95  	if len(warnings) > 0 {
    96  		t.Fatalf("bad: %#v", warnings)
    97  	}
    98  	if err != nil {
    99  		t.Fatalf("should not have error: %s", err)
   100  	}
   101  
   102  	if b.config.ClientID != "foo" {
   103  		t.Errorf("invalid: %s", b.config.ClientID)
   104  	}
   105  
   106  	// Test bad
   107  	delete(config, "client_id")
   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.Fatal("should have error")
   115  	}
   116  
   117  	// Test env variable
   118  	delete(config, "client_id")
   119  	os.Setenv("DIGITALOCEAN_CLIENT_ID", "foo")
   120  	defer os.Setenv("DIGITALOCEAN_CLIENT_ID", "")
   121  	warnings, err = b.Prepare(config)
   122  	if len(warnings) > 0 {
   123  		t.Fatalf("bad: %#v", warnings)
   124  	}
   125  	if err != nil {
   126  		t.Fatalf("should not have error: %s", err)
   127  	}
   128  }
   129  
   130  func TestBuilderPrepare_InvalidKey(t *testing.T) {
   131  	var b Builder
   132  	config := testConfig()
   133  
   134  	// Add a random key
   135  	config["i_should_not_be_valid"] = true
   136  	warnings, err := b.Prepare(config)
   137  	if len(warnings) > 0 {
   138  		t.Fatalf("bad: %#v", warnings)
   139  	}
   140  	if err == nil {
   141  		t.Fatal("should have error")
   142  	}
   143  }
   144  
   145  func TestBuilderPrepare_Region(t *testing.T) {
   146  	var b Builder
   147  	config := testConfig()
   148  
   149  	// Test default
   150  	warnings, err := b.Prepare(config)
   151  	if len(warnings) > 0 {
   152  		t.Fatalf("bad: %#v", warnings)
   153  	}
   154  	if err != nil {
   155  		t.Fatalf("should not have error: %s", err)
   156  	}
   157  
   158  	if b.config.Region != DefaultRegion {
   159  		t.Errorf("found %s, expected %s", b.config.Region, DefaultRegion)
   160  	}
   161  
   162  	expected := "sfo1"
   163  
   164  	// Test set
   165  	config["region_id"] = 0
   166  	config["region"] = expected
   167  	b = Builder{}
   168  	warnings, err = b.Prepare(config)
   169  	if len(warnings) > 0 {
   170  		t.Fatalf("bad: %#v", warnings)
   171  	}
   172  	if err != nil {
   173  		t.Fatalf("should not have error: %s", err)
   174  	}
   175  
   176  	if b.config.Region != expected {
   177  		t.Errorf("found %s, expected %s", b.config.Region, expected)
   178  	}
   179  }
   180  
   181  func TestBuilderPrepare_Size(t *testing.T) {
   182  	var b Builder
   183  	config := testConfig()
   184  
   185  	// Test default
   186  	warnings, err := b.Prepare(config)
   187  	if len(warnings) > 0 {
   188  		t.Fatalf("bad: %#v", warnings)
   189  	}
   190  	if err != nil {
   191  		t.Fatalf("should not have error: %s", err)
   192  	}
   193  
   194  	if b.config.Size != DefaultSize {
   195  		t.Errorf("found %s, expected %s", b.config.Size, DefaultSize)
   196  	}
   197  
   198  	expected := "1024mb"
   199  
   200  	// Test set
   201  	config["size_id"] = 0
   202  	config["size"] = expected
   203  	b = Builder{}
   204  	warnings, err = b.Prepare(config)
   205  	if len(warnings) > 0 {
   206  		t.Fatalf("bad: %#v", warnings)
   207  	}
   208  	if err != nil {
   209  		t.Fatalf("should not have error: %s", err)
   210  	}
   211  
   212  	if b.config.Size != expected {
   213  		t.Errorf("found %s, expected %s", b.config.Size, expected)
   214  	}
   215  }
   216  
   217  func TestBuilderPrepare_Image(t *testing.T) {
   218  	var b Builder
   219  	config := testConfig()
   220  
   221  	// Test default
   222  	warnings, err := b.Prepare(config)
   223  	if len(warnings) > 0 {
   224  		t.Fatalf("bad: %#v", warnings)
   225  	}
   226  	if err != nil {
   227  		t.Fatalf("should not have error: %s", err)
   228  	}
   229  
   230  	if b.config.Image != DefaultImage {
   231  		t.Errorf("found %s, expected %s", b.config.Image, DefaultImage)
   232  	}
   233  
   234  	expected := "ubuntu-14-04-x64"
   235  
   236  	// Test set
   237  	config["image_id"] = 0
   238  	config["image"] = expected
   239  	b = Builder{}
   240  	warnings, err = b.Prepare(config)
   241  	if len(warnings) > 0 {
   242  		t.Fatalf("bad: %#v", warnings)
   243  	}
   244  	if err != nil {
   245  		t.Fatalf("should not have error: %s", err)
   246  	}
   247  
   248  	if b.config.Image != expected {
   249  		t.Errorf("found %s, expected %s", b.config.Image, expected)
   250  	}
   251  }
   252  
   253  func TestBuilderPrepare_SSHUsername(t *testing.T) {
   254  	var b Builder
   255  	config := testConfig()
   256  
   257  	// Test default
   258  	warnings, err := b.Prepare(config)
   259  	if len(warnings) > 0 {
   260  		t.Fatalf("bad: %#v", warnings)
   261  	}
   262  	if err != nil {
   263  		t.Fatalf("should not have error: %s", err)
   264  	}
   265  
   266  	if b.config.SSHUsername != "root" {
   267  		t.Errorf("invalid: %d", b.config.SSHUsername)
   268  	}
   269  
   270  	// Test set
   271  	config["ssh_username"] = "foo"
   272  	b = Builder{}
   273  	warnings, err = b.Prepare(config)
   274  	if len(warnings) > 0 {
   275  		t.Fatalf("bad: %#v", warnings)
   276  	}
   277  	if err != nil {
   278  		t.Fatalf("should not have error: %s", err)
   279  	}
   280  
   281  	if b.config.SSHUsername != "foo" {
   282  		t.Errorf("invalid: %s", b.config.SSHUsername)
   283  	}
   284  }
   285  
   286  func TestBuilderPrepare_SSHTimeout(t *testing.T) {
   287  	var b Builder
   288  	config := testConfig()
   289  
   290  	// Test default
   291  	warnings, err := b.Prepare(config)
   292  	if len(warnings) > 0 {
   293  		t.Fatalf("bad: %#v", warnings)
   294  	}
   295  	if err != nil {
   296  		t.Fatalf("should not have error: %s", err)
   297  	}
   298  
   299  	if b.config.RawSSHTimeout != "1m" {
   300  		t.Errorf("invalid: %d", b.config.RawSSHTimeout)
   301  	}
   302  
   303  	// Test set
   304  	config["ssh_timeout"] = "30s"
   305  	b = Builder{}
   306  	warnings, err = b.Prepare(config)
   307  	if len(warnings) > 0 {
   308  		t.Fatalf("bad: %#v", warnings)
   309  	}
   310  	if err != nil {
   311  		t.Fatalf("should not have error: %s", err)
   312  	}
   313  
   314  	// Test bad
   315  	config["ssh_timeout"] = "tubes"
   316  	b = Builder{}
   317  	warnings, err = b.Prepare(config)
   318  	if len(warnings) > 0 {
   319  		t.Fatalf("bad: %#v", warnings)
   320  	}
   321  	if err == nil {
   322  		t.Fatal("should have error")
   323  	}
   324  
   325  }
   326  
   327  func TestBuilderPrepare_StateTimeout(t *testing.T) {
   328  	var b Builder
   329  	config := testConfig()
   330  
   331  	// Test default
   332  	warnings, err := b.Prepare(config)
   333  	if len(warnings) > 0 {
   334  		t.Fatalf("bad: %#v", warnings)
   335  	}
   336  	if err != nil {
   337  		t.Fatalf("should not have error: %s", err)
   338  	}
   339  
   340  	if b.config.RawStateTimeout != "6m" {
   341  		t.Errorf("invalid: %d", b.config.RawStateTimeout)
   342  	}
   343  
   344  	// Test set
   345  	config["state_timeout"] = "5m"
   346  	b = Builder{}
   347  	warnings, err = b.Prepare(config)
   348  	if len(warnings) > 0 {
   349  		t.Fatalf("bad: %#v", warnings)
   350  	}
   351  	if err != nil {
   352  		t.Fatalf("should not have error: %s", err)
   353  	}
   354  
   355  	// Test bad
   356  	config["state_timeout"] = "tubes"
   357  	b = Builder{}
   358  	warnings, err = b.Prepare(config)
   359  	if len(warnings) > 0 {
   360  		t.Fatalf("bad: %#v", warnings)
   361  	}
   362  	if err == nil {
   363  		t.Fatal("should have error")
   364  	}
   365  
   366  }
   367  
   368  func TestBuilderPrepare_PrivateNetworking(t *testing.T) {
   369  	var b Builder
   370  	config := testConfig()
   371  
   372  	// Test default
   373  	warnings, err := b.Prepare(config)
   374  	if len(warnings) > 0 {
   375  		t.Fatalf("bad: %#v", warnings)
   376  	}
   377  	if err != nil {
   378  		t.Fatalf("should not have error: %s", err)
   379  	}
   380  
   381  	if b.config.PrivateNetworking != false {
   382  		t.Errorf("invalid: %s", b.config.PrivateNetworking)
   383  	}
   384  
   385  	// Test set
   386  	config["private_networking"] = true
   387  	b = Builder{}
   388  	warnings, err = b.Prepare(config)
   389  	if len(warnings) > 0 {
   390  		t.Fatalf("bad: %#v", warnings)
   391  	}
   392  	if err != nil {
   393  		t.Fatalf("should not have error: %s", err)
   394  	}
   395  
   396  	if b.config.PrivateNetworking != true {
   397  		t.Errorf("invalid: %s", b.config.PrivateNetworking)
   398  	}
   399  }
   400  
   401  func TestBuilderPrepare_SnapshotName(t *testing.T) {
   402  	var b Builder
   403  	config := testConfig()
   404  
   405  	// Test default
   406  	warnings, err := b.Prepare(config)
   407  	if len(warnings) > 0 {
   408  		t.Fatalf("bad: %#v", warnings)
   409  	}
   410  	if err != nil {
   411  		t.Fatalf("should not have error: %s", err)
   412  	}
   413  
   414  	if b.config.SnapshotName == "" {
   415  		t.Errorf("invalid: %s", b.config.SnapshotName)
   416  	}
   417  
   418  	// Test set
   419  	config["snapshot_name"] = "foobarbaz"
   420  	b = Builder{}
   421  	warnings, err = b.Prepare(config)
   422  	if len(warnings) > 0 {
   423  		t.Fatalf("bad: %#v", warnings)
   424  	}
   425  	if err != nil {
   426  		t.Fatalf("should not have error: %s", err)
   427  	}
   428  
   429  	// Test set with template
   430  	config["snapshot_name"] = "{{timestamp}}"
   431  	b = Builder{}
   432  	warnings, err = b.Prepare(config)
   433  	if len(warnings) > 0 {
   434  		t.Fatalf("bad: %#v", warnings)
   435  	}
   436  	if err != nil {
   437  		t.Fatalf("should not have error: %s", err)
   438  	}
   439  
   440  	_, err = strconv.ParseInt(b.config.SnapshotName, 0, 0)
   441  	if err != nil {
   442  		t.Fatalf("failed to parse int in template: %s", err)
   443  	}
   444  
   445  }
   446  
   447  func TestBuilderPrepare_DropletName(t *testing.T) {
   448  	var b Builder
   449  	config := testConfig()
   450  
   451  	// Test default
   452  	warnings, err := b.Prepare(config)
   453  	if len(warnings) > 0 {
   454  		t.Fatalf("bad: %#v", warnings)
   455  	}
   456  	if err != nil {
   457  		t.Fatalf("should not have error: %s", err)
   458  	}
   459  
   460  	if b.config.DropletName == "" {
   461  		t.Errorf("invalid: %s", b.config.DropletName)
   462  	}
   463  
   464  	// Test normal set
   465  	config["droplet_name"] = "foobar"
   466  	b = Builder{}
   467  	warnings, err = b.Prepare(config)
   468  	if len(warnings) > 0 {
   469  		t.Fatalf("bad: %#v", warnings)
   470  	}
   471  	if err != nil {
   472  		t.Fatalf("should not have error: %s", err)
   473  	}
   474  
   475  	// Test with template
   476  	config["droplet_name"] = "foobar-{{timestamp}}"
   477  	b = Builder{}
   478  	warnings, err = b.Prepare(config)
   479  	if len(warnings) > 0 {
   480  		t.Fatalf("bad: %#v", warnings)
   481  	}
   482  	if err != nil {
   483  		t.Fatalf("should not have error: %s", err)
   484  	}
   485  
   486  	// Test with bad template
   487  	config["droplet_name"] = "foobar-{{"
   488  	b = Builder{}
   489  	warnings, err = b.Prepare(config)
   490  	if len(warnings) > 0 {
   491  		t.Fatalf("bad: %#v", warnings)
   492  	}
   493  	if err == nil {
   494  		t.Fatal("should have error")
   495  	}
   496  
   497  }