func TestVMs(t *testing.T) {
Convey("Given a mocked Vmrun Wrapper", t, func() {
vmrun := vmware.NewMockVmrun()
vmrun.RunningVMs = append(vmrun.RunningVMs, "/Volumes/VM_SB3/VMware/webbruegge.vmwarevm/webbruegge.vmx")
vmrun.RunningVMs = append(vmrun.RunningVMs, "/Volumes/VM_SB3/VMware/dockerbruegge1.vmwarevm/dockerbruegge1.vmx")
vmrun.RunningVMs = append(vmrun.RunningVMs, "/Volumes/VM_SB3/VMware/repoarchbruegge.vmwarevm/repoarchbruegge.vmx")
Convey("getRunningVMPaths should be able to parse all running vm paths", func() {
result, err := getRunningVMPaths(vmrun)
So(err, ShouldBeNil)
So(len(result), ShouldEqual, 3)
So(result[0], ShouldEqual, "/Volumes/VM_SB3/VMware/webbruegge.vmwarevm/webbruegge.vmx")
So(result[1], ShouldEqual, "/Volumes/VM_SB3/VMware/dockerbruegge1.vmwarevm/dockerbruegge1.vmx")
So(result[2], ShouldEqual, "/Volumes/VM_SB3/VMware/repoarchbruegge.vmwarevm/repoarchbruegge.vmx")
})
Convey("discoverVMsInDirectory should be able to discover vmx files in a directory", func() {
createTestVMsVmwareFolder()
defer deleteTestVMsVmwareFolder()
result, err := discoverVMs("/tmp/vmlcmvms/")
So(err, ShouldBeNil)
So(result, ShouldNotBeNil)
So(len(result), ShouldEqual, 2)
So(result[0], ShouldEqual, "/tmp/vmlcmvms/test1.vmwarevm/test1.vmx")
So(result[1], ShouldEqual, "/tmp/vmlcmvms/test2.vmwarevm/test2.vmx")
})
})
}
func TestSnapshots(t *testing.T) {
Convey("Given a mocked Vmrun Wrapper", t, func() {
vmrun := vmware.NewMockVmrun()
vmrun.TemplateVM = "/tmp/vmlcmverify/test.vmx"
vmrun.TemplateSnapshots = []string{
"SetUp",
"POM 2015",
}
config := new(util.LCMConfiguration)
config.ClonesDirectory = "/tmp/vmlcmverify/clones/"
config.TemplatePath = "/tmp/vmlcmverify/test.vmx"
config.Vmrun = "/tmp/vmlcmverify/vmrun"
config.Prefix = "Pom2015"
config.Addresses = []string{
"a1:b1:c1:d1:e1:f1",
"a2:b2:c2:d2:e2:f2",
}
Convey("getTemplateSnapshots should be able to parse the template snapshot names", func() {
snapshots, err := getTemplateSnapshots(vmrun, config)
So(err, ShouldBeNil)
So(snapshots, ShouldNotBeNil)
So(len(snapshots), ShouldEqual, 2)
So(snapshots[0], ShouldEqual, "SetUp")
So(snapshots[1], ShouldEqual, "POM 2015")
})
Convey("createTemplateSnapshot should be able to create a snapshot", func() {
_, err := createTemplateSnapshot(vmrun, config)
So(err, ShouldBeNil)
})
})
}
func TestStatus(t *testing.T) {
Convey("Given a mocked Vmrun Wrapper", t, func() {
vmrun := vmware.NewMockVmrun()
runningPaths := []string{
"/Volumes/VM_SB3/VMware/webbruegge.vmwarevm/webbruegge.vmx",
"/Volumes/VM_SB3/VMware/dockerbruegge1.vmwarevm/dockerbruegge1.vmx",
"/Volumes/VM_SB3/VMware/repoarchbruegge.vmwarevm/repoarchbruegge.vmx",
"/Volumes/VM_SB3/VMware/build-agents-reserve/buildagent-mac-5.vmwarevm/buildagent-mac-5.vmx",
"/Volumes/VM_SB3/VMware/LS1Cloud.vmwarevm/LS1Cloud.vmx",
"/Volumes/VM_SB3/VMware/build-agents-reserve/buildagent-mac-6.vmwarevm/buildagent-mac-6.vmx",
"/Volumes/VM_SB3/VMware/build-agents-reserve/buildagent-mac-4.vmwarevm/buildagent-mac-4.vmx",
"/Volumes/VM_SB3/VMware/backupbruegge.vmwarevm/backupbruegge.vmx",
"/Volumes/VM_SB3/VMware/build-agents-reserve/buildagent-mac-8.vmwarevm/buildagent-mac-8.vmx",
"/Volumes/VM_SB3/VMware/build-agents-reserve/buildagent-mac-7.vmwarevm/buildagent-mac-7.vmx",
"/Volumes/VM_SB3/VMware/mailbruegge.vmwarevm/mailbruegge.vmx",
"/Volumes/VM_SB3/VMware/webbruegge_prelive.vmwarevm/webbruegge_prelive.vmx",
"/Volumes/VM_SB3/VMware/monitorbruegge.vmwarevm/monitorbruegge.vmx",
}
for _, runningPath := range runningPaths {
vmrun.RunningVMs = append(vmrun.RunningVMs, runningPath)
}
clonePaths := []string{
"/tmp/vmlcmstatus/pom2015-a1b1c1d1e1f1.vmwarevm/pom2015-a1b1c1d1e1f1.vmx",
"/tmp/vmlcmstatus/pom2015-a2b2c2d2e2f2.vmwarevm/pom2015-a2b2c2d2e2f2.vmx",
"/tmp/vmlcmstatus/pom2015-a3b3c3d3e3f3.vmwarevm/pom2015-a3b3c3d3e3f3.vmx",
}
for _, clonePath := range clonePaths {
vmrun.CloneFolderVMs = append(vmrun.CloneFolderVMs, clonePath)
}
Convey("getVmrunVersion should be able to parse the version information", func() {
result, err := getVmrunVersion(vmrun)
So(err, ShouldBeNil)
So(result.version, ShouldEqual, "1.14.2")
So(result.build, ShouldEqual, "2779224")
})
Convey("getRunningVMNumber should be able to parse the number of running vms", func() {
result, err := getRunningVMNumber(vmrun)
So(err, ShouldBeNil)
So(result, ShouldEqual, 13)
})
Convey("getVMs should be able to detect all running vms and all vms in the clone directory", func() {
// Create folders
createTestStatusFolders()
defer deleteTestStatusFolders()
// Create configurations
config := new(util.LCMConfiguration)
config.Addresses = []string{
"a1b1c1d1e1f1",
"a2b2c2d2e2f2",
"a3b3c3d3e3f3",
"a4b4c4d4e4f4",
"a5b5c5d5e5f5",
"a6b6c6d6e6f6",
"a7b7c7d7e7f7",
}
config.ClonesDirectory = "/tmp/vmlcmstatus/"
config.Prefix = "pom2015"
config.TemplatePath = "/tmp/vmlcmstatus/pom2015-template.vmwarevm/pom2015-template.vmx"
// Now run getVMs and check for error first
vms, err := getVMs(vmrun, config)
So(err, ShouldBeNil)
So(vms, ShouldNotBeNil)
So(len(vms), ShouldEqual, 19)
vmMap := make(map[string]*virtualMachine)
// Build map with vms
for _, vm := range vms {
vmMap[vm.path] = vm
}
for _, path := range runningPaths {
vm, ok := vmMap[path]
So(ok, ShouldBeTrue)
So(vm, ShouldNotBeNil)
So(vm.running, ShouldBeTrue)
So(vm.template, ShouldBeFalse)
}
// Then check all clones
clonePaths := []string{
"/tmp/vmlcmstatus/pom2015-a1b1c1d1e1f1.vmwarevm/pom2015-a1b1c1d1e1f1.vmx",
"/tmp/vmlcmstatus/pom2015-a2b2c2d2e2f2.vmwarevm/pom2015-a2b2c2d2e2f2.vmx",
"/tmp/vmlcmstatus/pom2015-a3b3c3d3e3f3.vmwarevm/pom2015-a3b3c3d3e3f3.vmx",
"/tmp/vmlcmstatus/pom2015-a4b4c4d4e4f4.vmwarevm/pom2015-a4b4c4d4e4f4.vmx",
"/tmp/vmlcmstatus/pom2015-a5b5c5d5e5f5.vmwarevm/pom2015-a5b5c5d5e5f5.vmx",
}
for _, path := range clonePaths {
vm, ok := vmMap[path]
So(ok, ShouldBeTrue)
So(vm, ShouldNotBeNil)
So(vm.clone, ShouldBeTrue)
}
template, ok := vmMap["/tmp/vmlcmstatus/pom2015-template.vmwarevm/pom2015-template.vmx"]
So(ok, ShouldBeTrue)
So(template, ShouldNotBeNil)
So(template.clone, ShouldBeFalse)
So(template.running, ShouldBeFalse)
So(template.template, ShouldBeTrue)
})
})
}
func TestExecute(t *testing.T) {
Convey("Given a mock vmrun wrapper", t, func(context C) {
vmrun := vmware.NewMockVmrun()
vmrun.RunningVMs = append(vmrun.RunningVMs, "/Volumes/VM_SB3/VMware/webbruegge.vmwarevm/webbruegge.vmx")
Convey("Help() should return usage information and the version number", func() {
out, err := vmrun.Help()
So(out, ShouldNotBeNil)
So(out, ShouldContainSubstring, "vmrun version 1.14.2 build-2779224")
So(err, ShouldBeNil)
})
Convey("List() should return running vms", func() {
out, err := vmrun.List()
So(out, ShouldNotBeNil)
So(out, ShouldContainSubstring, "/Volumes/VM_SB3/VMware/webbruegge.vmwarevm/webbruegge.vmx")
So(err, ShouldBeNil)
})
Convey("CloneLinked() should correctly clone in a clean environment", func() {
vmrun.TemplateVM = "/tmp/vmlcmclones/pom2015-template.vmwarevm/pom2015-template.vmx"
vmrun.RunningVMs = []string{}
vmrun.CloneFolderVMs = []string{}
vmrun.TemplateSnapshots = []string{
"existing-snapshot-1",
"existing-snapshot-2",
}
vmrun.CloneLinked(
"/tmp/vmlcmclones/pom2015-template.vmwarevm/pom2015-template.vmx",
"/tmp/vmlcmclones/",
"pom2015-12345678",
"existing-snapshot-1")
So(vmrun.CloneFolderVMs, ShouldNotBeNil)
So(len(vmrun.CloneFolderVMs), ShouldEqual, 1)
So(vmrun.CloneFolderVMs[0], ShouldEqual,
"/tmp/vmlcmclones/pom2015-12345678.vmwarevm/pom2015-12345678.vmx")
})
Convey("CloneLinked() should return an error if vm exists", func() {
vmrun.TemplateVM = "/tmp/vmlcmclones/pom2015-template.vmwarevm/pom2015-template.vmx"
vmrun.RunningVMs = []string{}
vmrun.CloneFolderVMs = []string{
"/tmp/vmlcmclones/pom2015-12345678.vmwarevm/pom2015-12345678.vmx",
}
vmrun.TemplateSnapshots = []string{
"existing-snapshot-1",
"existing-snapshot-2",
}
err := vmrun.CloneLinked(
"/tmp/vmlcmclones/pom2015-template.vmwarevm/pom2015-template.vmx",
"/tmp/vmlcmclones/",
"pom2015-12345678",
"existing-snapshot-1")
So(err, ShouldNotBeNil)
})
Convey("CloneLinked() should return an error if snapshot does not exist", func() {
vmrun.TemplateVM = "/tmp/vmlcmclones/pom2015-template.vmwarevm/pom2015-template.vmx"
vmrun.RunningVMs = []string{}
vmrun.CloneFolderVMs = []string{}
vmrun.TemplateSnapshots = []string{
"existing-snapshot-1",
"existing-snapshot-2",
}
err := vmrun.CloneLinked(
"/tmp/vmlcmclones/pom2015-template.vmwarevm/pom2015-template.vmx",
"/tmp/vmlcmclones/",
"pom2015-12345678",
"not-existing-snapshot")
So(err, ShouldNotBeNil)
})
Convey("CloneLinked() should return an error if template does not exist", func() {
vmrun.TemplateVM = "/tmp/vmlcmclones/pom2015-template.vmwarevm/pom2015-template.vmx"
vmrun.RunningVMs = []string{}
vmrun.CloneFolderVMs = []string{}
vmrun.TemplateSnapshots = []string{
"existing-snapshot-1",
"existing-snapshot-2",
}
err := vmrun.CloneLinked(
"/not/existing",
"/tmp/vmlcmclones/",
"pom2015-12345678",
"not-existing-snapshot")
So(err, ShouldNotBeNil)
})
})
}
func TestClones(t *testing.T) {
Convey("Given a mocked Vmrun Wrapper", t, func() {
createTestClonesFolders()
defer deleteTestClonesFolders()
// Prepare mock vmrun
vmrun := vmware.NewMockVmrun()
vmrun.TemplateVM = "/tmp/vmlcmclones/pom2015-template.vmwarevm/pom2015-template.vmx"
vm1 := new(virtualMachine)
vm2 := new(virtualMachine)
vm3 := new(virtualMachine)
vm1.path = "/foo/bar/pom2015-A1B1C1D1E1F1.vmwarevm/pom2015-A1B1C1D1E1F1.vmx"
vm2.path = "/foo/bar/pom2015-A2B2C2D2E2F2.vmwarevm/pom2015-A2B2C2D2E2F2.vmx"
vm3.path = "/foo/bar/pom2015-A3B3C3D3E3F3.vmwarevm/pom2015-A3B3C3D3E3F3.vmx"
clones := []*virtualMachine{
vm1,
vm2,
vm3,
}
vmrun.CloneFolderVMs = []string{
"/foo/bar/pom2015-A1B1C1D1E1F1.vmwarevm/pom2015-A1B1C1D1E1F1.vmx",
"/foo/bar/pom2015-A2B2C2D2E2F2.vmwarevm/pom2015-A2B2C2D2E2F2.vmx",
"/foo/bar/pom2015-A3B3C3D3E3F3.vmwarevm/pom2015-A3B3C3D3E3F3.vmx",
}
// Prepare config
config := new(util.LCMConfiguration)
config.Vmrun = "/Applications/VMware Fusion.app/Contents/Library/vmrun"
config.Prefix = "pom2015"
config.ClonesDirectory = "/tmp/vmlcmclones/"
config.TemplatePath = "/tmp/vmlcmclones/pom2015-template.vmwarevm/pom2015-template.vmx"
config.Vmrun = ""
config.Addresses = []string{
"a1:b1:c1:d1:e1:f1",
"a2:b2:c2:d2:e2:f2",
"a3:b3:c3:d3:e3:f3",
"a4:b4:c4:d4:e4:f4",
"a5:b5:c5:d5:e5:f5",
}
for i, address := range config.Addresses {
config.Addresses[i] = strings.ToUpper(address)
}
// Check mac addresses
available := getAvailableMacAddresses(clones, config)
So(available, ShouldNotBeNil)
So(len(available), ShouldEqual, 2)
// Test getAvailableMacAddresses
Convey("getAvailableMacAddresses should only return available MAC addresses", func() {
// 2 available
available := getAvailableMacAddresses(clones, config)
So(available, ShouldNotBeNil)
So(len(available), ShouldEqual, 2)
// 1 available
config.Addresses = config.Addresses[0:4]
available = getAvailableMacAddresses(clones, config)
So(len(available), ShouldEqual, 1)
// 0 available
config.Addresses = config.Addresses[0:3]
available = getAvailableMacAddresses(clones, config)
So(len(available), ShouldEqual, 0)
// -1 available
config.Addresses = config.Addresses[0:2]
available = getAvailableMacAddresses(clones, config)
So(len(available), ShouldEqual, 0)
// None provided
config.Addresses = []string{}
available = getAvailableMacAddresses(clones, config)
So(len(available), ShouldEqual, 0)
})
Convey("cloneUpTo should clone no VM if up < existing", func() {
created, err := cloneUpTo(vmrun, config, clones, 3)
So(err, ShouldBeNil)
So(created, ShouldNotBeNil)
So(len(created), ShouldEqual, 0)
created, err = cloneUpTo(vmrun, config, clones, 2)
So(err, ShouldBeNil)
So(created, ShouldNotBeNil)
So(len(created), ShouldEqual, 0)
created, err = cloneUpTo(vmrun, config, clones, 1)
So(err, ShouldBeNil)
So(created, ShouldNotBeNil)
So(len(created), ShouldEqual, 0)
created, err = cloneUpTo(vmrun, config, clones, 0)
So(err, ShouldBeNil)
So(created, ShouldNotBeNil)
So(len(created), ShouldEqual, 0)
created, err = cloneUpTo(vmrun, config, clones, -10)
So(err, ShouldBeNil)
So(created, ShouldNotBeNil)
So(len(created), ShouldEqual, 0)
})
Convey("cloneUpTo should correctly create 1 clone if allowed", func() {
So(len(vmrun.TemplateSnapshots), ShouldEqual, 0)
created, err := cloneUpTo(vmrun, config, clones, 4)
So(err, ShouldBeNil)
// Check cloneUpTo result array
So(created, ShouldNotBeNil)
So(len(created), ShouldEqual, 1)
So(created[0], ShouldEqual, fmt.Sprintf(
"%s-%s", config.Prefix, "A4B4C4D4E4F4"))
// Check vmrun CloneFolder
So(len(vmrun.CloneFolderVMs), ShouldEqual, 4)
path := fmt.Sprintf("/tmp/vmlcmclones/%s-%s.vmwarevm/%s-%s.vmx",
config.Prefix, "A4B4C4D4E4F4", config.Prefix, "A4B4C4D4E4F4")
So(vmrun.CloneFolderVMs[3], ShouldEqual, path)
// Check created snapshot
So(vmrun.TemplateSnapshots, ShouldNotBeNil)
So(len(vmrun.TemplateSnapshots), ShouldEqual, 1)
So(vmrun.TemplateSnapshots[0], ShouldContainSubstring, config.Prefix)
})
Convey("cloneUpTo should correctly create 2 clones if allowed", func() {
created, err := cloneUpTo(vmrun, config, clones, 5)
So(err, ShouldBeNil)
// Check cloneUpTo result array
So(created, ShouldNotBeNil)
So(len(created), ShouldEqual, 2)
So(created[0], ShouldEqual, fmt.Sprintf(
"%s-%s", config.Prefix, "A4B4C4D4E4F4"))
So(created[1], ShouldEqual, fmt.Sprintf(
"%s-%s", config.Prefix, "A5B5C5D5E5F5"))
// Check vmrun CloneFolder
path := fmt.Sprintf("/tmp/vmlcmclones/%s-%s.vmwarevm/%s-%s.vmx",
config.Prefix, "A4B4C4D4E4F4", config.Prefix, "A4B4C4D4E4F4")
So(vmrun.CloneFolderVMs[3], ShouldEqual, path)
path = fmt.Sprintf("/tmp/vmlcmclones/%s-%s.vmwarevm/%s-%s.vmx",
config.Prefix, "A5B5C5D5E5F5", config.Prefix, "A5B5C5D5E5F5")
So(vmrun.CloneFolderVMs[4], ShouldEqual, path)
// Check created snapshot
So(vmrun.TemplateSnapshots, ShouldNotBeNil)
So(len(vmrun.TemplateSnapshots), ShouldEqual, 1)
So(vmrun.TemplateSnapshots[0], ShouldContainSubstring, config.Prefix)
})
Convey("cloneUpTo should create only 2 clones even though 3 are demanded", func() {
created, err := cloneUpTo(vmrun, config, clones, 6)
So(err, ShouldBeNil)
// Check cloneUpTo result array
So(created, ShouldNotBeNil)
So(len(created), ShouldEqual, 2)
So(created[0], ShouldEqual, fmt.Sprintf(
"%s-%s", config.Prefix, "A4B4C4D4E4F4"))
So(created[1], ShouldEqual, fmt.Sprintf(
"%s-%s", config.Prefix, "A5B5C5D5E5F5"))
// Check vmrun CloneFolder
path := fmt.Sprintf("/tmp/vmlcmclones/%s-%s.vmwarevm/%s-%s.vmx",
config.Prefix, "A4B4C4D4E4F4", config.Prefix, "A4B4C4D4E4F4")
So(vmrun.CloneFolderVMs[3], ShouldEqual, path)
path = fmt.Sprintf("/tmp/vmlcmclones/%s-%s.vmwarevm/%s-%s.vmx",
config.Prefix, "A5B5C5D5E5F5", config.Prefix, "A5B5C5D5E5F5")
So(vmrun.CloneFolderVMs[4], ShouldEqual, path)
// Check created snapshot
So(vmrun.TemplateSnapshots, ShouldNotBeNil)
So(len(vmrun.TemplateSnapshots), ShouldEqual, 1)
So(vmrun.TemplateSnapshots[0], ShouldContainSubstring, config.Prefix)
})
Convey("cloneUpTo should create a snapshot if only invalid snapshots are existing", func() {
vmrun.TemplateSnapshots = []string{
"existing-but-wrong-snapshot-1",
"existing-but-wrong-snapshot-2",
}
_, err := cloneUpTo(vmrun, config, clones, 5)
So(err, ShouldBeNil)
// Check created snapshot
So(vmrun.TemplateSnapshots, ShouldNotBeNil)
So(len(vmrun.TemplateSnapshots), ShouldEqual, 3)
So(vmrun.TemplateSnapshots[2], ShouldContainSubstring, config.Prefix)
})
Convey("cloneUpTo should not create a snapshot if a valid exists", func() {
vmrun.TemplateSnapshots = []string{
"existing-but-wrong-snapshot-1",
"existing-but-wrong-snapshot-2",
fmt.Sprintf("%s-1234567", config.Prefix),
}
_, err := cloneUpTo(vmrun, config, clones, 5)
So(err, ShouldBeNil)
So(vmrun.TemplateSnapshots, ShouldNotBeNil)
So(len(vmrun.TemplateSnapshots), ShouldEqual, 3)
})
})
}
func TestVerification(t *testing.T) {
Convey("Given a verification controller", t, func(context C) {
// $REPO/samples/config
Convey("isValidMacAddress should identify valid mac addresses", func() {
So(isValidMacAddress("a1:b1:c1:d1:e1:f1"), ShouldBeTrue)
So(isValidMacAddress("11:22:33:44:55:66"), ShouldBeTrue)
})
Convey("isValidMacAddress should detect invalid mac addresses", func() {
So(isValidMacAddress(""), ShouldBeFalse)
So(isValidMacAddress(":"), ShouldBeFalse)
So(isValidMacAddress("a1:b1:c1:d1:e1"), ShouldBeFalse)
})
Convey("isAbsolutePath should identify valid absolute paths", func() {
So(isAbsolutePath("/"), ShouldBeTrue)
So(isAbsolutePath("/blabla/foo/32/bar.xyz/.4"), ShouldBeTrue)
})
Convey("isAbsolutePath should detect invalid absolute paths", func() {
So(isAbsolutePath("./"), ShouldBeFalse)
So(isAbsolutePath("foo"), ShouldBeFalse)
So(isAbsolutePath(".foo"), ShouldBeFalse)
So(isAbsolutePath("./blabla/foo/32/bar.xyz/.4"), ShouldBeFalse)
})
Convey("isValidPath should identify valid absolute paths", func() {
So(isValidPath("/tmp"), ShouldBeTrue)
So(isValidPath("/tmp/"), ShouldBeTrue)
})
Convey("isValidPath should detect invalid absolute paths", func() {
So(isValidPath("./"), ShouldBeFalse)
So(isValidPath("foo"), ShouldBeFalse)
So(isValidPath("/not/existing/path"), ShouldBeFalse)
So(isValidPath("../samples/config/valid1.json"), ShouldBeFalse)
})
})
Convey("Verify should successfully verify various configurations", t, func() {
createTestVerifyFolders()
createTestVerifyTemplate()
createTestVerifyVmrun()
defer deleteTestVerifyFolders()
vmrun := vmware.NewMockVmrun()
config := new(util.LCMConfiguration)
config.ClonesDirectory = "/tmp/vmlcmverify/clones/"
config.TemplatePath = "/tmp/vmlcmverify/test.vmx"
config.Vmrun = "/tmp/vmlcmverify/vmrun"
config.Prefix = "Pom2015"
config.Addresses = []string{
"a1:b1:c1:d1:e1:f1",
"a2:b2:c2:d2:e2:f2",
}
// Success
err := Verify(nil, vmrun, config)
So(err, ShouldBeNil)
// Adding invalid MAC address
config.Addresses = append(config.Addresses, "keine_valide_mac")
err = Verify(nil, vmrun, config)
So(err, ShouldNotBeNil)
// Vmrun deletion
config.Addresses = config.Addresses[:len(config.Addresses)-1]
os.Remove("/tmp/vmlcmverify/vmrun")
err = Verify(nil, vmrun, config)
So(err, ShouldNotBeNil)
// Template deletion
createTestVerifyVmrun()
os.Remove("/tmp/vmlcmverify/test.vmx")
err = Verify(nil, vmrun, config)
So(err, ShouldNotBeNil)
// Clones directory deletion
createTestVerifyTemplate()
os.Remove("/tmp/vmlcmverify/clones")
err = Verify(nil, vmrun, config)
So(err, ShouldNotBeNil)
// Invalid template file extension
createTestVerifyFolders()
os.Remove("/tmp/vmlcmverify/test.vmx")
ioutil.WriteFile("/tmp/vmlcmverify/test", []byte(""), 0644)
config.TemplatePath = "/tmp/vmlcmverify/test"
err = Verify(nil, vmrun, config)
So(err, ShouldNotBeNil)
// File as clone folder
os.Remove("/tmp/vmlcmverify/test")
createTestVerifyTemplate()
config.TemplatePath = "/tmp/vmlcmverify/test.vmx"
os.Remove("/tmp/vmlcmverify/clones")
ioutil.WriteFile("/tmp/vmlcmverify/clones", []byte(""), 0644)
err = Verify(nil, vmrun, config)
So(err, ShouldNotBeNil)
})
}