github.com/rothwerx/packer@v0.9.0/builder/parallels/iso/builder_test.go (about)

     1  package iso
     2  
     3  import (
     4  	"github.com/mitchellh/packer/packer"
     5  	"testing"
     6  )
     7  
     8  func testConfig() map[string]interface{} {
     9  	return map[string]interface{}{
    10  		"iso_checksum":           "foo",
    11  		"iso_checksum_type":      "md5",
    12  		"iso_url":                "http://www.google.com/",
    13  		"shutdown_command":       "yes",
    14  		"ssh_username":           "foo",
    15  		"parallels_tools_flavor": "lin",
    16  
    17  		packer.BuildNameConfigKey: "foo",
    18  	}
    19  }
    20  
    21  func TestBuilder_ImplementsBuilder(t *testing.T) {
    22  	var raw interface{}
    23  	raw = &Builder{}
    24  	if _, ok := raw.(packer.Builder); !ok {
    25  		t.Error("Builder must implement builder.")
    26  	}
    27  }
    28  
    29  func TestBuilderPrepare_Defaults(t *testing.T) {
    30  	var b Builder
    31  	config := testConfig()
    32  	warns, err := b.Prepare(config)
    33  	if len(warns) > 0 {
    34  		t.Fatalf("bad: %#v", warns)
    35  	}
    36  	if err != nil {
    37  		t.Fatalf("should not have error: %s", err)
    38  	}
    39  
    40  	if b.config.GuestOSType != "other" {
    41  		t.Errorf("bad guest OS type: %s", b.config.GuestOSType)
    42  	}
    43  
    44  	if b.config.VMName != "packer-foo" {
    45  		t.Errorf("bad vm name: %s", b.config.VMName)
    46  	}
    47  }
    48  
    49  func TestBuilderPrepare_DiskSize(t *testing.T) {
    50  	var b Builder
    51  	config := testConfig()
    52  
    53  	delete(config, "disk_size")
    54  	warns, err := b.Prepare(config)
    55  	if len(warns) > 0 {
    56  		t.Fatalf("bad: %#v", warns)
    57  	}
    58  	if err != nil {
    59  		t.Fatalf("bad err: %s", err)
    60  	}
    61  
    62  	if b.config.DiskSize != 40000 {
    63  		t.Fatalf("bad size: %d", b.config.DiskSize)
    64  	}
    65  
    66  	config["disk_size"] = 60000
    67  	b = Builder{}
    68  	warns, err = b.Prepare(config)
    69  	if len(warns) > 0 {
    70  		t.Fatalf("bad: %#v", warns)
    71  	}
    72  	if err != nil {
    73  		t.Fatalf("should not have error: %s", err)
    74  	}
    75  
    76  	if b.config.DiskSize != 60000 {
    77  		t.Fatalf("bad size: %d", b.config.DiskSize)
    78  	}
    79  }
    80  
    81  func TestBuilderPrepare_HardDriveInterface(t *testing.T) {
    82  	var b Builder
    83  	config := testConfig()
    84  
    85  	// Test a default boot_wait
    86  	delete(config, "hard_drive_interface")
    87  	warns, err := b.Prepare(config)
    88  	if len(warns) > 0 {
    89  		t.Fatalf("bad: %#v", warns)
    90  	}
    91  	if err != nil {
    92  		t.Fatalf("err: %s", err)
    93  	}
    94  
    95  	if b.config.HardDriveInterface != "sata" {
    96  		t.Fatalf("bad: %s", b.config.HardDriveInterface)
    97  	}
    98  
    99  	// Test with a bad
   100  	config["hard_drive_interface"] = "fake"
   101  	b = Builder{}
   102  	warns, err = b.Prepare(config)
   103  	if len(warns) > 0 {
   104  		t.Fatalf("bad: %#v", warns)
   105  	}
   106  	if err == nil {
   107  		t.Fatal("should have error")
   108  	}
   109  
   110  	// Test with a good
   111  	config["hard_drive_interface"] = "scsi"
   112  	b = Builder{}
   113  	warns, err = b.Prepare(config)
   114  	if len(warns) > 0 {
   115  		t.Fatalf("bad: %#v", warns)
   116  	}
   117  	if err != nil {
   118  		t.Fatalf("should not have error: %s", err)
   119  	}
   120  }
   121  
   122  func TestBuilderPrepare_InvalidKey(t *testing.T) {
   123  	var b Builder
   124  	config := testConfig()
   125  
   126  	// Add a random key
   127  	config["i_should_not_be_valid"] = true
   128  	warns, err := b.Prepare(config)
   129  	if len(warns) > 0 {
   130  		t.Fatalf("bad: %#v", warns)
   131  	}
   132  	if err == nil {
   133  		t.Fatal("should have error")
   134  	}
   135  }