0fa60c68fb
* Drop the iso_checksum_type & iso_checksum_url fields
In favor of simply using iso_checksum that will know what to do.
* fix after master merge
* Update builder_test.go
* Update builder_test.go
* Update builder_test.go
* Update builder_test.go
* Update builder_test.go
* remove checksum lowercasing tests
* Update builder_test.go
* Update builder_test.go
* better docs
* Update builder_test.go
* even better docs
* Update config.go
* Update builder_test.go
* Update step_create_vmx_test.go
* make generate
* better docs
* fix imports
* up tests
* Update _ISOConfig-required.html.md
* Update builder_test.go
* don't use sha1.Sum("none") as a caching path
* Update builder_test.go
* better docs
* Update iso_config_test.go
remove ISOChecksumType/ISOChecksumURL references
* Update step_download_test.go
* add iso_checksum_url and iso_checksum_type fixers + tests
* add concrete examples of checksum values
* add examples of checksumming from local file
* update go-getter dep
* up deps
* use new go-getter version
* up ESX5Driver.VerifyChecksum: use go-getter's checksumming
* ISOConfig.Prepare: get checksum there in case we need it as a string in ESX5Driver.VerifyChecksum
* Update iso_config.go
* get go-getter from v2 branch
* Update driver_esx5.go
add more comments
* Update driver_esx5.go
* show better error message when the checksum is invalid
* Update builder_test.go
put in a valid checksum to fix tests, checksum is md5("packer")
* Update builder_test.go
test invalid and valid checksum
* more test updating
* fix default md5 string to be a valid md5
* TestChecksumFileNameMixedCaseBug: use 'file:' prefix for file checksumming
* Update iso_config_test.go
* Update iso_config_test.go
* Update builder_test.go
* Update builder_test.go
* Update builder_test.go
* Update CHANGELOG.md
* Update CHANGELOG.md
* Update go.mod
* Update go.mod
* Update CHANGELOG.md
369 lines
7.9 KiB
Go
369 lines
7.9 KiB
Go
package iso
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/hashicorp/packer/builder/virtualbox/common"
|
|
"github.com/hashicorp/packer/packer"
|
|
)
|
|
|
|
func testConfig() map[string]interface{} {
|
|
return map[string]interface{}{
|
|
"iso_checksum": "md5:0B0F137F17AC10944716020B018F8126",
|
|
"iso_url": "http://www.google.com/",
|
|
"shutdown_command": "yes",
|
|
"ssh_username": "foo",
|
|
|
|
packer.BuildNameConfigKey: "foo",
|
|
}
|
|
}
|
|
|
|
func TestBuilder_ImplementsBuilder(t *testing.T) {
|
|
var raw interface{}
|
|
raw = &Builder{}
|
|
if _, ok := raw.(packer.Builder); !ok {
|
|
t.Error("Builder must implement builder.")
|
|
}
|
|
}
|
|
|
|
func TestBuilderPrepare_Defaults(t *testing.T) {
|
|
var b Builder
|
|
config := testConfig()
|
|
_, warns, err := b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("should not have error: %s", err)
|
|
}
|
|
|
|
if b.config.GuestAdditionsMode != common.GuestAdditionsModeUpload {
|
|
t.Errorf("bad guest additions mode: %s", b.config.GuestAdditionsMode)
|
|
}
|
|
|
|
if b.config.GuestOSType != "Other" {
|
|
t.Errorf("bad guest OS type: %s", b.config.GuestOSType)
|
|
}
|
|
|
|
if b.config.VMName == "" {
|
|
t.Errorf("bad vm name: %s", b.config.VMName)
|
|
}
|
|
|
|
if b.config.Format != "ovf" {
|
|
t.Errorf("bad format: %s", b.config.Format)
|
|
}
|
|
}
|
|
|
|
func TestBuilderPrepare_DiskSize(t *testing.T) {
|
|
var b Builder
|
|
config := testConfig()
|
|
|
|
delete(config, "disk_size")
|
|
_, warns, err := b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("bad err: %s", err)
|
|
}
|
|
|
|
if b.config.DiskSize != 40000 {
|
|
t.Fatalf("bad size: %d", b.config.DiskSize)
|
|
}
|
|
|
|
config["disk_size"] = 60000
|
|
b = Builder{}
|
|
_, warns, err = b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("should not have error: %s", err)
|
|
}
|
|
|
|
if b.config.DiskSize != 60000 {
|
|
t.Fatalf("bad size: %d", b.config.DiskSize)
|
|
}
|
|
}
|
|
|
|
func TestBuilderPrepare_FloppyFiles(t *testing.T) {
|
|
var b Builder
|
|
config := testConfig()
|
|
|
|
delete(config, "floppy_files")
|
|
_, warns, err := b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("bad err: %s", err)
|
|
}
|
|
|
|
if len(b.config.FloppyFiles) != 0 {
|
|
t.Fatalf("bad: %#v", b.config.FloppyFiles)
|
|
}
|
|
|
|
floppies_path := "../../../common/test-fixtures/floppies"
|
|
config["floppy_files"] = []string{fmt.Sprintf("%s/bar.bat", floppies_path), fmt.Sprintf("%s/foo.ps1", floppies_path)}
|
|
b = Builder{}
|
|
_, warns, err = b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("should not have error: %s", err)
|
|
}
|
|
|
|
expected := []string{fmt.Sprintf("%s/bar.bat", floppies_path), fmt.Sprintf("%s/foo.ps1", floppies_path)}
|
|
if !reflect.DeepEqual(b.config.FloppyFiles, expected) {
|
|
t.Fatalf("bad: %#v", b.config.FloppyFiles)
|
|
}
|
|
}
|
|
|
|
func TestBuilderPrepare_InvalidFloppies(t *testing.T) {
|
|
var b Builder
|
|
config := testConfig()
|
|
config["floppy_files"] = []string{"nonexistent.bat", "nonexistent.ps1"}
|
|
b = Builder{}
|
|
_, _, errs := b.Prepare(config)
|
|
if errs == nil {
|
|
t.Fatalf("Nonexistent floppies should trigger multierror")
|
|
}
|
|
|
|
if len(errs.(*packer.MultiError).Errors) != 2 {
|
|
t.Fatalf("Multierror should work and report 2 errors")
|
|
}
|
|
}
|
|
|
|
func TestBuilderPrepare_GuestAdditionsMode(t *testing.T) {
|
|
var b Builder
|
|
config := testConfig()
|
|
|
|
// test default mode
|
|
delete(config, "guest_additions_mode")
|
|
_, warns, err := b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("bad err: %s", err)
|
|
}
|
|
|
|
// Test another mode
|
|
config["guest_additions_mode"] = "attach"
|
|
b = Builder{}
|
|
_, warns, err = b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("should not have error: %s", err)
|
|
}
|
|
|
|
if b.config.GuestAdditionsMode != common.GuestAdditionsModeAttach {
|
|
t.Fatalf("bad: %s", b.config.GuestAdditionsMode)
|
|
}
|
|
|
|
// Test bad mode
|
|
config["guest_additions_mode"] = "teleport"
|
|
b = Builder{}
|
|
_, warns, err = b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err == nil {
|
|
t.Fatal("should error")
|
|
}
|
|
}
|
|
|
|
func TestBuilderPrepare_GuestAdditionsPath(t *testing.T) {
|
|
var b Builder
|
|
config := testConfig()
|
|
|
|
delete(config, "guest_additions_path")
|
|
_, warns, err := b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("bad err: %s", err)
|
|
}
|
|
|
|
if b.config.GuestAdditionsPath != "VBoxGuestAdditions.iso" {
|
|
t.Fatalf("bad: %s", b.config.GuestAdditionsPath)
|
|
}
|
|
|
|
config["guest_additions_path"] = "foo"
|
|
b = Builder{}
|
|
_, warns, err = b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("should not have error: %s", err)
|
|
}
|
|
|
|
if b.config.GuestAdditionsPath != "foo" {
|
|
t.Fatalf("bad size: %s", b.config.GuestAdditionsPath)
|
|
}
|
|
}
|
|
|
|
func TestBuilderPrepare_GuestAdditionsSHA256(t *testing.T) {
|
|
var b Builder
|
|
config := testConfig()
|
|
|
|
delete(config, "guest_additions_sha256")
|
|
_, warns, err := b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("bad err: %s", err)
|
|
}
|
|
|
|
if b.config.GuestAdditionsSHA256 != "" {
|
|
t.Fatalf("bad: %s", b.config.GuestAdditionsSHA256)
|
|
}
|
|
|
|
config["guest_additions_sha256"] = "FOO"
|
|
b = Builder{}
|
|
_, warns, err = b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("should not have error: %s", err)
|
|
}
|
|
|
|
if b.config.GuestAdditionsSHA256 != "foo" {
|
|
t.Fatalf("bad size: %s", b.config.GuestAdditionsSHA256)
|
|
}
|
|
}
|
|
|
|
func TestBuilderPrepare_GuestAdditionsURL(t *testing.T) {
|
|
var b Builder
|
|
config := testConfig()
|
|
|
|
config["guest_additions_url"] = ""
|
|
_, warns, err := b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("err: %s", err)
|
|
}
|
|
|
|
if b.config.GuestAdditionsURL != "" {
|
|
t.Fatalf("should be empty: %s", b.config.GuestAdditionsURL)
|
|
}
|
|
|
|
config["guest_additions_url"] = "http://www.packer.io"
|
|
b = Builder{}
|
|
_, warns, err = b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Errorf("should not have error: %s", err)
|
|
}
|
|
}
|
|
|
|
func TestBuilderPrepare_HardDriveInterface(t *testing.T) {
|
|
var b Builder
|
|
config := testConfig()
|
|
|
|
// Test a default boot_wait
|
|
delete(config, "hard_drive_interface")
|
|
_, warns, err := b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("err: %s", err)
|
|
}
|
|
|
|
if b.config.HardDriveInterface != "ide" {
|
|
t.Fatalf("bad: %s", b.config.HardDriveInterface)
|
|
}
|
|
|
|
// Test with a bad
|
|
config["hard_drive_interface"] = "fake"
|
|
b = Builder{}
|
|
_, warns, err = b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err == nil {
|
|
t.Fatal("should have error")
|
|
}
|
|
|
|
// Test with a good
|
|
config["hard_drive_interface"] = "sata"
|
|
b = Builder{}
|
|
_, warns, err = b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("should not have error: %s", err)
|
|
}
|
|
}
|
|
|
|
func TestBuilderPrepare_InvalidKey(t *testing.T) {
|
|
var b Builder
|
|
config := testConfig()
|
|
|
|
// Add a random key
|
|
config["i_should_not_be_valid"] = true
|
|
_, warns, err := b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err == nil {
|
|
t.Fatal("should have error")
|
|
}
|
|
}
|
|
|
|
func TestBuilderPrepare_ISOInterface(t *testing.T) {
|
|
var b Builder
|
|
config := testConfig()
|
|
|
|
// Test a default boot_wait
|
|
delete(config, "iso_interface")
|
|
_, warns, err := b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("err: %s", err)
|
|
}
|
|
|
|
if b.config.ISOInterface != "ide" {
|
|
t.Fatalf("bad: %s", b.config.ISOInterface)
|
|
}
|
|
|
|
// Test with a bad
|
|
config["iso_interface"] = "fake"
|
|
b = Builder{}
|
|
_, warns, err = b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err == nil {
|
|
t.Fatal("should have error")
|
|
}
|
|
|
|
// Test with a good
|
|
config["iso_interface"] = "sata"
|
|
b = Builder{}
|
|
_, warns, err = b.Prepare(config)
|
|
if len(warns) > 0 {
|
|
t.Fatalf("bad: %#v", warns)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("should not have error: %s", err)
|
|
}
|
|
}
|