From c2ff4ded9c0932eaf5b101670a60791a3eaa985e Mon Sep 17 00:00:00 2001 From: Jonas Pfenniger Date: Sat, 5 Oct 2013 23:32:41 +0100 Subject: [PATCH 01/25] Use the same vagrant post-processor for amazon instances than EBS. Fixes #502 --- post-processor/vagrant/post-processor.go | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) 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 { From 50bc71e4a2d4c772a3ba3b70aa3b58787b68c172 Mon Sep 17 00:00:00 2001 From: Lyndon Washington Date: Wed, 9 Oct 2013 12:59:47 -0400 Subject: [PATCH 02/25] Moved the 1 sec timeout to the export step --- builder/virtualbox/step_export.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/builder/virtualbox/step_export.go b/builder/virtualbox/step_export.go index fd7282c67..a8b60ce50 100644 --- a/builder/virtualbox/step_export.go +++ b/builder/virtualbox/step_export.go @@ -5,6 +5,8 @@ import ( "github.com/mitchellh/multistep" "github.com/mitchellh/packer/packer" "path/filepath" + "log" + "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"))) From 53b15e62cce3bdfed85ee9dc9a9be7d6c2489167 Mon Sep 17 00:00:00 2001 From: Lyndon Washington Date: Wed, 9 Oct 2013 13:14:09 -0400 Subject: [PATCH 03/25] Formatted contributions --- builder/virtualbox/step_export.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/builder/virtualbox/step_export.go b/builder/virtualbox/step_export.go index a8b60ce50..726af7937 100644 --- a/builder/virtualbox/step_export.go +++ b/builder/virtualbox/step_export.go @@ -4,8 +4,8 @@ import ( "fmt" "github.com/mitchellh/multistep" "github.com/mitchellh/packer/packer" - "path/filepath" "log" + "path/filepath" "time" ) From 2c5f742fa35ed347f8f700d6f238010e0cab95b0 Mon Sep 17 00:00:00 2001 From: Matthew Hooker Date: Thu, 10 Oct 2013 15:01:07 -0700 Subject: [PATCH 04/25] builder/digitalocean: Scrub config before logging [GH-516] --- builder/digitalocean/builder.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/builder/digitalocean/builder.go b/builder/digitalocean/builder.go index 8e74ec9b1..f8a25b4b3 100644 --- a/builder/digitalocean/builder.go +++ b/builder/digitalocean/builder.go @@ -11,6 +11,7 @@ import ( "github.com/mitchellh/packer/packer" "log" "os" + "strings" "time" ) @@ -164,7 +165,10 @@ func (b *Builder) Prepare(raws ...interface{}) error { return errs } - log.Printf("Config: %+v", b.config) + configRepr := fmt.Sprintf("Config: %+v", b.config) + scrubbedConfig := strings.Replace(configRepr, b.config.ClientID, "CLIENT_ID", -1) + scrubbedConfig = strings.Replace(scrubbedConfig, b.config.APIKey, "API_KEY", -1) + log.Println(scrubbedConfig) return nil } From 4afe900535b9c90e7c2fe0ac045aaaec3256d516 Mon Sep 17 00:00:00 2001 From: Jack Pearkes Date: Fri, 11 Oct 2013 01:07:06 +0200 Subject: [PATCH 05/25] Update CHANGELOG --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index cf62f1129..63505717d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,7 @@ BUG FIXES: * builder/all: timeout waiting for SSH connection is a failure. [GH-491] * 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] From aeb0e8bc06cf24c2a1844f8bf1dded3cc5292e14 Mon Sep 17 00:00:00 2001 From: Patrick Lucas Date: Fri, 11 Oct 2013 14:05:24 -0700 Subject: [PATCH 06/25] Fix race condition after launching EC2 instance It is possible for an instance to not immediately exist after it is launched. Previously, InstanceStateRefreshFunc would crash if this race condition were realized. This change takes the exact same approach of the function above, AMIStateRefreshFunc, treating 'InvalidInstanceID.NotFound' as if there were an empty result. --- builder/amazon/common/state.go | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) 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 From 739fbc896218379aaf976c0de8565bd8f93bbb3e Mon Sep 17 00:00:00 2001 From: Matthew Hooker Date: Fri, 11 Oct 2013 03:50:08 -0700 Subject: [PATCH 07/25] common/config: config filter function [GH-521] Fixes #521 --- builder/amazon/chroot/builder.go | 2 +- builder/amazon/ebs/builder.go | 2 +- builder/amazon/instance/builder.go | 2 +- builder/digitalocean/builder.go | 6 +----- builder/openstack/builder.go | 2 +- common/config.go | 10 ++++++++++ common/config_test.go | 17 +++++++++++++++++ 7 files changed, 32 insertions(+), 9 deletions(-) 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/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 f8a25b4b3..acf92c240 100644 --- a/builder/digitalocean/builder.go +++ b/builder/digitalocean/builder.go @@ -11,7 +11,6 @@ import ( "github.com/mitchellh/packer/packer" "log" "os" - "strings" "time" ) @@ -165,10 +164,7 @@ func (b *Builder) Prepare(raws ...interface{}) error { return errs } - configRepr := fmt.Sprintf("Config: %+v", b.config) - scrubbedConfig := strings.Replace(configRepr, b.config.ClientID, "CLIENT_ID", -1) - scrubbedConfig = strings.Replace(scrubbedConfig, b.config.APIKey, "API_KEY", -1) - log.Println(scrubbedConfig) + common.ScrubConfig(b.config, b.config.ClientID, b.config.APIKey) return nil } diff --git a/builder/openstack/builder.go b/builder/openstack/builder.go index 95204dab6..6e9c961b4 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.AccessKey, b.config.SecretKey) return nil } 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) + } +} From 7ae1042696b933ed417018934da8bf2042cdda56 Mon Sep 17 00:00:00 2001 From: Matthew Hooker Date: Sun, 13 Oct 2013 11:03:45 -0700 Subject: [PATCH 08/25] common/config: strip keys appropriate for OpenStack. --- builder/openstack/builder.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/builder/openstack/builder.go b/builder/openstack/builder.go index 6e9c961b4..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.Println(common.ScrubConfig(b.config), b.config.AccessKey, b.config.SecretKey) + log.Println(common.ScrubConfig(b.config), b.config.Password) return nil } From df3d751b19d49b06ffd2c676ffc45d4776b37ce0 Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Sun, 13 Oct 2013 22:21:52 -1000 Subject: [PATCH 09/25] communicator/ssh: explicitly set c.conn = nil --- CHANGELOG.md | 2 ++ communicator/ssh/communicator.go | 8 ++++++++ 2 files changed, 10 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 63505717d..68f07c792 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,8 @@ BUG FIXES: * 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] +* communicator/ssh: Fix issue where a panic could arise from a nil + dereference. [GH-525] ## 0.3.9 (October 2, 2013) 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 } From eb2bcfe456eb122e8102883c08404d5aa7eaff8b Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Sun, 13 Oct 2013 22:36:15 -1000 Subject: [PATCH 10/25] Update CHANGELOG --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 68f07c792..b2c25ccda 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,7 @@ 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/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] From 93ab5c8f63d09d77362757265e107a76e2bb63d7 Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Sun, 13 Oct 2013 22:46:31 -1000 Subject: [PATCH 11/25] Update CHANGELOG --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index b2c25ccda..d675be0da 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,8 @@ 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] From bfba5413387a644437a9ba9d1aa287978c49a989 Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Sun, 13 Oct 2013 22:51:36 -1000 Subject: [PATCH 12/25] Update CHANGELOG --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index d675be0da..9a4f62e91 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,8 @@ BUG FIXES: * 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] From 61ea7de66b3d5fa286a28fa647a4e02253cf9e7f Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Sun, 13 Oct 2013 22:57:04 -1000 Subject: [PATCH 13/25] Update CHANGELOG --- CHANGELOG.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9a4f62e91..552f12b57 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,9 @@ ## 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] From bd68f3c52b3878384278274b1b5a0e7a96168b48 Mon Sep 17 00:00:00 2001 From: Jon Stevens Date: Mon, 14 Oct 2013 17:59:53 -0700 Subject: [PATCH 14/25] I found that I needed the shutdown command to be run as root. Also added a note about shutdown_command that bit me. --- website/source/docs/builders/virtualbox.html.markdown | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) 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. From abe92ed7398c7e943e6951a8721c33d590e01e6b Mon Sep 17 00:00:00 2001 From: Matthew Hooker Date: Tue, 15 Oct 2013 05:51:49 -0700 Subject: [PATCH 15/25] provisioner/shell: fix EOF detection Fixes #507 The scanUnixLine function was erroneously returning empty lines when EOF was reached. This commit adds a test for the problem and changes the scanUnixLine function to elide the trailing \n if no content was read. --- provisioner/shell/unix_reader.go | 3 +++ provisioner/shell/unix_reader_test.go | 24 ++++++++++++------------ 2 files changed, 15 insertions(+), 12 deletions(-) diff --git a/provisioner/shell/unix_reader.go b/provisioner/shell/unix_reader.go index 0a19c0692..52b83eddd 100644 --- a/provisioner/shell/unix_reader.go +++ b/provisioner/shell/unix_reader.go @@ -54,5 +54,8 @@ 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) + if advance == 0 { + 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)), } From f2c0aeacf56c1653e624240db4b770166ae657a1 Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Tue, 15 Oct 2013 09:40:47 -1000 Subject: [PATCH 16/25] provisoiner/shell: append only needs to add a byte for UnixReader --- provisioner/shell/unix_reader.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/provisioner/shell/unix_reader.go b/provisioner/shell/unix_reader.go index 52b83eddd..1e4ea76a1 100644 --- a/provisioner/shell/unix_reader.go +++ b/provisioner/shell/unix_reader.go @@ -57,5 +57,5 @@ func scanUnixLine(data []byte, atEOF bool) (advance int, token []byte, err error if advance == 0 { return } - return advance, append(token, "\n"...), err + return advance, append(token, '\n'), err } From d3ab4d6b40a779ffa0edba8439999a96c2e6805d Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Tue, 15 Oct 2013 09:48:12 -1000 Subject: [PATCH 17/25] provisioner/shell: comment on why we return right away if advance == 0 /cc @mwhooker --- provisioner/shell/unix_reader.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/provisioner/shell/unix_reader.go b/provisioner/shell/unix_reader.go index 1e4ea76a1..837ecdeae 100644 --- a/provisioner/shell/unix_reader.go +++ b/provisioner/shell/unix_reader.go @@ -55,7 +55,11 @@ func (r *UnixReader) Read(p []byte) (n int, err error) { func scanUnixLine(data []byte, atEOF bool) (advance int, token []byte, err error) { advance, token, err = bufio.ScanLines(data, atEOF) 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 } From 7b09e24ac3c18955d6939cc8bdb0d952ce824b75 Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Tue, 15 Oct 2013 09:51:47 -1000 Subject: [PATCH 18/25] Update CHANGELOG --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 552f12b57..b705ae719 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -19,6 +19,8 @@ BUG FIXES: 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) From 697c91b0b0e5a4c515383dda921ca41511087b89 Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Wed, 16 Oct 2013 16:21:14 -1000 Subject: [PATCH 19/25] Remove dependency on identifier package, use time ordered UUID [GH-541] --- builder/amazon/common/step_security_group.go | 5 ++--- builder/digitalocean/step_create_droplet.go | 5 ++--- builder/digitalocean/step_create_ssh_key.go | 5 ++--- builder/openstack/step_key_pair.go | 5 ++--- common/uuid/uuid.go | 23 ++++++++++++++++++++ packer/config_template.go | 5 ++--- 6 files changed, 33 insertions(+), 15 deletions(-) create mode 100644 common/uuid/uuid.go 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/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/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/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/packer/config_template.go b/packer/config_template.go index 895e11682..4be4d1c94 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 hex.EncodeToString(uuid.TimeOrderedUUID()) } From ac64805a9eddff2caa28fe6a213510e0fc3efd1e Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Wed, 16 Oct 2013 16:27:15 -1000 Subject: [PATCH 20/25] command/build: remove asserts framewor --- command/build/command_test.go | 21 ++++++++++----------- packer/config_template.go | 2 +- 2 files changed, 11 insertions(+), 12 deletions(-) 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/packer/config_template.go b/packer/config_template.go index 4be4d1c94..98dde878d 100644 --- a/packer/config_template.go +++ b/packer/config_template.go @@ -93,5 +93,5 @@ func templateTimestamp() string { } func templateUuid() string { - return hex.EncodeToString(uuid.TimeOrderedUUID()) + return uuid.TimeOrderedUUID() } From 3fad717ba46fe0f6562291e46f97a780f531b2da Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Wed, 16 Oct 2013 16:29:53 -1000 Subject: [PATCH 21/25] builder/amazon,builder/openstack: remove more cgl libs --- builder/amazon/common/artifact_test.go | 18 +++++++----------- builder/amazon/common/block_device_test.go | 13 ++++++++----- builder/openstack/artifact_test.go | 18 +++++++----------- 3 files changed, 22 insertions(+), 27 deletions(-) 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/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) + } } From cf9dafd37318e0fcc4e351c0858cacde7ed9d55e Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Wed, 16 Oct 2013 17:04:57 -1000 Subject: [PATCH 22/25] packer/rpc: don't depend on cgl --- packer/rpc/artifact_test.go | 34 +++++++++------- packer/rpc/build_test.go | 71 +++++++++++++++++++++----------- packer/rpc/builder_test.go | 74 +++++++++++++++++++++++----------- packer/rpc/cache_test.go | 39 ++++++++++++------ packer/rpc/command_test.go | 42 ++++++++++--------- packer/rpc/environment_test.go | 63 +++++++++++++++++++---------- packer/rpc/error_test.go | 14 ++----- packer/rpc/hook_test.go | 22 +++++----- packer/rpc/port_test.go | 19 +++++---- packer/rpc/provisioner_test.go | 31 +++++++------- packer/rpc/ui_test.go | 31 +++++++++----- 11 files changed, 274 insertions(+), 166 deletions(-) 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 { From 7d3987d840101e4a6e0d2586cf387eb051989722 Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Wed, 16 Oct 2013 21:09:27 -1000 Subject: [PATCH 23/25] packer: no more asserts lib --- packer/build_test.go | 97 +++++++---- packer/config_template_test.go | 2 +- packer/environment_test.go | 251 +++++++++++++++++----------- packer/hook_test.go | 22 ++- packer/multi_error_test.go | 7 +- packer/template_test.go | 291 +++++++++++++++++++++------------ packer/ui_test.go | 59 +++++-- 7 files changed, 462 insertions(+), 267 deletions(-) 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_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/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) { From cfcdeadf534965cd7fc9a940d06b09fa82a58f51 Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Wed, 16 Oct 2013 21:19:53 -1000 Subject: [PATCH 24/25] common/uuid: add test, albeit weak --- common/uuid/uuid_test.go | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 common/uuid/uuid_test.go 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) + } +} From 45f4a1a914739730b304feaacde158ca846bbd4e Mon Sep 17 00:00:00 2001 From: Tate Eskew Date: Thu, 17 Oct 2013 11:12:21 -0500 Subject: [PATCH 25/25] fix typo in docs for saltmasterless provisioner. bootstrap was spelled incorrectly --- website/source/docs/provisioners/salt-masterless.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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