diff --git a/CHANGELOG.md b/CHANGELOG.md index cf62f1129..b705ae719 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,12 +1,26 @@ ## 0.3.10 (unreleased) +IMPROVEMENTS: + +* post-processor/vagrant: support instance-store AMIs built by Packer. [GH-502] + BUG FIXES: * builder/all: timeout waiting for SSH connection is a failure. [GH-491] +* builder/amazon: Scrub sensitive data from the logs. [GH-521] +* builder/amazon: Handle the situation where an EC2 instance might not + be immediately available. [GH-522] * builder/digitalocean: don't panic if erroneous API response doesn't contain error message. [GH-492] +* builder/digitalocean: scrub API keys from config debug output [GH-516] * builder/virtualbox: error if VirtualBox version cant be detected. [GH-488] * builder/virtualbox: detect if vboxdrv isn't properly setup. [GH-488] +* builder/virtualbox: sleep a bit before export to ensure the sesssion + is unlocked. [GH-512] +* communicator/ssh: Fix issue where a panic could arise from a nil + dereference. [GH-525] +* provisioner/shell: Won't block on certain scripts on Windows anymore. + [GH-507] ## 0.3.9 (October 2, 2013) diff --git a/builder/amazon/chroot/builder.go b/builder/amazon/chroot/builder.go index 00119b487..f373b4ba2 100644 --- a/builder/amazon/chroot/builder.go +++ b/builder/amazon/chroot/builder.go @@ -143,7 +143,7 @@ func (b *Builder) Prepare(raws ...interface{}) error { return errs } - log.Printf("Config: %+v", b.config) + log.Println(common.ScrubConfig(b.config), b.config.AccessKey, b.config.SecretKey) return nil } diff --git a/builder/amazon/common/artifact_test.go b/builder/amazon/common/artifact_test.go index 28af553c7..ccca4fa0a 100644 --- a/builder/amazon/common/artifact_test.go +++ b/builder/amazon/common/artifact_test.go @@ -1,21 +1,15 @@ package common import ( - "cgl.tideland.biz/asserts" "github.com/mitchellh/packer/packer" "testing" ) func TestArtifact_Impl(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - - var actual packer.Artifact - assert.Implementor(&Artifact{}, &actual, "should be an Artifact") + var _ packer.Artifact = new(Artifact) } func TestArtifactId(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - expected := `east:foo,west:bar` amis := make(map[string]string) @@ -27,12 +21,12 @@ func TestArtifactId(t *testing.T) { } result := a.Id() - assert.Equal(result, expected, "should match output") + if result != expected { + t.Fatalf("bad: %s", result) + } } func TestArtifactString(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - expected := `AMIs were created: east: foo @@ -44,5 +38,7 @@ west: bar` a := &Artifact{Amis: amis} result := a.String() - assert.Equal(result, expected, "should match output") + if result != expected { + t.Fatalf("bad: %s", result) + } } diff --git a/builder/amazon/common/block_device_test.go b/builder/amazon/common/block_device_test.go index 0981816cf..2e671e3d6 100644 --- a/builder/amazon/common/block_device_test.go +++ b/builder/amazon/common/block_device_test.go @@ -1,14 +1,12 @@ package common import ( - "cgl.tideland.biz/asserts" "github.com/mitchellh/goamz/ec2" + "reflect" "testing" ) func TestBlockDevice(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - ec2Mapping := []ec2.BlockDeviceMapping{ ec2.BlockDeviceMapping{ DeviceName: "/dev/sdb", @@ -36,6 +34,11 @@ func TestBlockDevice(t *testing.T) { LaunchMappings: []BlockDevice{blockDevice}, } - assert.Equal(ec2Mapping, blockDevices.BuildAMIDevices(), "should match output") - assert.Equal(ec2Mapping, blockDevices.BuildLaunchDevices(), "should match output") + if !reflect.DeepEqual(ec2Mapping, blockDevices.BuildAMIDevices()) { + t.Fatalf("bad: %#v", ec2Mapping) + } + + if !reflect.DeepEqual(ec2Mapping, blockDevices.BuildLaunchDevices()) { + t.Fatalf("bad: %#v", ec2Mapping) + } } diff --git a/builder/amazon/common/state.go b/builder/amazon/common/state.go index 1e9dea36b..eaa29e92d 100644 --- a/builder/amazon/common/state.go +++ b/builder/amazon/common/state.go @@ -62,11 +62,16 @@ func InstanceStateRefreshFunc(conn *ec2.EC2, i *ec2.Instance) StateRefreshFunc { return func() (interface{}, string, error) { resp, err := conn.Instances([]string{i.InstanceId}, ec2.NewFilter()) if err != nil { - log.Printf("Error on InstanceStateRefresh: %s", err) - return nil, "", err + if ec2err, ok := err.(*ec2.Error); ok && ec2err.Code == "InvalidInstanceID.NotFound" { + // Set this to nil as if we didn't find anything. + resp = nil + } else { + log.Printf("Error on InstanceStateRefresh: %s", err) + return nil, "", err + } } - if len(resp.Reservations) == 0 || len(resp.Reservations[0].Instances) == 0 { + if resp == nil || len(resp.Reservations) == 0 || len(resp.Reservations[0].Instances) == 0 { // Sometimes AWS just has consistency issues and doesn't see // our instance yet. Return an empty state. return nil, "", nil diff --git a/builder/amazon/common/step_security_group.go b/builder/amazon/common/step_security_group.go index 0f52548df..529ec4fff 100644 --- a/builder/amazon/common/step_security_group.go +++ b/builder/amazon/common/step_security_group.go @@ -1,11 +1,10 @@ package common import ( - "cgl.tideland.biz/identifier" - "encoding/hex" "fmt" "github.com/mitchellh/goamz/ec2" "github.com/mitchellh/multistep" + "github.com/mitchellh/packer/common/uuid" "github.com/mitchellh/packer/packer" "log" "time" @@ -35,7 +34,7 @@ func (s *StepSecurityGroup) Run(state multistep.StateBag) multistep.StepAction { // Create the group ui.Say("Creating temporary security group for this instance...") - groupName := fmt.Sprintf("packer %s", hex.EncodeToString(identifier.NewUUID().Raw())) + groupName := fmt.Sprintf("packer %s", uuid.TimeOrderedUUID()) log.Printf("Temporary group name: %s", groupName) group := ec2.SecurityGroup{ Name: groupName, diff --git a/builder/amazon/ebs/builder.go b/builder/amazon/ebs/builder.go index 194e10bc9..376a90e2b 100644 --- a/builder/amazon/ebs/builder.go +++ b/builder/amazon/ebs/builder.go @@ -56,7 +56,7 @@ func (b *Builder) Prepare(raws ...interface{}) error { return errs } - log.Printf("Config: %+v", b.config) + log.Println(common.ScrubConfig(b.config), b.config.AccessKey, b.config.SecretKey) return nil } diff --git a/builder/amazon/instance/builder.go b/builder/amazon/instance/builder.go index 44691ecee..8b3abc75b 100644 --- a/builder/amazon/instance/builder.go +++ b/builder/amazon/instance/builder.go @@ -159,7 +159,7 @@ func (b *Builder) Prepare(raws ...interface{}) error { return errs } - log.Printf("Config: %+v", b.config) + log.Println(common.ScrubConfig(b.config), b.config.AccessKey, b.config.SecretKey) return nil } diff --git a/builder/digitalocean/builder.go b/builder/digitalocean/builder.go index 8e74ec9b1..acf92c240 100644 --- a/builder/digitalocean/builder.go +++ b/builder/digitalocean/builder.go @@ -164,7 +164,7 @@ func (b *Builder) Prepare(raws ...interface{}) error { return errs } - log.Printf("Config: %+v", b.config) + common.ScrubConfig(b.config, b.config.ClientID, b.config.APIKey) return nil } diff --git a/builder/digitalocean/step_create_droplet.go b/builder/digitalocean/step_create_droplet.go index c97cd192d..cdf32db3e 100644 --- a/builder/digitalocean/step_create_droplet.go +++ b/builder/digitalocean/step_create_droplet.go @@ -1,10 +1,9 @@ package digitalocean import ( - "cgl.tideland.biz/identifier" - "encoding/hex" "fmt" "github.com/mitchellh/multistep" + "github.com/mitchellh/packer/common/uuid" "github.com/mitchellh/packer/packer" ) @@ -21,7 +20,7 @@ func (s *stepCreateDroplet) Run(state multistep.StateBag) multistep.StepAction { ui.Say("Creating droplet...") // Some random droplet name as it's temporary - name := fmt.Sprintf("packer-%s", hex.EncodeToString(identifier.NewUUID().Raw())) + name := fmt.Sprintf("packer-%s", uuid.TimeOrderedUUID()) // Create the droplet based on configuration dropletId, err := client.CreateDroplet(name, c.SizeID, c.ImageID, c.RegionID, sshKeyId) diff --git a/builder/digitalocean/step_create_ssh_key.go b/builder/digitalocean/step_create_ssh_key.go index 04699ec66..05e8b8067 100644 --- a/builder/digitalocean/step_create_ssh_key.go +++ b/builder/digitalocean/step_create_ssh_key.go @@ -1,15 +1,14 @@ package digitalocean import ( - "cgl.tideland.biz/identifier" "code.google.com/p/go.crypto/ssh" "crypto/rand" "crypto/rsa" "crypto/x509" - "encoding/hex" "encoding/pem" "fmt" "github.com/mitchellh/multistep" + "github.com/mitchellh/packer/common/uuid" "github.com/mitchellh/packer/packer" "log" ) @@ -43,7 +42,7 @@ func (s *stepCreateSSHKey) Run(state multistep.StateBag) multistep.StepAction { pub_sshformat := string(ssh.MarshalAuthorizedKey(pub)) // The name of the public key on DO - name := fmt.Sprintf("packer-%s", hex.EncodeToString(identifier.NewUUID().Raw())) + name := fmt.Sprintf("packer-%s", uuid.TimeOrderedUUID()) // Create the key! keyId, err := client.CreateKey(name, pub_sshformat) diff --git a/builder/openstack/artifact_test.go b/builder/openstack/artifact_test.go index 2fb4de928..313fea7cf 100644 --- a/builder/openstack/artifact_test.go +++ b/builder/openstack/artifact_test.go @@ -1,21 +1,15 @@ package openstack import ( - "cgl.tideland.biz/asserts" "github.com/mitchellh/packer/packer" "testing" ) func TestArtifact_Impl(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - - var actual packer.Artifact - assert.Implementor(&Artifact{}, &actual, "should be an Artifact") + var _ packer.Artifact = new(Artifact) } func TestArtifactId(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - expected := `b8cdf55b-c916-40bd-b190-389ec144c4ed` a := &Artifact{ @@ -23,17 +17,19 @@ func TestArtifactId(t *testing.T) { } result := a.Id() - assert.Equal(result, expected, "should match output") + if result != expected { + t.Fatalf("bad: %s", result) + } } func TestArtifactString(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - expected := "An image was created: b8cdf55b-c916-40bd-b190-389ec144c4ed" a := &Artifact{ ImageId: "b8cdf55b-c916-40bd-b190-389ec144c4ed", } result := a.String() - assert.Equal(result, expected, "should match output") + if result != expected { + t.Fatalf("bad: %s", result) + } } diff --git a/builder/openstack/builder.go b/builder/openstack/builder.go index 95204dab6..83c5e0b15 100644 --- a/builder/openstack/builder.go +++ b/builder/openstack/builder.go @@ -51,7 +51,7 @@ func (b *Builder) Prepare(raws ...interface{}) error { return errs } - log.Printf("Config: %+v", b.config) + log.Println(common.ScrubConfig(b.config), b.config.Password) return nil } diff --git a/builder/openstack/step_key_pair.go b/builder/openstack/step_key_pair.go index a67579976..b9ffd5f4e 100644 --- a/builder/openstack/step_key_pair.go +++ b/builder/openstack/step_key_pair.go @@ -1,10 +1,9 @@ package openstack import ( - "cgl.tideland.biz/identifier" - "encoding/hex" "fmt" "github.com/mitchellh/multistep" + "github.com/mitchellh/packer/common/uuid" "github.com/mitchellh/packer/packer" "github.com/rackspace/gophercloud" "log" @@ -19,7 +18,7 @@ func (s *StepKeyPair) Run(state multistep.StateBag) multistep.StepAction { ui := state.Get("ui").(packer.Ui) ui.Say("Creating temporary keypair for this instance...") - keyName := fmt.Sprintf("packer %s", hex.EncodeToString(identifier.NewUUID().Raw())) + keyName := fmt.Sprintf("packer %s", uuid.TimeOrderedUUID()) log.Printf("temporary keypair name: %s", keyName) keyResp, err := csp.CreateKeyPair(gophercloud.NewKeyPair{Name: keyName}) if err != nil { diff --git a/builder/virtualbox/step_export.go b/builder/virtualbox/step_export.go index fd7282c67..726af7937 100644 --- a/builder/virtualbox/step_export.go +++ b/builder/virtualbox/step_export.go @@ -4,7 +4,9 @@ import ( "fmt" "github.com/mitchellh/multistep" "github.com/mitchellh/packer/packer" + "log" "path/filepath" + "time" ) // This step cleans up forwarded ports and exports the VM to an OVF. @@ -21,6 +23,10 @@ func (s *stepExport) Run(state multistep.StateBag) multistep.StepAction { ui := state.Get("ui").(packer.Ui) vmName := state.Get("vmName").(string) + // Wait a second to ensure VM is really shutdown. + log.Println("1 second timeout to ensure VM is really shutdown") + time.Sleep(1 * time.Second) + // Clear out the Packer-created forwarding rule ui.Say("Preparing to export machine...") ui.Message(fmt.Sprintf("Deleting forwarded port mapping for SSH (host port %d)", state.Get("sshHostPort"))) diff --git a/command/build/command_test.go b/command/build/command_test.go index 33559cfc5..2edd82b4a 100644 --- a/command/build/command_test.go +++ b/command/build/command_test.go @@ -2,7 +2,6 @@ package build import ( "bytes" - "cgl.tideland.biz/asserts" "github.com/mitchellh/packer/packer" "testing" ) @@ -23,33 +22,33 @@ func testEnvironment() packer.Environment { } func TestCommand_Implements(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - - var actual packer.Command - assert.Implementor(new(Command), &actual, "should be a Command") + var _ packer.Command = new(Command) } func TestCommand_Run_NoArgs(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) command := new(Command) result := command.Run(testEnvironment(), make([]string, 0)) - assert.Equal(result, 1, "no args should error") + if result != 1 { + t.Fatalf("bad: %d", result) + } } func TestCommand_Run_MoreThanOneArg(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) command := new(Command) args := []string{"one", "two"} result := command.Run(testEnvironment(), args) - assert.Equal(result, 1, "More than one arg should fail") + if result != 1 { + t.Fatalf("bad: %d", result) + } } func TestCommand_Run_MissingFile(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) command := new(Command) args := []string{"i-better-not-exist"} result := command.Run(testEnvironment(), args) - assert.Equal(result, 1, "a non-existent file should error") + if result != 1 { + t.Fatalf("bad: %d", result) + } } diff --git a/common/config.go b/common/config.go index b579562d5..460eeabc7 100644 --- a/common/config.go +++ b/common/config.go @@ -12,6 +12,16 @@ import ( "strings" ) +// ScrubConfig is a helper that returns a string representation of +// any struct with the given values stripped out. +func ScrubConfig(target interface{}, values ...string) string { + conf := fmt.Sprintf("Config: %+v", target) + for _, value := range values { + conf = strings.Replace(conf, value, "", -1) + } + return conf +} + // CheckUnusedConfig is a helper that makes sure that the there are no // unused configuration keys, properly ignoring keys that don't matter. func CheckUnusedConfig(md *mapstructure.Metadata) *packer.MultiError { diff --git a/common/config_test.go b/common/config_test.go index e7f469bcc..ea994de51 100644 --- a/common/config_test.go +++ b/common/config_test.go @@ -159,3 +159,20 @@ func TestDownloadableURL_FilePaths(t *testing.T) { } } } + +func TestScrubConfig(t *testing.T) { + type Inner struct { + Baz string + } + type Local struct { + Foo string + Bar string + Inner + } + c := Local{"foo", "bar", Inner{"bar"}} + expect := "Config: {Foo:foo Bar: Inner:{Baz:}}" + conf := ScrubConfig(c, c.Bar) + if conf != expect { + t.Fatalf("got %s, expected %s", conf, expect) + } +} diff --git a/common/uuid/uuid.go b/common/uuid/uuid.go new file mode 100644 index 000000000..496a2f6ef --- /dev/null +++ b/common/uuid/uuid.go @@ -0,0 +1,23 @@ +package uuid + +import ( + "fmt" + "math/rand" + "time" +) + +// Generates a time ordered UUID. Top 32 bits are a timestamp, +// bottom 96 are random. +func TimeOrderedUUID() string { + unix := uint32(time.Now().UTC().Unix()) + rand1 := rand.Uint32() + rand2 := rand.Uint32() + rand3 := rand.Uint32() + return fmt.Sprintf("%08x-%04x-%04x-%04x-%04x%08x", + unix, + uint16(rand1>>16), + uint16(rand1&0xffff), + uint16(rand2>>16), + uint16(rand2&0xffff), + rand3) +} diff --git a/common/uuid/uuid_test.go b/common/uuid/uuid_test.go new file mode 100644 index 000000000..8a853f1be --- /dev/null +++ b/common/uuid/uuid_test.go @@ -0,0 +1,12 @@ +package uuid + +import ( + "testing" +) + +func TestTimeOrderedUuid(t *testing.T) { + uuid := TimeOrderedUUID() + if len(uuid) != 36 { + t.Fatalf("bad: %s", uuid) + } +} diff --git a/communicator/ssh/communicator.go b/communicator/ssh/communicator.go index abdc46461..780dc425a 100644 --- a/communicator/ssh/communicator.go +++ b/communicator/ssh/communicator.go @@ -238,6 +238,14 @@ func (c *comm) reconnect() (err error) { log.Printf("reconnecting to TCP connection for SSH") c.conn, err = c.config.Connection() if err != nil { + // Explicitly set this to the REAL nil. Connection() can return + // a nil implementation of net.Conn which will make the + // "if c.conn == nil" check fail above. Read here for more information + // on this psychotic language feature: + // + // http://golang.org/doc/faq#nil_error + c.conn = nil + log.Printf("reconnection error: %s", err) return } diff --git a/packer/build_test.go b/packer/build_test.go index d88218513..7ada5d7d8 100644 --- a/packer/build_test.go +++ b/packer/build_test.go @@ -1,7 +1,6 @@ package packer import ( - "cgl.tideland.biz/asserts" "reflect" "testing" ) @@ -41,32 +40,43 @@ func testDefaultPackerConfig() map[string]interface{} { } } func TestBuild_Name(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - build := testBuild() - assert.Equal(build.Name(), "test", "should have a name") + if build.Name() != "test" { + t.Fatalf("bad: %s", build.Name()) + } } func TestBuild_Prepare(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) packerConfig := testDefaultPackerConfig() build := testBuild() builder := build.builder.(*TestBuilder) build.Prepare(nil) - assert.True(builder.prepareCalled, "prepare should be called") - assert.Equal(builder.prepareConfig, []interface{}{42, packerConfig}, "prepare config should be 42") + if !builder.prepareCalled { + t.Fatal("should be called") + } + if !reflect.DeepEqual(builder.prepareConfig, []interface{}{42, packerConfig}) { + t.Fatalf("bad: %#v", builder.prepareConfig) + } coreProv := build.provisioners[0] prov := coreProv.provisioner.(*MockProvisioner) - assert.True(prov.PrepCalled, "prepare should be called") - assert.Equal(prov.PrepConfigs, []interface{}{42, packerConfig}, "prepare should be called with proper config") + if !prov.PrepCalled { + t.Fatal("prep should be called") + } + if !reflect.DeepEqual(prov.PrepConfigs, []interface{}{42, packerConfig}) { + t.Fatalf("bad: %#v", prov.PrepConfigs) + } corePP := build.postProcessors[0][0] pp := corePP.processor.(*TestPostProcessor) - assert.True(pp.configCalled, "config should be called") - assert.Equal(pp.configVal, []interface{}{make(map[string]interface{}), packerConfig}, "config should have right value") + if !pp.configCalled { + t.Fatal("should be called") + } + if !reflect.DeepEqual(pp.configVal, []interface{}{make(map[string]interface{}), packerConfig}) { + t.Fatalf("bad: %#v", pp.configVal) + } } func TestBuild_Prepare_Twice(t *testing.T) { @@ -90,8 +100,6 @@ func TestBuild_Prepare_Twice(t *testing.T) { } func TestBuild_Prepare_Debug(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - packerConfig := testDefaultPackerConfig() packerConfig[DebugConfigKey] = true @@ -100,13 +108,21 @@ func TestBuild_Prepare_Debug(t *testing.T) { build.SetDebug(true) build.Prepare(nil) - assert.True(builder.prepareCalled, "prepare should be called") - assert.Equal(builder.prepareConfig, []interface{}{42, packerConfig}, "prepare config should be 42") + if !builder.prepareCalled { + t.Fatalf("should be called") + } + if !reflect.DeepEqual(builder.prepareConfig, []interface{}{42, packerConfig}) { + t.Fatalf("bad: %#v", builder.prepareConfig) + } coreProv := build.provisioners[0] prov := coreProv.provisioner.(*MockProvisioner) - assert.True(prov.PrepCalled, "prepare should be called") - assert.Equal(prov.PrepConfigs, []interface{}{42, packerConfig}, "prepare should be called with proper config") + if !prov.PrepCalled { + t.Fatal("prepare should be called") + } + if !reflect.DeepEqual(prov.PrepConfigs, []interface{}{42, packerConfig}) { + t.Fatalf("bad: %#v", prov.PrepConfigs) + } } func TestBuildPrepare_variables_default(t *testing.T) { @@ -186,37 +202,49 @@ func TestBuildPrepare_variablesRequired(t *testing.T) { } func TestBuild_Run(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - cache := &TestCache{} ui := testUi() build := testBuild() build.Prepare(nil) artifacts, err := build.Run(ui, cache) - assert.Nil(err, "should not error") - assert.Equal(len(artifacts), 2, "should have two artifacts") + if err != nil { + t.Fatalf("err: %s", err) + } + if len(artifacts) != 2 { + t.Fatalf("bad: %#v", artifacts) + } // Verify builder was run builder := build.builder.(*TestBuilder) - assert.True(builder.runCalled, "run should be called") + if !builder.runCalled { + t.Fatal("should be called") + } // Verify hooks are disapatchable dispatchHook := builder.runHook dispatchHook.Run("foo", nil, nil, 42) hook := build.hooks["foo"][0].(*MockHook) - assert.True(hook.RunCalled, "run should be called") - assert.Equal(hook.RunData, 42, "should have correct data") + if !hook.RunCalled { + t.Fatal("should be called") + } + if hook.RunData != 42 { + t.Fatalf("bad: %#v", hook.RunData) + } // Verify provisioners run dispatchHook.Run(HookProvision, nil, nil, 42) prov := build.provisioners[0].provisioner.(*MockProvisioner) - assert.True(prov.ProvCalled, "provision should be called") + if !prov.ProvCalled { + t.Fatal("should be called") + } // Verify post-processor was run pp := build.postProcessors[0][0].processor.(*TestPostProcessor) - assert.True(pp.ppCalled, "post processor should be called") + if !pp.ppCalled { + t.Fatal("should be called") + } } func TestBuild_Run_Artifacts(t *testing.T) { @@ -356,23 +384,26 @@ func TestBuild_Run_Artifacts(t *testing.T) { } func TestBuild_RunBeforePrepare(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - defer func() { p := recover() - assert.NotNil(p, "should panic") - assert.Equal(p.(string), "Prepare must be called first", "right panic") + if p == nil { + t.Fatal("should panic") + } + + if p.(string) != "Prepare must be called first" { + t.Fatalf("bad: %s", p.(string)) + } }() testBuild().Run(testUi(), &TestCache{}) } func TestBuild_Cancel(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - build := testBuild() build.Cancel() builder := build.builder.(*TestBuilder) - assert.True(builder.cancelCalled, "cancel should be called") + if !builder.cancelCalled { + t.Fatal("cancel should be called") + } } diff --git a/packer/config_template.go b/packer/config_template.go index 895e11682..98dde878d 100644 --- a/packer/config_template.go +++ b/packer/config_template.go @@ -2,9 +2,8 @@ package packer import ( "bytes" - "cgl.tideland.biz/identifier" - "encoding/hex" "fmt" + "github.com/mitchellh/packer/common/uuid" "strconv" "text/template" "time" @@ -94,5 +93,5 @@ func templateTimestamp() string { } func templateUuid() string { - return hex.EncodeToString(identifier.NewUUID().Raw()) + return uuid.TimeOrderedUUID() } diff --git a/packer/config_template_test.go b/packer/config_template_test.go index 317732f0f..dad1b0dc8 100644 --- a/packer/config_template_test.go +++ b/packer/config_template_test.go @@ -80,7 +80,7 @@ func TestConfigTemplateProcess_uuid(t *testing.T) { t.Fatalf("err: %s", err) } - if len(result) != 32 { + if len(result) != 36 { t.Fatalf("err: %s", result) } } diff --git a/packer/environment_test.go b/packer/environment_test.go index 6cda3f7d2..1a4751281 100644 --- a/packer/environment_test.go +++ b/packer/environment_test.go @@ -2,12 +2,11 @@ package packer import ( "bytes" - "cgl.tideland.biz/asserts" "errors" - "fmt" "io/ioutil" "log" "os" + "reflect" "strings" "testing" ) @@ -44,40 +43,48 @@ func testEnvironment() Environment { } func TestEnvironment_DefaultConfig_Commands(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - config := DefaultEnvironmentConfig() - assert.Empty(config.Commands, "should have no commands") + if len(config.Commands) != 0 { + t.Fatalf("bad: %#v", config.Commands) + } } func TestEnvironment_DefaultConfig_Ui(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - config := DefaultEnvironmentConfig() - assert.NotNil(config.Ui, "default UI should not be nil") + if config.Ui == nil { + t.Fatal("config.Ui should not be nil") + } rwUi, ok := config.Ui.(*BasicUi) - assert.True(ok, "default UI should be BasicUi") - assert.Equal(rwUi.Writer, os.Stdout, "default UI should go to stdout") - assert.Equal(rwUi.Reader, os.Stdin, "default UI should read from stdin") + if !ok { + t.Fatal("default UI should be BasicUi") + } + if rwUi.Writer != os.Stdout { + t.Fatal("default UI should go to stdout") + } + if rwUi.Reader != os.Stdin { + t.Fatal("default UI reader should go to stdin") + } } func TestNewEnvironment_NoConfig(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - env, err := NewEnvironment(nil) - assert.Nil(env, "env should be nil") - assert.NotNil(err, "should be an error") + if env != nil { + t.Fatal("env should be nil") + } + if err == nil { + t.Fatal("should have error") + } } func TestEnvironment_NilComponents(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - config := DefaultEnvironmentConfig() config.Components = *new(ComponentFinder) env, err := NewEnvironment(config) - assert.Nil(err, "should not have an error") + if err != nil { + t.Fatalf("err: %s", err) + } // All of these should not cause panics... so we don't assert // anything but if there is a panic in the test then yeah, something @@ -90,8 +97,6 @@ func TestEnvironment_NilComponents(t *testing.T) { } func TestEnvironment_Builder(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - builder := &TestBuilder{} builders := make(map[string]Builder) builders["foo"] = builder @@ -101,33 +106,43 @@ func TestEnvironment_Builder(t *testing.T) { env, _ := NewEnvironment(config) returnedBuilder, err := env.Builder("foo") - assert.Nil(err, "should be no error") - assert.Equal(returnedBuilder, builder, "should return correct builder") + if err != nil { + t.Fatalf("err: %s", err) + } + if returnedBuilder != builder { + t.Fatalf("bad: %#v", returnedBuilder) + } } func TestEnvironment_Builder_NilError(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - config := DefaultEnvironmentConfig() config.Components.Builder = func(n string) (Builder, error) { return nil, nil } env, _ := NewEnvironment(config) returnedBuilder, err := env.Builder("foo") - assert.NotNil(err, "should be an error") - assert.Nil(returnedBuilder, "should be no builder") + if err == nil { + t.Fatal("should have error") + } + if returnedBuilder != nil { + t.Fatalf("bad: %#v", returnedBuilder) + } } func TestEnvironment_Builder_Error(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - config := DefaultEnvironmentConfig() config.Components.Builder = func(n string) (Builder, error) { return nil, errors.New("foo") } env, _ := NewEnvironment(config) returnedBuilder, err := env.Builder("foo") - assert.NotNil(err, "should be an error") - assert.Equal(err.Error(), "foo", "should be correct error") - assert.Nil(returnedBuilder, "should be no builder") + if err == nil { + t.Fatal("should have error") + } + if err.Error() != "foo" { + t.Fatalf("bad err: %s", err) + } + if returnedBuilder != nil { + t.Fatalf("should be nil: %#v", returnedBuilder) + } } func TestEnvironment_Cache(t *testing.T) { @@ -139,20 +154,20 @@ func TestEnvironment_Cache(t *testing.T) { } func TestEnvironment_Cli_Error(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - config := DefaultEnvironmentConfig() config.Components.Command = func(n string) (Command, error) { return nil, errors.New("foo") } env, _ := NewEnvironment(config) _, err := env.Cli([]string{"foo"}) - assert.NotNil(err, "should be an error") - assert.Equal(err.Error(), "foo", "should be correct error") + if err == nil { + t.Fatal("should have error") + } + if err.Error() != "foo" { + t.Fatalf("bad: %s", err) + } } func TestEnvironment_Cli_CallsRun(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - command := &TestCommand{} commands := make(map[string]Command) commands["foo"] = command @@ -163,25 +178,33 @@ func TestEnvironment_Cli_CallsRun(t *testing.T) { env, _ := NewEnvironment(config) exitCode, err := env.Cli([]string{"foo", "bar", "baz"}) - assert.Nil(err, "should be no error") - assert.Equal(exitCode, 0, "runs foo command") - assert.True(command.runCalled, "run should've been called") - assert.Equal(command.runEnv, env, "should've ran with env") - assert.Equal(command.runArgs, []string{"bar", "baz"}, "should have right args") + if err != nil { + t.Fatalf("err: %s", err) + } + if exitCode != 0 { + t.Fatalf("bad: %d", exitCode) + } + if !command.runCalled { + t.Fatal("command should be run") + } + if command.runEnv != env { + t.Fatalf("bad env: %#v", command.runEnv) + } + if !reflect.DeepEqual(command.runArgs, []string{"bar", "baz"}) { + t.Fatalf("bad: %#v", command.runArgs) + } } func TestEnvironment_DefaultCli_Empty(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - defaultEnv := testEnvironment() exitCode, _ := defaultEnv.Cli([]string{}) - assert.Equal(exitCode, 1, "CLI with no args") + if exitCode != 1 { + t.Fatalf("bad: %d", exitCode) + } } func TestEnvironment_DefaultCli_Help(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - defaultEnv := testEnvironment() // A little lambda to help us test the output actually contains help @@ -189,44 +212,52 @@ func TestEnvironment_DefaultCli_Help(t *testing.T) { buffer := defaultEnv.Ui().(*BasicUi).Writer.(*bytes.Buffer) output := buffer.String() buffer.Reset() - assert.True(strings.Contains(output, "usage: packer"), "should print help") + if !strings.Contains(output, "usage: packer") { + t.Fatalf("should contain help: %#v", output) + } } // Test "--help" exitCode, _ := defaultEnv.Cli([]string{"--help"}) - assert.Equal(exitCode, 1, "--help should print") + if exitCode != 1 { + t.Fatalf("bad: %d", exitCode) + } testOutput() // Test "-h" exitCode, _ = defaultEnv.Cli([]string{"--help"}) - assert.Equal(exitCode, 1, "--help should print") + if exitCode != 1 { + t.Fatalf("bad: %d", exitCode) + } testOutput() } func TestEnvironment_DefaultCli_Version(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - defaultEnv := testEnvironment() versionCommands := []string{"version", "--version", "-v"} for _, command := range versionCommands { exitCode, _ := defaultEnv.Cli([]string{command}) - assert.Equal(exitCode, 0, fmt.Sprintf("%s should work", command)) + if exitCode != 0 { + t.Fatalf("bad: %d", exitCode) + } // Test the --version and -v can appear anywhere exitCode, _ = defaultEnv.Cli([]string{"bad", command}) if command != "version" { - assert.Equal(exitCode, 0, fmt.Sprintf("%s should work anywhere", command)) + if exitCode != 0 { + t.Fatalf("bad: %d", exitCode) + } } else { - assert.Equal(exitCode, 1, fmt.Sprintf("%s should NOT work anywhere", command)) + if exitCode != 1 { + t.Fatalf("bad: %d", exitCode) + } } } } func TestEnvironment_Hook(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - hook := &MockHook{} hooks := make(map[string]Hook) hooks["foo"] = hook @@ -236,38 +267,46 @@ func TestEnvironment_Hook(t *testing.T) { env, _ := NewEnvironment(config) returned, err := env.Hook("foo") - assert.Nil(err, "should be no error") - assert.Equal(returned, hook, "should return correct hook") + if err != nil { + t.Fatalf("err: %s", err) + } + if returned != hook { + t.Fatalf("bad: %#v", returned) + } } func TestEnvironment_Hook_NilError(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - config := DefaultEnvironmentConfig() config.Components.Hook = func(n string) (Hook, error) { return nil, nil } env, _ := NewEnvironment(config) returned, err := env.Hook("foo") - assert.NotNil(err, "should be an error") - assert.Nil(returned, "should be no hook") + if err == nil { + t.Fatal("should have error") + } + if returned != nil { + t.Fatalf("bad: %#v", returned) + } } func TestEnvironment_Hook_Error(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - config := DefaultEnvironmentConfig() config.Components.Hook = func(n string) (Hook, error) { return nil, errors.New("foo") } env, _ := NewEnvironment(config) returned, err := env.Hook("foo") - assert.NotNil(err, "should be an error") - assert.Equal(err.Error(), "foo", "should be correct error") - assert.Nil(returned, "should be no hook") + if err == nil { + t.Fatal("should have error") + } + if err.Error() != "foo" { + t.Fatalf("err: %s", err) + } + if returned != nil { + t.Fatalf("bad: %#v", returned) + } } func TestEnvironment_PostProcessor(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - pp := &TestPostProcessor{} pps := make(map[string]PostProcessor) pps["foo"] = pp @@ -277,38 +316,46 @@ func TestEnvironment_PostProcessor(t *testing.T) { env, _ := NewEnvironment(config) returned, err := env.PostProcessor("foo") - assert.Nil(err, "should be no error") - assert.Equal(returned, pp, "should return correct pp") + if err != nil { + t.Fatalf("err: %s", err) + } + if returned != pp { + t.Fatalf("bad: %#v", returned) + } } func TestEnvironment_PostProcessor_NilError(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - config := DefaultEnvironmentConfig() config.Components.PostProcessor = func(n string) (PostProcessor, error) { return nil, nil } env, _ := NewEnvironment(config) returned, err := env.PostProcessor("foo") - assert.NotNil(err, "should be an error") - assert.Nil(returned, "should be no pp") + if err == nil { + t.Fatal("should have error") + } + if returned != nil { + t.Fatalf("bad: %#v", returned) + } } func TestEnvironment_PostProcessor_Error(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - config := DefaultEnvironmentConfig() config.Components.PostProcessor = func(n string) (PostProcessor, error) { return nil, errors.New("foo") } env, _ := NewEnvironment(config) returned, err := env.PostProcessor("foo") - assert.NotNil(err, "should be an error") - assert.Equal(err.Error(), "foo", "should be correct error") - assert.Nil(returned, "should be no pp") + if err == nil { + t.Fatal("should be an error") + } + if err.Error() != "foo" { + t.Fatalf("bad err: %s", err) + } + if returned != nil { + t.Fatalf("bad: %#v", returned) + } } func TestEnvironmentProvisioner(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - p := &MockProvisioner{} ps := make(map[string]Provisioner) ps["foo"] = p @@ -318,25 +365,29 @@ func TestEnvironmentProvisioner(t *testing.T) { env, _ := NewEnvironment(config) returned, err := env.Provisioner("foo") - assert.Nil(err, "should be no error") - assert.Equal(returned, p, "should return correct provisioner") + if err != nil { + t.Fatalf("err: %s", err) + } + if returned != p { + t.Fatalf("bad: %#v", returned) + } } func TestEnvironmentProvisioner_NilError(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - config := DefaultEnvironmentConfig() config.Components.Provisioner = func(n string) (Provisioner, error) { return nil, nil } env, _ := NewEnvironment(config) returned, err := env.Provisioner("foo") - assert.NotNil(err, "should be an error") - assert.Nil(returned, "should be no provisioner") + if err == nil { + t.Fatal("should have error") + } + if returned != nil { + t.Fatalf("bad: %#v", returned) + } } func TestEnvironmentProvisioner_Error(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - config := DefaultEnvironmentConfig() config.Components.Provisioner = func(n string) (Provisioner, error) { return nil, errors.New("foo") @@ -344,14 +395,18 @@ func TestEnvironmentProvisioner_Error(t *testing.T) { env, _ := NewEnvironment(config) returned, err := env.Provisioner("foo") - assert.NotNil(err, "should be an error") - assert.Equal(err.Error(), "foo", "should be correct error") - assert.Nil(returned, "should be no provisioner") + if err == nil { + t.Fatal("should have error") + } + if err.Error() != "foo" { + t.Fatalf("err: %s", err) + } + if returned != nil { + t.Fatalf("bad: %#v", returned) + } } func TestEnvironment_SettingUi(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - ui := &BasicUi{ Reader: new(bytes.Buffer), Writer: new(bytes.Buffer), @@ -362,5 +417,7 @@ func TestEnvironment_SettingUi(t *testing.T) { env, _ := NewEnvironment(config) - assert.Equal(env.Ui(), ui, "UIs should be equal") + if env.Ui() != ui { + t.Fatalf("UI should be equal: %#v", env.Ui()) + } } diff --git a/packer/hook_test.go b/packer/hook_test.go index bf88e65df..1106ee961 100644 --- a/packer/hook_test.go +++ b/packer/hook_test.go @@ -1,7 +1,6 @@ package packer import ( - "cgl.tideland.biz/asserts" "sync" "testing" "time" @@ -42,12 +41,7 @@ func (h *CancelHook) Cancel() { } func TestDispatchHook_Implements(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - - var r Hook - c := &DispatchHook{} - - assert.Implementor(c, &r, "should be a Hook") + var _ Hook = new(DispatchHook) } func TestDispatchHook_Run_NoHooks(t *testing.T) { @@ -57,8 +51,6 @@ func TestDispatchHook_Run_NoHooks(t *testing.T) { } func TestDispatchHook_Run(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - hook := &MockHook{} mapping := make(map[string][]Hook) @@ -66,9 +58,15 @@ func TestDispatchHook_Run(t *testing.T) { dh := &DispatchHook{Mapping: mapping} dh.Run("foo", nil, nil, 42) - assert.True(hook.RunCalled, "run should be called") - assert.Equal(hook.RunName, "foo", "should be proper event") - assert.Equal(hook.RunData, 42, "should be correct data") + if !hook.RunCalled { + t.Fatal("should be called") + } + if hook.RunName != "foo" { + t.Fatalf("bad: %s", hook.RunName) + } + if hook.RunData != 42 { + t.Fatalf("bad: %#v", hook.RunData) + } } func TestDispatchHook_cancel(t *testing.T) { diff --git a/packer/multi_error_test.go b/packer/multi_error_test.go index be28f25c7..05463e690 100644 --- a/packer/multi_error_test.go +++ b/packer/multi_error_test.go @@ -1,7 +1,6 @@ package packer import ( - "cgl.tideland.biz/asserts" "errors" "testing" ) @@ -15,8 +14,6 @@ func TestMultiError_Impl(t *testing.T) { } func TestMultiErrorError(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - expected := `2 error(s) occurred: * foo @@ -28,7 +25,9 @@ func TestMultiErrorError(t *testing.T) { } multi := &MultiError{errors} - assert.Equal(multi.Error(), expected, "should have proper error") + if multi.Error() != expected { + t.Fatalf("bad: %s", multi.Error()) + } } func TestMultiErrorAppend_MultiError(t *testing.T) { diff --git a/packer/rpc/artifact_test.go b/packer/rpc/artifact_test.go index bc2f88a19..336fa6d8b 100644 --- a/packer/rpc/artifact_test.go +++ b/packer/rpc/artifact_test.go @@ -1,9 +1,9 @@ package rpc import ( - "cgl.tideland.biz/asserts" "github.com/mitchellh/packer/packer" "net/rpc" + "reflect" "testing" ) @@ -30,8 +30,6 @@ func (testArtifact) Destroy() error { } func TestArtifactRPC(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - // Create the interface to test a := new(testArtifact) @@ -42,21 +40,29 @@ func TestArtifactRPC(t *testing.T) { // Create the client over RPC and run some methods to verify it works client, err := rpc.Dial("tcp", address) - assert.Nil(err, "should be able to connect") + if err != nil { + t.Fatalf("err: %s", err) + } aClient := Artifact(client) // Test - assert.Equal(aClient.BuilderId(), "bid", "should have correct builder ID") - assert.Equal(aClient.Files(), []string{"a", "b"}, "should have correct builder ID") - assert.Equal(aClient.Id(), "id", "should have correct builder ID") - assert.Equal(aClient.String(), "string", "should have correct builder ID") + if aClient.BuilderId() != "bid" { + t.Fatalf("bad: %s", aClient.BuilderId()) + } + + if !reflect.DeepEqual(aClient.Files(), []string{"a", "b"}) { + t.Fatalf("bad: %#v", aClient.Files()) + } + + if aClient.Id() != "id" { + t.Fatalf("bad: %s", aClient.Id()) + } + + if aClient.String() != "string" { + t.Fatalf("bad: %s", aClient.String()) + } } func TestArtifact_Implements(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - - var r packer.Artifact - a := Artifact(nil) - - assert.Implementor(a, &r, "should be an Artifact") + var _ packer.Artifact = Artifact(nil) } diff --git a/packer/rpc/build_test.go b/packer/rpc/build_test.go index e8555ffff..bee9b6796 100644 --- a/packer/rpc/build_test.go +++ b/packer/rpc/build_test.go @@ -1,7 +1,6 @@ package rpc import ( - "cgl.tideland.biz/asserts" "errors" "github.com/mitchellh/packer/packer" "net/rpc" @@ -60,8 +59,6 @@ func (b *testBuild) Cancel() { } func TestBuildRPC(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - // Create the interface to test b := new(testBuild) @@ -72,16 +69,23 @@ func TestBuildRPC(t *testing.T) { // Create the client over RPC and run some methods to verify it works client, err := rpc.Dial("tcp", address) - assert.Nil(err, "should be able to connect") + if err != nil { + t.Fatalf("err: %s", err) + } bClient := Build(client) // Test Name bClient.Name() - assert.True(b.nameCalled, "name should be called") + if !b.nameCalled { + t.Fatal("name should be called") + } // Test Prepare bClient.Prepare(map[string]string{"foo": "bar"}) - assert.True(b.prepareCalled, "prepare should be called") + if !b.prepareCalled { + t.Fatal("prepare should be called") + } + if len(b.prepareVars) != 1 { t.Fatalf("bad vars: %#v", b.prepareVars) } @@ -94,44 +98,65 @@ func TestBuildRPC(t *testing.T) { cache := new(testCache) ui := new(testUi) artifacts, err := bClient.Run(ui, cache) - assert.True(b.runCalled, "run should be called") - assert.Nil(err, "should not error") - assert.Equal(len(artifacts), 1, "should have one artifact") - assert.Equal(artifacts[0].BuilderId(), "bid", "should have proper builder id") + if !b.runCalled { + t.Fatal("run should be called") + } + + if err != nil { + t.Fatalf("err: %s", err) + } + + if len(artifacts) != 1 { + t.Fatalf("bad: %#v", artifacts) + } + + if artifacts[0].BuilderId() != "bid" { + t.Fatalf("bad: %#v", artifacts) + } // Test the UI given to run, which should be fully functional if b.runCalled { b.runCache.Lock("foo") - assert.True(cache.lockCalled, "lock should be called") + if !cache.lockCalled { + t.Fatal("lock shuld be called") + } b.runUi.Say("format") - assert.True(ui.sayCalled, "say should be called") - assert.Equal(ui.sayMessage, "format", "message should be correct") + if !ui.sayCalled { + t.Fatal("say should be called") + } + + if ui.sayMessage != "format" { + t.Fatalf("bad: %#v", ui.sayMessage) + } } // Test run with an error b.errRunResult = true _, err = bClient.Run(ui, cache) - assert.NotNil(err, "should not nil") + if err == nil { + t.Fatal("should error") + } // Test SetDebug bClient.SetDebug(true) - assert.True(b.setDebugCalled, "should be called") + if !b.setDebugCalled { + t.Fatal("should be called") + } // Test SetForce bClient.SetForce(true) - assert.True(b.setForceCalled, "should be called") + if !b.setForceCalled { + t.Fatal("should be called") + } // Test Cancel bClient.Cancel() - assert.True(b.cancelCalled, "cancel should be called") + if !b.cancelCalled { + t.Fatal("should be called") + } } func TestBuild_ImplementsBuild(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - - var realBuild packer.Build - b := Build(nil) - - assert.Implementor(b, &realBuild, "should be a Build") + var _ packer.Build = Build(nil) } diff --git a/packer/rpc/builder_test.go b/packer/rpc/builder_test.go index 5235de9b5..6ce8df78e 100644 --- a/packer/rpc/builder_test.go +++ b/packer/rpc/builder_test.go @@ -1,10 +1,10 @@ package rpc import ( - "cgl.tideland.biz/asserts" "errors" "github.com/mitchellh/packer/packer" "net/rpc" + "reflect" "testing" ) @@ -49,8 +49,6 @@ func (b *testBuilder) Cancel() { } func TestBuilderRPC(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - // Create the interface to test b := new(testBuilder) @@ -61,60 +59,88 @@ func TestBuilderRPC(t *testing.T) { // Create the client over RPC and run some methods to verify it works client, err := rpc.Dial("tcp", address) - assert.Nil(err, "should be able to connect") + if err != nil { + t.Fatalf("err: %s", err) + } // Test Prepare config := 42 bClient := Builder(client) bClient.Prepare(config) - assert.True(b.prepareCalled, "prepare should be called") - assert.Equal(b.prepareConfig, []interface{}{42}, "prepare should be called with right arg") + if !b.prepareCalled { + t.Fatal("should be called") + } + + if !reflect.DeepEqual(b.prepareConfig, []interface{}{42}) { + t.Fatalf("bad: %#v", b.prepareConfig) + } // Test Run cache := new(testCache) hook := &packer.MockHook{} ui := &testUi{} artifact, err := bClient.Run(ui, hook, cache) - assert.Nil(err, "should have no error") - assert.True(b.runCalled, "runs hould be called") + if err != nil { + t.Fatalf("err: %s", err) + } + + if !b.runCalled { + t.Fatal("run should be called") + } if b.runCalled { b.runCache.Lock("foo") - assert.True(cache.lockCalled, "lock should be called") + if !cache.lockCalled { + t.Fatal("should be called") + } b.runHook.Run("foo", nil, nil, nil) - assert.True(hook.RunCalled, "run should be called") + if !hook.RunCalled { + t.Fatal("should be called") + } b.runUi.Say("format") - assert.True(ui.sayCalled, "say should be called") - assert.Equal(ui.sayMessage, "format", "message should be correct") + if !ui.sayCalled { + t.Fatal("say should be called") + } - assert.Equal(artifact.Id(), testBuilderArtifact.Id(), "should have artifact Id") + if ui.sayMessage != "format" { + t.Fatalf("bad: %s", ui.sayMessage) + } + + if artifact.Id() != testBuilderArtifact.Id() { + t.Fatalf("bad: %s", artifact.Id()) + } } // Test run with nil result b.nilRunResult = true artifact, err = bClient.Run(ui, hook, cache) - assert.Nil(artifact, "should be nil") - assert.Nil(err, "should have no error") + if artifact != nil { + t.Fatalf("bad: %#v", artifact) + } + if err != nil { + t.Fatalf("bad: %#v", err) + } // Test with an error b.errRunResult = true b.nilRunResult = false artifact, err = bClient.Run(ui, hook, cache) - assert.Nil(artifact, "should be nil") - assert.NotNil(err, "should have error") + if artifact != nil { + t.Fatalf("bad: %#v", artifact) + } + if err == nil { + t.Fatal("should have error") + } // Test Cancel bClient.Cancel() - assert.True(b.cancelCalled, "cancel should be called") + if !b.cancelCalled { + t.Fatal("cancel should be called") + } } func TestBuilder_ImplementsBuilder(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - - var realBuilder packer.Builder - b := Builder(nil) - - assert.Implementor(b, &realBuilder, "should be a Builder") + var _ packer.Builder = Builder(nil) } diff --git a/packer/rpc/cache_test.go b/packer/rpc/cache_test.go index 9c74de74e..46cb81d08 100644 --- a/packer/rpc/cache_test.go +++ b/packer/rpc/cache_test.go @@ -1,7 +1,6 @@ package rpc import ( - "cgl.tideland.biz/asserts" "github.com/mitchellh/packer/packer" "net/rpc" "testing" @@ -49,8 +48,6 @@ func TestCache_Implements(t *testing.T) { } func TestCacheRPC(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - // Create the interface to test c := new(testCache) @@ -61,26 +58,44 @@ func TestCacheRPC(t *testing.T) { // Create the client over RPC and run some methods to verify it works rpcClient, err := rpc.Dial("tcp", address) - assert.Nil(err, "should be able to connect") + if err != nil { + t.Fatalf("bad: %s", err) + } client := Cache(rpcClient) // Test Lock client.Lock("foo") - assert.True(c.lockCalled, "should be called") - assert.Equal(c.lockKey, "foo", "should have proper key") + if !c.lockCalled { + t.Fatal("should be called") + } + if c.lockKey != "foo" { + t.Fatalf("bad: %s", c.lockKey) + } // Test Unlock client.Unlock("foo") - assert.True(c.unlockCalled, "should be called") - assert.Equal(c.unlockKey, "foo", "should have proper key") + if !c.unlockCalled { + t.Fatal("should be called") + } + if c.unlockKey != "foo" { + t.Fatalf("bad: %s", c.unlockKey) + } // Test RLock client.RLock("foo") - assert.True(c.rlockCalled, "should be called") - assert.Equal(c.rlockKey, "foo", "should have proper key") + if !c.rlockCalled { + t.Fatal("should be called") + } + if c.rlockKey != "foo" { + t.Fatalf("bad: %s", c.rlockKey) + } // Test RUnlock client.RUnlock("foo") - assert.True(c.runlockCalled, "should be called") - assert.Equal(c.runlockKey, "foo", "should have proper key") + if !c.runlockCalled { + t.Fatal("should be called") + } + if c.runlockKey != "foo" { + t.Fatalf("bad: %s", c.runlockKey) + } } diff --git a/packer/rpc/command_test.go b/packer/rpc/command_test.go index e27ae7c1c..086e0eeed 100644 --- a/packer/rpc/command_test.go +++ b/packer/rpc/command_test.go @@ -1,9 +1,9 @@ package rpc import ( - "cgl.tideland.biz/asserts" "github.com/mitchellh/packer/packer" "net/rpc" + "reflect" "testing" ) @@ -29,8 +29,6 @@ func (tc *TestCommand) Synopsis() string { } func TestRPCCommand(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - // Create the command command := new(TestCommand) @@ -42,37 +40,45 @@ func TestRPCCommand(t *testing.T) { // Create the command client over RPC and run some methods to verify // we get the proper behavior. client, err := rpc.Dial("tcp", address) - assert.Nil(err, "should be no error") + if err != nil { + t.Fatalf("err: %s", err) + } clientComm := Command(client) //Test Help help := clientComm.Help() - assert.Equal(help, "bar", "helps hould be correct") + if help != "bar" { + t.Fatalf("bad: %s", help) + } // Test run runArgs := []string{"foo", "bar"} testEnv := &testEnvironment{} exitCode := clientComm.Run(testEnv, runArgs) - assert.Equal(command.runArgs, runArgs, "Correct args should be sent") - assert.Equal(exitCode, 0, "Exit code should be correct") + if !reflect.DeepEqual(command.runArgs, runArgs) { + t.Fatalf("bad: %#v", command.runArgs) + } + if exitCode != 0 { + t.Fatalf("bad: %d", exitCode) + } - assert.NotNil(command.runEnv, "should have an env") - if command.runEnv != nil { - command.runEnv.Ui() - assert.True(testEnv.uiCalled, "UI should be called on env") + if command.runEnv == nil { + t.Fatal("runEnv should not be nil") + } + + command.runEnv.Ui() + if !testEnv.uiCalled { + t.Fatal("ui should be called") } // Test Synopsis synopsis := clientComm.Synopsis() - assert.Equal(synopsis, "foo", "Synopsis should be correct") + if synopsis != "foo" { + t.Fatalf("bad: %#v", synopsis) + } } func TestCommand_Implements(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - - var r packer.Command - c := Command(nil) - - assert.Implementor(c, &r, "should be a Builder") + var _ packer.Command = Command(nil) } diff --git a/packer/rpc/environment_test.go b/packer/rpc/environment_test.go index 18a755a65..39d020ce6 100644 --- a/packer/rpc/environment_test.go +++ b/packer/rpc/environment_test.go @@ -1,9 +1,9 @@ package rpc import ( - "cgl.tideland.biz/asserts" "github.com/mitchellh/packer/packer" "net/rpc" + "reflect" "testing" ) @@ -65,8 +65,6 @@ func (e *testEnvironment) Ui() packer.Ui { } func TestEnvironmentRPC(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - // Create the interface to test e := &testEnvironment{} @@ -77,49 +75,70 @@ func TestEnvironmentRPC(t *testing.T) { // Create the client over RPC and run some methods to verify it works client, err := rpc.Dial("tcp", address) - assert.Nil(err, "should be able to connect") + if err != nil { + t.Fatalf("err: %s", err) + } eClient := &Environment{client} // Test Builder builder, _ := eClient.Builder("foo") - assert.True(e.builderCalled, "Builder should be called") - assert.Equal(e.builderName, "foo", "Correct name for Builder") + if !e.builderCalled { + t.Fatal("builder should be called") + } + if e.builderName != "foo" { + t.Fatalf("bad: %#v", e.builderName) + } builder.Prepare(nil) - assert.True(testEnvBuilder.prepareCalled, "Prepare should be called") + if !testEnvBuilder.prepareCalled { + t.Fatal("should be called") + } // Test Cache cache := eClient.Cache() cache.Lock("foo") - assert.True(testEnvCache.lockCalled, "lock should be called") + if !testEnvCache.lockCalled { + t.Fatal("should be called") + } // Test Cli cliArgs := []string{"foo", "bar"} result, _ := eClient.Cli(cliArgs) - assert.True(e.cliCalled, "CLI should be called") - assert.Equal(e.cliArgs, cliArgs, "args should match") - assert.Equal(result, 42, "result shuld be 42") + if !e.cliCalled { + t.Fatal("should be called") + } + if !reflect.DeepEqual(e.cliArgs, cliArgs) { + t.Fatalf("bad: %#v", e.cliArgs) + } + if result != 42 { + t.Fatalf("bad: %#v", result) + } // Test Provisioner _, _ = eClient.Provisioner("foo") - assert.True(e.provCalled, "provisioner should be called") - assert.Equal(e.provName, "foo", "should have proper name") + if !e.provCalled { + t.Fatal("should be called") + } + if e.provName != "foo" { + t.Fatalf("bad: %s", e.provName) + } // Test Ui ui := eClient.Ui() - assert.True(e.uiCalled, "Ui should've been called") + if !e.uiCalled { + t.Fatal("should be called") + } // Test calls on the Ui ui.Say("format") - assert.True(testEnvUi.sayCalled, "Say should be called") - assert.Equal(testEnvUi.sayMessage, "format", "message should match") + if !testEnvUi.sayCalled { + t.Fatal("should be called") + } + if testEnvUi.sayMessage != "format" { + t.Fatalf("bad: %#v", testEnvUi.sayMessage) + } } func TestEnvironment_ImplementsEnvironment(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - - var realVar packer.Environment - e := &Environment{nil} - - assert.Implementor(e, &realVar, "should be an Environment") + var _ packer.Environment = new(Environment) } diff --git a/packer/rpc/error_test.go b/packer/rpc/error_test.go index af631f46a..8c5cbd7fa 100644 --- a/packer/rpc/error_test.go +++ b/packer/rpc/error_test.go @@ -1,25 +1,19 @@ package rpc import ( - "cgl.tideland.biz/asserts" "errors" "testing" ) func TestBasicError_ImplementsError(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - - var r error - e := &BasicError{""} - - assert.Implementor(e, &r, "should be an error") + var _ error = new(BasicError) } func TestBasicError_MatchesMessage(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - err := errors.New("foo") wrapped := NewBasicError(err) - assert.Equal(wrapped.Error(), err.Error(), "should have the same error") + if wrapped.Error() != err.Error() { + t.Fatalf("bad: %#v", wrapped.Error()) + } } diff --git a/packer/rpc/hook_test.go b/packer/rpc/hook_test.go index 1d226056a..c7ffc7258 100644 --- a/packer/rpc/hook_test.go +++ b/packer/rpc/hook_test.go @@ -1,7 +1,6 @@ package rpc import ( - "cgl.tideland.biz/asserts" "github.com/mitchellh/packer/packer" "net/rpc" "reflect" @@ -11,8 +10,6 @@ import ( ) func TestHookRPC(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - // Create the UI to test h := new(packer.MockHook) @@ -23,27 +20,28 @@ func TestHookRPC(t *testing.T) { // Create the client over RPC and run some methods to verify it works client, err := rpc.Dial("tcp", address) - assert.Nil(err, "should be able to connect") + if err != nil { + t.Fatalf("err: %s", err) + } hClient := Hook(client) // Test Run ui := &testUi{} hClient.Run("foo", ui, nil, 42) - assert.True(h.RunCalled, "run should be called") + if !h.RunCalled { + t.Fatal("should be called") + } // Test Cancel hClient.Cancel() - assert.True(h.CancelCalled, "cancel should be called") + if !h.CancelCalled { + t.Fatal("should be called") + } } func TestHook_Implements(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - - var r packer.Hook - h := &hook{nil} - - assert.Implementor(h, &r, "should be a Hook") + var _ packer.Hook = new(hook) } func TestHook_cancelWhileRun(t *testing.T) { diff --git a/packer/rpc/port_test.go b/packer/rpc/port_test.go index dc0e0878a..3e6afef40 100644 --- a/packer/rpc/port_test.go +++ b/packer/rpc/port_test.go @@ -1,7 +1,6 @@ package rpc import ( - "cgl.tideland.biz/asserts" "net" "strings" "testing" @@ -13,21 +12,27 @@ func addrPort(address net.Addr) string { } func Test_netListenerInRange(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - // Open up port 10000 so that we take up a port L1000, err := net.Listen("tcp", "127.0.0.1:11000") defer L1000.Close() - assert.Nil(err, "should be able to bind to port 10000") + if err != nil { + t.Fatalf("bad: %s", err) + } if err == nil { // Verify it selects an open port L := netListenerInRange(11000, 11005) - assert.NotNil(L, "should have a listener") - assert.Equal(addrPort(L.Addr()), "11001", "should bind to open port") + if L == nil { + t.Fatal("L should not be nil") + } + if addrPort(L.Addr()) != "11001" { + t.Fatalf("bad: %s", L.Addr()) + } // Returns nil if there are no open ports L = netListenerInRange(11000, 11000) - assert.Nil(L, "should not get a listener") + if L != nil { + t.Fatalf("bad: %#v", L) + } } } diff --git a/packer/rpc/provisioner_test.go b/packer/rpc/provisioner_test.go index e251d814f..7e281a1b5 100644 --- a/packer/rpc/provisioner_test.go +++ b/packer/rpc/provisioner_test.go @@ -1,15 +1,13 @@ package rpc import ( - "cgl.tideland.biz/asserts" "github.com/mitchellh/packer/packer" "net/rpc" + "reflect" "testing" ) func TestProvisionerRPC(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - // Create the interface to test p := new(packer.MockProvisioner) @@ -20,23 +18,33 @@ func TestProvisionerRPC(t *testing.T) { // Create the client over RPC and run some methods to verify it works client, err := rpc.Dial("tcp", address) - assert.Nil(err, "should be able to connect") + if err != nil { + t.Fatalf("err: %s", err) + } // Test Prepare config := 42 pClient := Provisioner(client) pClient.Prepare(config) - assert.True(p.PrepCalled, "prepare should be called") - assert.Equal(p.PrepConfigs, []interface{}{42}, "prepare should be called with right arg") + if !p.PrepCalled { + t.Fatal("should be called") + } + if !reflect.DeepEqual(p.PrepConfigs, []interface{}{42}) { + t.Fatalf("bad: %#v", p.PrepConfigs) + } // Test Provision ui := &testUi{} comm := &packer.MockCommunicator{} pClient.Provision(ui, comm) - assert.True(p.ProvCalled, "provision should be called") + if !p.ProvCalled { + t.Fatal("should be called") + } p.ProvUi.Say("foo") - assert.True(ui.sayCalled, "say should be called") + if !ui.sayCalled { + t.Fatal("should be called") + } // Test Cancel pClient.Cancel() @@ -46,10 +54,5 @@ func TestProvisionerRPC(t *testing.T) { } func TestProvisioner_Implements(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - - var r packer.Provisioner - p := Provisioner(nil) - - assert.Implementor(p, &r, "should be a provisioner") + var _ packer.Provisioner = Provisioner(nil) } diff --git a/packer/rpc/ui_test.go b/packer/rpc/ui_test.go index dec0d4721..8a85c5573 100644 --- a/packer/rpc/ui_test.go +++ b/packer/rpc/ui_test.go @@ -1,7 +1,6 @@ package rpc import ( - "cgl.tideland.biz/asserts" "net/rpc" "reflect" "testing" @@ -49,8 +48,6 @@ func (u *testUi) Say(message string) { } func TestUiRPC(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - // Create the UI to test ui := new(testUi) @@ -69,19 +66,33 @@ func TestUiRPC(t *testing.T) { // Basic error and say tests result, err := uiClient.Ask("query") - assert.Nil(err, "should not error") - assert.True(ui.askCalled, "ask should be called") - assert.Equal(ui.askQuery, "query", "should be correct") - assert.Equal(result, "foo", "should have correct result") + if err != nil { + t.Fatalf("err: %s", err) + } + if !ui.askCalled { + t.Fatal("should be called") + } + if ui.askQuery != "query" { + t.Fatalf("bad: %s", ui.askQuery) + } + if result != "foo" { + t.Fatalf("bad: %#v", result) + } uiClient.Error("message") - assert.Equal(ui.errorMessage, "message", "message should be correct") + if ui.errorMessage != "message" { + t.Fatalf("bad: %#v", ui.errorMessage) + } uiClient.Message("message") - assert.Equal(ui.messageMessage, "message", "message should be correct") + if ui.messageMessage != "message" { + t.Fatalf("bad: %#v", ui.errorMessage) + } uiClient.Say("message") - assert.Equal(ui.sayMessage, "message", "message should be correct") + if ui.sayMessage != "message" { + t.Fatalf("bad: %#v", ui.errorMessage) + } uiClient.Machine("foo", "bar", "baz") if !ui.machineCalled { diff --git a/packer/template_test.go b/packer/template_test.go index d457e7932..57ba31e47 100644 --- a/packer/template_test.go +++ b/packer/template_test.go @@ -1,7 +1,6 @@ package packer import ( - "cgl.tideland.biz/asserts" "io/ioutil" "os" "reflect" @@ -94,8 +93,6 @@ func TestParseTemplateFile_stdin(t *testing.T) { } func TestParseTemplate_Basic(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [{"type": "something"}] @@ -103,14 +100,18 @@ func TestParseTemplate_Basic(t *testing.T) { ` result, err := ParseTemplate([]byte(data)) - assert.Nil(err, "should not error") - assert.NotNil(result, "template should not be nil") - assert.Length(result.Builders, 1, "one builder") + if err != nil { + t.Fatalf("err: %s", err) + } + if result == nil { + t.Fatal("should have result") + } + if len(result.Builders) != 1 { + t.Fatalf("bad: %#v", result.Builders) + } } func TestParseTemplate_Invalid(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - // Note there is an extra comma below for a purposeful // syntax error in the JSON. data := ` @@ -120,13 +121,15 @@ func TestParseTemplate_Invalid(t *testing.T) { ` result, err := ParseTemplate([]byte(data)) - assert.NotNil(err, "should have an error") - assert.Nil(result, "should have no result") + if err == nil { + t.Fatal("shold have error") + } + if result != nil { + t.Fatal("should not have result") + } } func TestParseTemplate_InvalidKeys(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - // Note there is an extra comma below for a purposeful // syntax error in the JSON. data := ` @@ -137,13 +140,15 @@ func TestParseTemplate_InvalidKeys(t *testing.T) { ` result, err := ParseTemplate([]byte(data)) - assert.NotNil(err, "should have an error") - assert.Nil(result, "should have no result") + if err == nil { + t.Fatal("should have error") + } + if result != nil { + t.Fatal("should not have result") + } } func TestParseTemplate_BuilderWithoutType(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [{}] @@ -151,12 +156,12 @@ func TestParseTemplate_BuilderWithoutType(t *testing.T) { ` _, err := ParseTemplate([]byte(data)) - assert.NotNil(err, "should have error") + if err == nil { + t.Fatal("should have error") + } } func TestParseTemplate_BuilderWithNonStringType(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [{ @@ -166,12 +171,12 @@ func TestParseTemplate_BuilderWithNonStringType(t *testing.T) { ` _, err := ParseTemplate([]byte(data)) - assert.NotNil(err, "should have error") + if err == nil { + t.Fatal("should have error") + } } func TestParseTemplate_BuilderWithoutName(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [ @@ -183,18 +188,26 @@ func TestParseTemplate_BuilderWithoutName(t *testing.T) { ` result, err := ParseTemplate([]byte(data)) - assert.Nil(err, "should not error") - assert.NotNil(result, "template should not be nil") - assert.Length(result.Builders, 1, "should have one builder") + if err != nil { + t.Fatalf("err: %s", err) + } + if result == nil { + t.Fatal("should have result") + } + if len(result.Builders) != 1 { + t.Fatalf("bad: %#v", result.Builders) + } builder, ok := result.Builders["amazon-ebs"] - assert.True(ok, "should have amazon-ebs builder") - assert.Equal(builder.Type, "amazon-ebs", "builder should be amazon-ebs") + if !ok { + t.Fatal("should be ok") + } + if builder.Type != "amazon-ebs" { + t.Fatalf("bad: %#v", builder.Type) + } } func TestParseTemplate_BuilderWithName(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [ @@ -207,13 +220,23 @@ func TestParseTemplate_BuilderWithName(t *testing.T) { ` result, err := ParseTemplate([]byte(data)) - assert.Nil(err, "should not error") - assert.NotNil(result, "template should not be nil") - assert.Length(result.Builders, 1, "should have one builder") + if err != nil { + t.Fatalf("err: %s", err) + } + if result == nil { + t.Fatal("should have result") + } + if len(result.Builders) != 1 { + t.Fatalf("bad: %#v", result.Builders) + } builder, ok := result.Builders["bob"] - assert.True(ok, "should have bob builder") - assert.Equal(builder.Type, "amazon-ebs", "builder should be amazon-ebs") + if !ok { + t.Fatal("should be ok") + } + if builder.Type != "amazon-ebs" { + t.Fatalf("bad: %#v", builder.Type) + } RawConfig := builder.RawConfig if RawConfig == nil { @@ -230,8 +253,6 @@ func TestParseTemplate_BuilderWithName(t *testing.T) { } func TestParseTemplate_BuilderWithConflictingName(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [ @@ -248,12 +269,12 @@ func TestParseTemplate_BuilderWithConflictingName(t *testing.T) { ` _, err := ParseTemplate([]byte(data)) - assert.NotNil(err, "should have error") + if err == nil { + t.Fatal("should have error") + } } func TestParseTemplate_Hooks(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { @@ -266,13 +287,23 @@ func TestParseTemplate_Hooks(t *testing.T) { ` result, err := ParseTemplate([]byte(data)) - assert.Nil(err, "should not error") - assert.NotNil(result, "template should not be nil") - assert.Length(result.Hooks, 1, "should have one hook") + if err != nil { + t.Fatalf("err: %s", err) + } + if result == nil { + t.Fatal("should have result") + } + if len(result.Hooks) != 1 { + t.Fatalf("bad: %#v", result.Hooks) + } hooks, ok := result.Hooks["event"] - assert.True(ok, "should have hook") - assert.Equal(hooks, []string{"foo", "bar"}, "hooks should be correct") + if !ok { + t.Fatal("should be okay") + } + if !reflect.DeepEqual(hooks, []string{"foo", "bar"}) { + t.Fatalf("bad: %#v", hooks) + } } func TestParseTemplate_PostProcessors(t *testing.T) { @@ -332,8 +363,6 @@ func TestParseTemplate_PostProcessors(t *testing.T) { } func TestParseTemplate_ProvisionerWithoutType(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [{"type": "foo"}], @@ -343,12 +372,12 @@ func TestParseTemplate_ProvisionerWithoutType(t *testing.T) { ` _, err := ParseTemplate([]byte(data)) - assert.NotNil(err, "should have error") + if err == nil { + t.Fatal("err should not be nil") + } } func TestParseTemplate_ProvisionerWithNonStringType(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [{"type": "foo"}], @@ -360,12 +389,12 @@ func TestParseTemplate_ProvisionerWithNonStringType(t *testing.T) { ` _, err := ParseTemplate([]byte(data)) - assert.NotNil(err, "should have error") + if err == nil { + t.Fatal("should have error") + } } func TestParseTemplate_Provisioners(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [{"type": "foo"}], @@ -379,11 +408,21 @@ func TestParseTemplate_Provisioners(t *testing.T) { ` result, err := ParseTemplate([]byte(data)) - assert.Nil(err, "should not error") - assert.NotNil(result, "template should not be nil") - assert.Length(result.Provisioners, 1, "should have one provisioner") - assert.Equal(result.Provisioners[0].Type, "shell", "provisioner should be shell") - assert.NotNil(result.Provisioners[0].RawConfig, "should have raw config") + if err != nil { + t.Fatal("err: %s", err) + } + if result == nil { + t.Fatal("should have result") + } + if len(result.Provisioners) != 1 { + t.Fatalf("bad: %#v", result.Provisioners) + } + if result.Provisioners[0].Type != "shell" { + t.Fatalf("bad: %#v", result.Provisioners[0].Type) + } + if result.Provisioners[0].RawConfig == nil { + t.Fatal("should have raw config") + } } func TestParseTemplate_Variables(t *testing.T) { @@ -451,8 +490,6 @@ func TestParseTemplate_variablesBadDefault(t *testing.T) { } func TestTemplate_BuildNames(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [ @@ -469,16 +506,18 @@ func TestTemplate_BuildNames(t *testing.T) { ` result, err := ParseTemplate([]byte(data)) - assert.Nil(err, "should not error") + if err != nil { + t.Fatalf("err: %s", err) + } buildNames := result.BuildNames() sort.Strings(buildNames) - assert.Equal(buildNames, []string{"bob", "chris"}, "should have proper builds") + if !reflect.DeepEqual(buildNames, []string{"bob", "chris"}) { + t.Fatalf("bad: %#v", buildNames) + } } func TestTemplate_BuildUnknown(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [ @@ -491,16 +530,20 @@ func TestTemplate_BuildUnknown(t *testing.T) { ` template, err := ParseTemplate([]byte(data)) - assert.Nil(err, "should not error") + if err != nil { + t.Fatalf("bad: %s", err) + } build, err := template.Build("nope", nil) - assert.Nil(build, "build should be nil") - assert.NotNil(err, "should have error") + if build != nil { + t.Fatalf("build should be nil: %#v", build) + } + if err == nil { + t.Fatal("should have error") + } } func TestTemplate_BuildUnknownBuilder(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [ @@ -513,18 +556,22 @@ func TestTemplate_BuildUnknownBuilder(t *testing.T) { ` template, err := ParseTemplate([]byte(data)) - assert.Nil(err, "should not error") + if err != nil { + t.Fatalf("err: %s", err) + } builderFactory := func(string) (Builder, error) { return nil, nil } components := &ComponentFinder{Builder: builderFactory} build, err := template.Build("test1", components) - assert.Nil(build, "build should be nil") - assert.NotNil(err, "should have error") + if err == nil { + t.Fatal("should have error") + } + if build != nil { + t.Fatalf("bad: %#v", build) + } } func TestTemplate_Build_NilBuilderFunc(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [ @@ -543,14 +590,18 @@ func TestTemplate_Build_NilBuilderFunc(t *testing.T) { ` template, err := ParseTemplate([]byte(data)) - assert.Nil(err, "should not error") + if err != nil { + t.Fatalf("err: %s", err) + } defer func() { p := recover() - assert.NotNil(p, "should panic") + if p == nil { + t.Fatal("should panic") + } - if p != nil { - assert.Equal(p.(string), "no builder function", "right panic") + if p.(string) != "no builder function" { + t.Fatalf("bad panic: %s", p.(string)) } }() @@ -558,8 +609,6 @@ func TestTemplate_Build_NilBuilderFunc(t *testing.T) { } func TestTemplate_Build_NilProvisionerFunc(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [ @@ -578,14 +627,18 @@ func TestTemplate_Build_NilProvisionerFunc(t *testing.T) { ` template, err := ParseTemplate([]byte(data)) - assert.Nil(err, "should not error") + if err != nil { + t.Fatalf("err: %s", err) + } defer func() { p := recover() - assert.NotNil(p, "should panic") + if p == nil { + t.Fatal("should panic") + } - if p != nil { - assert.Equal(p.(string), "no provisioner function", "right panic") + if p.(string) != "no provisioner function" { + t.Fatalf("bad panic: %s", p.(string)) } }() @@ -595,8 +648,6 @@ func TestTemplate_Build_NilProvisionerFunc(t *testing.T) { } func TestTemplate_Build_NilProvisionerFunc_WithNoProvisioners(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [ @@ -611,7 +662,9 @@ func TestTemplate_Build_NilProvisionerFunc_WithNoProvisioners(t *testing.T) { ` template, err := ParseTemplate([]byte(data)) - assert.Nil(err, "should not error") + if err != nil { + t.Fatalf("err: %s", err) + } template.Build("test1", &ComponentFinder{ Builder: func(string) (Builder, error) { return nil, nil }, @@ -619,8 +672,6 @@ func TestTemplate_Build_NilProvisionerFunc_WithNoProvisioners(t *testing.T) { } func TestTemplate_Build(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [ @@ -651,7 +702,9 @@ func TestTemplate_Build(t *testing.T) { } template, err := ParseTemplate([]byte(data)) - assert.Nil(err, "should not error") + if err != nil { + t.Fatalf("err: %s", err) + } builder := testBuilder() builderMap := map[string]Builder{ @@ -680,18 +733,40 @@ func TestTemplate_Build(t *testing.T) { // Get the build, verifying we can get it without issue, but also // that the proper builder was looked up and used for the build. build, err := template.Build("test1", components) - assert.Nil(err, "should not error") + if err != nil { + t.Fatalf("err: %s", err) + } coreBuild, ok := build.(*coreBuild) - assert.True(ok, "should be a core build") - assert.Equal(coreBuild.builder, builder, "should have the same builder") - assert.Equal(coreBuild.builderConfig, expectedConfig, "should have proper config") - assert.Equal(len(coreBuild.provisioners), 1, "should have one provisioner") - assert.Equal(len(coreBuild.postProcessors), 2, "should have pps") - assert.Equal(len(coreBuild.postProcessors[0]), 1, "should have correct number") - assert.Equal(len(coreBuild.postProcessors[1]), 2, "should have correct number") - assert.False(coreBuild.postProcessors[1][0].keepInputArtifact, "shoule be correct") - assert.True(coreBuild.postProcessors[1][1].keepInputArtifact, "shoule be correct") + if !ok { + t.Fatal("should be ok") + } + if coreBuild.builder != builder { + t.Fatalf("bad: %#v", coreBuild.builder) + } + if !reflect.DeepEqual(coreBuild.builderConfig, expectedConfig) { + t.Fatalf("bad: %#v", coreBuild.builderConfig) + } + if len(coreBuild.provisioners) != 1 { + t.Fatalf("bad: %#v", coreBuild.provisioners) + } + if len(coreBuild.postProcessors) != 2 { + t.Fatalf("bad: %#v", coreBuild.postProcessors) + } + + if len(coreBuild.postProcessors[0]) != 1 { + t.Fatalf("bad: %#v", coreBuild.postProcessors[0]) + } + if len(coreBuild.postProcessors[1]) != 2 { + t.Fatalf("bad: %#v", coreBuild.postProcessors[1]) + } + + if coreBuild.postProcessors[1][0].keepInputArtifact { + t.Fatal("postProcessors[1][0] should not keep input artifact") + } + if !coreBuild.postProcessors[1][1].keepInputArtifact { + t.Fatal("postProcessors[1][1] should keep input artifact") + } config := coreBuild.postProcessors[1][1].config if _, ok := config["keep_input_artifact"]; ok { @@ -1080,8 +1155,6 @@ func TestTemplateBuild_onlyProv(t *testing.T) { } func TestTemplate_Build_ProvisionerOverride(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - data := ` { "builders": [ @@ -1141,12 +1214,20 @@ func TestTemplate_Build_ProvisionerOverride(t *testing.T) { // Get the build, verifying we can get it without issue, but also // that the proper builder was looked up and used for the build. build, err := template.Build("test1", components) - assert.Nil(err, "should not error") + if err != nil { + t.Fatalf("err: %s", err) + } coreBuild, ok := build.(*coreBuild) - assert.True(ok, "should be a core build") - assert.Equal(len(coreBuild.provisioners), 1, "should have one provisioner") - assert.Equal(len(coreBuild.provisioners[0].config), 2, "should have two configs on the provisioner") + if !ok { + t.Fatal("should be okay") + } + if len(coreBuild.provisioners) != 1 { + t.Fatalf("bad: %#v", coreBuild.provisioners) + } + if len(coreBuild.provisioners[0].config) != 2 { + t.Fatalf("bad: %#v", coreBuild.provisioners[0].config) + } } func TestTemplate_Build_ProvisionerOverrideBad(t *testing.T) { diff --git a/packer/ui_test.go b/packer/ui_test.go index 87091f189..c8168a19e 100644 --- a/packer/ui_test.go +++ b/packer/ui_test.go @@ -2,7 +2,6 @@ package packer import ( "bytes" - "cgl.tideland.biz/asserts" "strings" "testing" ) @@ -38,25 +37,40 @@ func TestColoredUi(t *testing.T) { } func TestTargettedUi(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - bufferUi := testUi() targettedUi := &TargettedUi{ Target: "foo", Ui: bufferUi, } + var actual, expected string targettedUi.Say("foo") - assert.Equal(readWriter(bufferUi), "==> foo: foo\n", "should have prefix") + actual = readWriter(bufferUi) + expected = "==> foo: foo\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } targettedUi.Message("foo") - assert.Equal(readWriter(bufferUi), " foo: foo\n", "should have prefix") + actual = readWriter(bufferUi) + expected = " foo: foo\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } targettedUi.Error("bar") - assert.Equal(readWriter(bufferUi), "==> foo: bar\n", "should have prefix") + actual = readWriter(bufferUi) + expected = "==> foo: bar\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } targettedUi.Say("foo\nbar") - assert.Equal(readWriter(bufferUi), "==> foo: foo\n==> foo: bar\n", "should multiline") + actual = readWriter(bufferUi) + expected = "==> foo: foo\n==> foo: bar\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } } func TestColoredUi_ImplUi(t *testing.T) { @@ -84,27 +98,42 @@ func TestBasicUi_ImplUi(t *testing.T) { } func TestBasicUi_Error(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - bufferUi := testUi() + var actual, expected string bufferUi.Error("foo") - assert.Equal(readWriter(bufferUi), "foo\n", "basic output") + actual = readWriter(bufferUi) + expected = "foo\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } bufferUi.Error("5") - assert.Equal(readWriter(bufferUi), "5\n", "formatting") + actual = readWriter(bufferUi) + expected = "5\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } } func TestBasicUi_Say(t *testing.T) { - assert := asserts.NewTestingAsserts(t, true) - bufferUi := testUi() + var actual, expected string + bufferUi.Say("foo") - assert.Equal(readWriter(bufferUi), "foo\n", "basic output") + actual = readWriter(bufferUi) + expected = "foo\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } bufferUi.Say("5") - assert.Equal(readWriter(bufferUi), "5\n", "formatting") + actual = readWriter(bufferUi) + expected = "5\n" + if actual != expected { + t.Fatalf("bad: %#v", actual) + } } func TestMachineReadableUi_ImplUi(t *testing.T) { diff --git a/post-processor/vagrant/post-processor.go b/post-processor/vagrant/post-processor.go index 91969e558..8aa44d9fb 100644 --- a/post-processor/vagrant/post-processor.go +++ b/post-processor/vagrant/post-processor.go @@ -12,9 +12,10 @@ import ( ) var builtins = map[string]string{ - "mitchellh.amazonebs": "aws", - "mitchellh.virtualbox": "virtualbox", - "mitchellh.vmware": "vmware", + "mitchellh.amazonebs": "aws", + "mitchellh.amazon.instance": "aws", + "mitchellh.virtualbox": "virtualbox", + "mitchellh.vmware": "vmware", } type Config struct { diff --git a/provisioner/shell/unix_reader.go b/provisioner/shell/unix_reader.go index 0a19c0692..837ecdeae 100644 --- a/provisioner/shell/unix_reader.go +++ b/provisioner/shell/unix_reader.go @@ -54,5 +54,12 @@ func (r *UnixReader) Read(p []byte) (n int, err error) { // token returned will be "one\n". func scanUnixLine(data []byte, atEOF bool) (advance int, token []byte, err error) { advance, token, err = bufio.ScanLines(data, atEOF) - return advance, append(token, "\n"...), err + if advance == 0 { + // If we reached the end of a line without a newline, then + // just return as it is. Otherwise the Scanner will keep trying + // to scan, blocking forever. + return + } + + return advance, append(token, '\n'), err } diff --git a/provisioner/shell/unix_reader_test.go b/provisioner/shell/unix_reader_test.go index 4f39eb00f..4aa1f9ea9 100644 --- a/provisioner/shell/unix_reader_test.go +++ b/provisioner/shell/unix_reader_test.go @@ -18,24 +18,24 @@ func TestUnixReader(t *testing.T) { input := "one\r\ntwo\n\r\nthree\r\n" expected := "one\ntwo\n\nthree\n" - r := &UnixReader{ - Reader: bytes.NewReader([]byte(input)), - } - - result := new(bytes.Buffer) - if _, err := io.Copy(result, r); err != nil { - t.Fatalf("err: %s", err) - } - - if result.String() != expected { - t.Fatalf("bad: %#v", result.String()) - } + unixReaderTest(t, input, expected) } func TestUnixReader_unixOnly(t *testing.T) { input := "\none\n\ntwo\nthree\n\n" expected := "\none\n\ntwo\nthree\n\n" + unixReaderTest(t, input, expected) +} + +func TestUnixReader_readsLastLine(t *testing.T) { + input := "one\ntwo" + expected := "one\ntwo\n" + + unixReaderTest(t, input, expected) +} + +func unixReaderTest(t *testing.T, input string, expected string) { r := &UnixReader{ Reader: bytes.NewReader([]byte(input)), } diff --git a/website/source/docs/builders/virtualbox.html.markdown b/website/source/docs/builders/virtualbox.html.markdown index b10cd8cb0..0045b7460 100644 --- a/website/source/docs/builders/virtualbox.html.markdown +++ b/website/source/docs/builders/virtualbox.html.markdown @@ -28,11 +28,16 @@ Ubuntu to self-install. Still, the example serves to show the basic configuratio "iso_checksum": "2cbe868812a871242cdcdd8f2fd6feb9", "iso_checksum_type": "md5", "ssh_username": "packer", + "ssh_password": "packer", "ssh_wait_timeout": "30s", - "shutdown_command": "shutdown -P now" + "shutdown_command": "echo 'packer' | sudo -S shutdown -P now" } +It is important to add a `shutdown_command`. By default Packer halts the +virtual machine and the file system may not be sync'd. Thus, changes made in a +provisioner might not be saved. + ## Configuration Reference There are many configuration options available for the VirtualBox builder. diff --git a/website/source/docs/provisioners/salt-masterless.html.markdown b/website/source/docs/provisioners/salt-masterless.html.markdown index 7cc23d440..c0dbead7c 100644 --- a/website/source/docs/provisioners/salt-masterless.html.markdown +++ b/website/source/docs/provisioners/salt-masterless.html.markdown @@ -39,7 +39,7 @@ Optional: [salt bootstrap](https://github.com/saltstack/salt-bootstrap) to install salt. Set this to true to skip this step. -* `boostrap_args` (string) - Arguments to send to the bootstrap script. Usage +* `bootstrap_args` (string) - Arguments to send to the bootstrap script. Usage is somewhat documented on [github](https://github.com/saltstack/salt-bootstrap), but the [script itself](https://github.com/saltstack/salt-bootstrap/blob/develop/bootstrap-salt.sh) has more detailed usage instructions. By default, no arguments are sent to