github.com/sneal/packer@v0.5.2/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_RegionID(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.RegionID != 1 {
   159  		t.Errorf("invalid: %d", b.config.RegionID)
   160  	}
   161  
   162  	// Test set
   163  	config["region_id"] = 2
   164  	b = Builder{}
   165  	warnings, err = b.Prepare(config)
   166  	if len(warnings) > 0 {
   167  		t.Fatalf("bad: %#v", warnings)
   168  	}
   169  	if err != nil {
   170  		t.Fatalf("should not have error: %s", err)
   171  	}
   172  
   173  	if b.config.RegionID != 2 {
   174  		t.Errorf("invalid: %d", b.config.RegionID)
   175  	}
   176  }
   177  
   178  func TestBuilderPrepare_SizeID(t *testing.T) {
   179  	var b Builder
   180  	config := testConfig()
   181  
   182  	// Test default
   183  	warnings, err := b.Prepare(config)
   184  	if len(warnings) > 0 {
   185  		t.Fatalf("bad: %#v", warnings)
   186  	}
   187  	if err != nil {
   188  		t.Fatalf("should not have error: %s", err)
   189  	}
   190  
   191  	if b.config.SizeID != 66 {
   192  		t.Errorf("invalid: %d", b.config.SizeID)
   193  	}
   194  
   195  	// Test set
   196  	config["size_id"] = 67
   197  	b = Builder{}
   198  	warnings, err = b.Prepare(config)
   199  	if len(warnings) > 0 {
   200  		t.Fatalf("bad: %#v", warnings)
   201  	}
   202  	if err != nil {
   203  		t.Fatalf("should not have error: %s", err)
   204  	}
   205  
   206  	if b.config.SizeID != 67 {
   207  		t.Errorf("invalid: %d", b.config.SizeID)
   208  	}
   209  }
   210  
   211  func TestBuilderPrepare_ImageID(t *testing.T) {
   212  	var b Builder
   213  	config := testConfig()
   214  
   215  	// Test default
   216  	warnings, err := b.Prepare(config)
   217  	if len(warnings) > 0 {
   218  		t.Fatalf("bad: %#v", warnings)
   219  	}
   220  	if err != nil {
   221  		t.Fatalf("should not have error: %s", err)
   222  	}
   223  
   224  	if b.config.SizeID != 66 {
   225  		t.Errorf("invalid: %d", b.config.SizeID)
   226  	}
   227  
   228  	// Test set
   229  	config["size_id"] = 2
   230  	b = Builder{}
   231  	warnings, err = b.Prepare(config)
   232  	if len(warnings) > 0 {
   233  		t.Fatalf("bad: %#v", warnings)
   234  	}
   235  	if err != nil {
   236  		t.Fatalf("should not have error: %s", err)
   237  	}
   238  
   239  	if b.config.SizeID != 2 {
   240  		t.Errorf("invalid: %d", b.config.SizeID)
   241  	}
   242  }
   243  
   244  func TestBuilderPrepare_SSHUsername(t *testing.T) {
   245  	var b Builder
   246  	config := testConfig()
   247  
   248  	// Test default
   249  	warnings, err := b.Prepare(config)
   250  	if len(warnings) > 0 {
   251  		t.Fatalf("bad: %#v", warnings)
   252  	}
   253  	if err != nil {
   254  		t.Fatalf("should not have error: %s", err)
   255  	}
   256  
   257  	if b.config.SSHUsername != "root" {
   258  		t.Errorf("invalid: %d", b.config.SSHUsername)
   259  	}
   260  
   261  	// Test set
   262  	config["ssh_username"] = "foo"
   263  	b = Builder{}
   264  	warnings, err = b.Prepare(config)
   265  	if len(warnings) > 0 {
   266  		t.Fatalf("bad: %#v", warnings)
   267  	}
   268  	if err != nil {
   269  		t.Fatalf("should not have error: %s", err)
   270  	}
   271  
   272  	if b.config.SSHUsername != "foo" {
   273  		t.Errorf("invalid: %s", b.config.SSHUsername)
   274  	}
   275  }
   276  
   277  func TestBuilderPrepare_SSHTimeout(t *testing.T) {
   278  	var b Builder
   279  	config := testConfig()
   280  
   281  	// Test default
   282  	warnings, err := b.Prepare(config)
   283  	if len(warnings) > 0 {
   284  		t.Fatalf("bad: %#v", warnings)
   285  	}
   286  	if err != nil {
   287  		t.Fatalf("should not have error: %s", err)
   288  	}
   289  
   290  	if b.config.RawSSHTimeout != "1m" {
   291  		t.Errorf("invalid: %d", b.config.RawSSHTimeout)
   292  	}
   293  
   294  	// Test set
   295  	config["ssh_timeout"] = "30s"
   296  	b = Builder{}
   297  	warnings, err = b.Prepare(config)
   298  	if len(warnings) > 0 {
   299  		t.Fatalf("bad: %#v", warnings)
   300  	}
   301  	if err != nil {
   302  		t.Fatalf("should not have error: %s", err)
   303  	}
   304  
   305  	// Test bad
   306  	config["ssh_timeout"] = "tubes"
   307  	b = Builder{}
   308  	warnings, err = b.Prepare(config)
   309  	if len(warnings) > 0 {
   310  		t.Fatalf("bad: %#v", warnings)
   311  	}
   312  	if err == nil {
   313  		t.Fatal("should have error")
   314  	}
   315  
   316  }
   317  
   318  func TestBuilderPrepare_StateTimeout(t *testing.T) {
   319  	var b Builder
   320  	config := testConfig()
   321  
   322  	// Test default
   323  	warnings, err := b.Prepare(config)
   324  	if len(warnings) > 0 {
   325  		t.Fatalf("bad: %#v", warnings)
   326  	}
   327  	if err != nil {
   328  		t.Fatalf("should not have error: %s", err)
   329  	}
   330  
   331  	if b.config.RawStateTimeout != "6m" {
   332  		t.Errorf("invalid: %d", b.config.RawStateTimeout)
   333  	}
   334  
   335  	// Test set
   336  	config["state_timeout"] = "5m"
   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 bad
   347  	config["state_timeout"] = "tubes"
   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  }
   358  
   359  func TestBuilderPrepare_PrivateNetworking(t *testing.T) {
   360  	var b Builder
   361  	config := testConfig()
   362  
   363  	// Test default
   364  	warnings, err := b.Prepare(config)
   365  	if len(warnings) > 0 {
   366  		t.Fatalf("bad: %#v", warnings)
   367  	}
   368  	if err != nil {
   369  		t.Fatalf("should not have error: %s", err)
   370  	}
   371  
   372  	if b.config.PrivateNetworking != false {
   373  		t.Errorf("invalid: %s", b.config.PrivateNetworking)
   374  	}
   375  
   376  	// Test set
   377  	config["private_networking"] = true
   378  	b = Builder{}
   379  	warnings, err = b.Prepare(config)
   380  	if len(warnings) > 0 {
   381  		t.Fatalf("bad: %#v", warnings)
   382  	}
   383  	if err != nil {
   384  		t.Fatalf("should not have error: %s", err)
   385  	}
   386  
   387  	if b.config.PrivateNetworking != true {
   388  		t.Errorf("invalid: %s", b.config.PrivateNetworking)
   389  	}
   390  }
   391  
   392  func TestBuilderPrepare_SnapshotName(t *testing.T) {
   393  	var b Builder
   394  	config := testConfig()
   395  
   396  	// Test default
   397  	warnings, err := b.Prepare(config)
   398  	if len(warnings) > 0 {
   399  		t.Fatalf("bad: %#v", warnings)
   400  	}
   401  	if err != nil {
   402  		t.Fatalf("should not have error: %s", err)
   403  	}
   404  
   405  	if b.config.SnapshotName == "" {
   406  		t.Errorf("invalid: %s", b.config.SnapshotName)
   407  	}
   408  
   409  	// Test set
   410  	config["snapshot_name"] = "foobarbaz"
   411  	b = Builder{}
   412  	warnings, err = b.Prepare(config)
   413  	if len(warnings) > 0 {
   414  		t.Fatalf("bad: %#v", warnings)
   415  	}
   416  	if err != nil {
   417  		t.Fatalf("should not have error: %s", err)
   418  	}
   419  
   420  	// Test set with template
   421  	config["snapshot_name"] = "{{timestamp}}"
   422  	b = Builder{}
   423  	warnings, err = b.Prepare(config)
   424  	if len(warnings) > 0 {
   425  		t.Fatalf("bad: %#v", warnings)
   426  	}
   427  	if err != nil {
   428  		t.Fatalf("should not have error: %s", err)
   429  	}
   430  
   431  	_, err = strconv.ParseInt(b.config.SnapshotName, 0, 0)
   432  	if err != nil {
   433  		t.Fatalf("failed to parse int in template: %s", err)
   434  	}
   435  
   436  }
   437  
   438  func TestBuilderPrepare_DropletName(t *testing.T) {
   439  	var b Builder
   440  	config := testConfig()
   441  
   442  	// Test default
   443  	warnings, err := b.Prepare(config)
   444  	if len(warnings) > 0 {
   445  		t.Fatalf("bad: %#v", warnings)
   446  	}
   447  	if err != nil {
   448  		t.Fatalf("should not have error: %s", err)
   449  	}
   450  
   451  	if b.config.DropletName == "" {
   452  		t.Errorf("invalid: %s", b.config.DropletName)
   453  	}
   454  
   455  	// Test normal set
   456  	config["droplet_name"] = "foobar"
   457  	b = Builder{}
   458  	warnings, err = b.Prepare(config)
   459  	if len(warnings) > 0 {
   460  		t.Fatalf("bad: %#v", warnings)
   461  	}
   462  	if err != nil {
   463  		t.Fatalf("should not have error: %s", err)
   464  	}
   465  
   466  	// Test with template
   467  	config["droplet_name"] = "foobar-{{timestamp}}"
   468  	b = Builder{}
   469  	warnings, err = b.Prepare(config)
   470  	if len(warnings) > 0 {
   471  		t.Fatalf("bad: %#v", warnings)
   472  	}
   473  	if err != nil {
   474  		t.Fatalf("should not have error: %s", err)
   475  	}
   476  
   477  	// Test with bad template
   478  	config["droplet_name"] = "foobar-{{"
   479  	b = Builder{}
   480  	warnings, err = b.Prepare(config)
   481  	if len(warnings) > 0 {
   482  		t.Fatalf("bad: %#v", warnings)
   483  	}
   484  	if err == nil {
   485  		t.Fatal("should have error")
   486  	}
   487  
   488  }