builder/amazonebs: Config validation, testing

builder/amazonebs/builder.go

@@ -6,6 +6,7 @@
 package amazonebs
 
 import (
+	"errors"
 	"github.com/mitchellh/goamz/aws"
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/mapstructure"
@@ -44,17 +45,32 @@ func (b *Builder) Prepare(raw interface{}) (err error) {
 		return
 	}
 
-	log.Printf("Config: %+v", b.config)
+	if b.config.SSHPort == 0 {
+		b.config.SSHPort = 22
+	}
+
+	// Accumulate any errors
+	errs := make([]error, 0)
+
+	if b.config.AccessKey == "" {
+		errs = append(errs, errors.New("An access_key must be specified"))
+	}
+
+	if b.config.SecretKey == "" {
+		errs = append(errs, errors.New("A secret_key must be specified"))
+	}
+
+	if len(errs) > 0 {
+		return &packer.MultiError{errs}
+	}
 
 	// TODO: config validation and asking for fields:
-	// * access key
-	// * secret key
 	// * region (exists and valid)
 	// * source ami
 	// * instance type
 	// * SSH username
-	// * SSH port? (or default to 22?)
 
+	log.Printf("Config: %+v", b.config)
 	return
 }
 

builder/amazonebs/builder_test.go

 package amazonebs
 
 import (
-	"cgl.tideland.biz/asserts"
 	"github.com/mitchellh/packer/packer"
 	"testing"
 )
 
-func TestBuilder_ImplementsBuilder(t *testing.T) {
-	assert := asserts.NewTestingAsserts(t, true)
+func testConfig() map[string]interface{} {
+	return map[string]interface{}{
+		"access_key": "foo",
+		"secret_key": "bar",
+	}
+}
 
-	var actual packer.Builder
-	assert.Implementor(&Builder{}, &actual, "should be a Builder")
+func TestBuilder_ImplementsBuilder(t *testing.T) {
+	var raw interface{}
+	raw = &Builder{}
+	if _, ok := raw.(packer.Builder); !ok {
+		t.Fatalf("Builder should be a builder")
+	}
 }
 
 func TestBuilder_Prepare_BadType(t *testing.T) {
@@ -25,19 +32,77 @@ func TestBuilder_Prepare_BadType(t *testing.T) {
 	}
 }
 
-func TestBuilder_Prepare_Good(t *testing.T) {
-	assert := asserts.NewTestingAsserts(t, true)
+func TestBuilderPrepare_AccessKey(t *testing.T) {
+	var b Builder
+	config := testConfig()
 
-	b := &Builder{}
-	c := map[string]interface{}{
-		"access_key": "foo",
-		"secret_key": "bar",
-		"source_ami": "123456",
+	// Test good
+	config["access_key"] = "foo"
+	err := b.Prepare(config)
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
 	}
 
-	err := b.Prepare(c)
-	assert.Nil(err, "should not have an error")
-	assert.Equal(b.config.AccessKey, "foo", "should be valid access key")
-	assert.Equal(b.config.SecretKey, "bar", "should be valid secret key")
-	assert.Equal(b.config.SourceAmi, "123456", "should have source AMI")
+	if b.config.AccessKey != "foo" {
+		t.Errorf("access key invalid: %s", b.config.AccessKey)
+	}
+
+	// Test bad
+	delete(config, "access_key")
+	b = Builder{}
+	err = b.Prepare(config)
+	if err == nil {
+		t.Fatal("should have error")
+	}
+}
+
+func TestBuilderPrepare_SecretKey(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test good
+	config["secret_key"] = "foo"
+	err := b.Prepare(config)
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.SecretKey != "foo" {
+		t.Errorf("secret key invalid: %s", b.config.SecretKey)
+	}
+
+	// Test bad
+	delete(config, "secret_key")
+	b = Builder{}
+	err = b.Prepare(config)
+	if err == nil {
+		t.Fatal("should have error")
+	}
+}
+
+func TestBuilderPrepare_SSHPort(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test default
+	err := b.Prepare(config)
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.SSHPort != 22 {
+		t.Errorf("invalid: %d", b.config.SSHPort)
+	}
+
+	// Test set
+	config["ssh_port"] = 35
+	b = Builder{}
+	err = b.Prepare(config)
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.SSHPort != 35 {
+		t.Errorf("invalid: %d", b.config.SSHPort)
+	}
 }