566 lines
15 KiB
Go
566 lines
15 KiB
Go
|
package dao
|
||
|
|
|
||
|
|
import (
|
||
|
|
"testing"
|
||
|
|
"time"
|
||
|
|
|
||
|
|
"go-common/app/admin/ep/merlin/model"
|
||
|
|
"go-common/library/log"
|
||
|
|
|
||
|
|
. "github.com/smartystreets/goconvey/convey"
|
||
|
|
)
|
||
|
|
|
||
|
|
var tMachine *model.Machine
|
||
|
|
|
||
|
|
func machineFunc(f func()) func() {
|
||
|
|
return func() {
|
||
|
|
beforeAllMT()
|
||
|
|
defer afterAllMT()
|
||
|
|
f()
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func beforeAllMT() {
|
||
|
|
var err error
|
||
|
|
tMachine = &model.Machine{
|
||
|
|
Name: "test-machine-1",
|
||
|
|
PodName: "test-machine-0-0",
|
||
|
|
Status: 100,
|
||
|
|
Username: "seanan",
|
||
|
|
BusinessUnit: "test",
|
||
|
|
Project: "ep",
|
||
|
|
App: "merlin",
|
||
|
|
ClusterID: 3,
|
||
|
|
NetworkID: 5,
|
||
|
|
Comment: "Unit test for the dao of merlin.",
|
||
|
|
DelayStatus: 0,
|
||
|
|
}
|
||
|
|
if err = d.db.Create(tMachine).Error; err != nil {
|
||
|
|
log.Error("Failed to init machine(%v) for test, err(%v)", tMachine, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = d.db.Create(&model.MachineNode{MachineID: tMachine.ID, BusinessUnit: tMachine.BusinessUnit, Project: tMachine.Project, App: tMachine.App, TreeID: 1234}).Error; err != nil {
|
||
|
|
log.Error("Failed to init machine node for test, err(%v)", tMachine, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func afterAllMT() {
|
||
|
|
var err error
|
||
|
|
if err = d.db.Where("name = ?", tMachine.Name).Delete(&model.Machine{}).Error; err != nil {
|
||
|
|
log.Error("Failed to delete machine(%v) for test, err(%v)", tMachine, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = d.db.Where("machine_id = ?", tMachine.ID).Delete(&model.MachineNode{}).Error; err != nil {
|
||
|
|
log.Error("Failed to delete machine node for test, err(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestFindExpiredMachineByDay(t *testing.T) {
|
||
|
|
Convey("The actualMachines must contain tMachine when deadline day is 0", t, machineFunc(func() {
|
||
|
|
var err error
|
||
|
|
if err = d.db.Model(&model.Machine{}).Where("id = ?", tMachine.ID).Update("end_time", time.Now()).Error; err != nil {
|
||
|
|
log.Error("Cannot update the end_time of tMachine")
|
||
|
|
return
|
||
|
|
}
|
||
|
|
actualMachines, err := d.FindExpiredMachineByDay(0)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
for _, m := range actualMachines {
|
||
|
|
if m.Name == tMachine.Name {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
So(true, ShouldBeFalse)
|
||
|
|
}))
|
||
|
|
|
||
|
|
Convey("The actualMachines must not contain tMachine when deadline day is not 0", t, machineFunc(func() {
|
||
|
|
var err error
|
||
|
|
if err = d.db.Model(&model.Machine{}).Where("id = ?", tMachine.ID).Update("end_time", time.Now()).Error; err != nil {
|
||
|
|
log.Error("Cannot update the end_time of tMachine")
|
||
|
|
return
|
||
|
|
}
|
||
|
|
actualMachines, err := d.FindExpiredMachineByDay(1)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
for _, m := range actualMachines {
|
||
|
|
if m.Name == tMachine.Name {
|
||
|
|
So(true, ShouldBeFalse)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}))
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestFindExpiredMachine(t *testing.T) {
|
||
|
|
Convey("The actualMachines must contain tMachine", t, machineFunc(func() {
|
||
|
|
var err error
|
||
|
|
if err = d.db.Model(&model.Machine{}).Where("id = ?", tMachine.ID).Update("end_time", time.Now().AddDate(0, 0, 1)).Error; err != nil {
|
||
|
|
log.Error("Cannot update the end_time of tMachine")
|
||
|
|
return
|
||
|
|
}
|
||
|
|
actualMachines, err := d.FindExpiredMachine()
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
for _, m := range actualMachines {
|
||
|
|
if m.Name == tMachine.Name {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
So(true, ShouldBeFalse)
|
||
|
|
}))
|
||
|
|
|
||
|
|
Convey("The actualMachines must not contain tMachine", t, machineFunc(func() {
|
||
|
|
actualMachines, err := d.FindExpiredMachine()
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
for _, m := range actualMachines {
|
||
|
|
if m.Name == tMachine.Name {
|
||
|
|
So(true, ShouldBeFalse)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}))
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestQueryMachine(t *testing.T) {
|
||
|
|
Convey("The actualMachines must be tMachine when id is the id of tMachine", t, machineFunc(func() {
|
||
|
|
actualMachines, err := d.QueryMachine(tMachine.ID)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
So(actualMachines.ID, ShouldEqual, tMachine.ID)
|
||
|
|
}))
|
||
|
|
|
||
|
|
Convey("The actualMachines must not be tMachine when id is not the id of tMachine", t, machineFunc(func() {
|
||
|
|
_, err := d.QueryMachine(0)
|
||
|
|
So(err, ShouldNotBeNil)
|
||
|
|
}))
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestDelMachine this test only need positive test because negative case is filtered by service
|
||
|
|
func TestDelMachine(t *testing.T) {
|
||
|
|
Convey("The tMachine must be delete", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
actual = &model.Machine{}
|
||
|
|
updateBy = "seanan"
|
||
|
|
)
|
||
|
|
err := d.DelMachine(tMachine.ID, updateBy)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
d.db.Where("id = ?", tMachine.ID).Find(actual)
|
||
|
|
So(actual.Status, ShouldEqual, model.RemovedMachineInMerlin)
|
||
|
|
So(actual.UpdateBy, ShouldEqual, updateBy)
|
||
|
|
}))
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestHasMachine HasMachine is fuzzy matching name which is end with -number
|
||
|
|
func TestHasMachine(t *testing.T) {
|
||
|
|
Convey("return true when machine existed", t, machineFunc(func() {
|
||
|
|
b, err := d.HasMachine("test-machine")
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
So(b, ShouldBeTrue)
|
||
|
|
}))
|
||
|
|
|
||
|
|
Convey("return false when machine does not exist", t, machineFunc(func() {
|
||
|
|
b, err := d.HasMachine("no-test-machine")
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
So(b, ShouldBeFalse)
|
||
|
|
}))
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUpdateMachineStatus(t *testing.T) {
|
||
|
|
Convey("The machine status must be boot", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
err error
|
||
|
|
actualMachine = &model.Machine{}
|
||
|
|
)
|
||
|
|
if err = d.db.Model(&model.Machine{}).Where("id = ?", tMachine.ID).Update("status", model.CreatingMachineInMerlin).Error; err != nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
err = d.UpdateMachineStatus(tMachine.ID, model.BootMachineInMerlin)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
if err = d.db.Where("id = ?", tMachine.ID).First(actualMachine).Error; err != nil {
|
||
|
|
log.Error("find machine err(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
So(actualMachine.Status, ShouldEqual, model.BootMachineInMerlin)
|
||
|
|
}))
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestQueryMachines(t *testing.T) {
|
||
|
|
Convey("Find the boot machines by names", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
err error
|
||
|
|
qmr = &model.QueryMachineRequest{
|
||
|
|
Pagination: model.Pagination{
|
||
|
|
PageSize: 5,
|
||
|
|
PageNum: 1,
|
||
|
|
},
|
||
|
|
}
|
||
|
|
names = []string{"test-machine-0-0"}
|
||
|
|
actualMachines []*model.Machine
|
||
|
|
)
|
||
|
|
_, actualMachines, err = d.QueryMachines(names, qmr)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
for _, m := range actualMachines {
|
||
|
|
if m.Name == tMachine.Name {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
So(true, ShouldBeFalse)
|
||
|
|
}))
|
||
|
|
|
||
|
|
Convey("Find the creating machines by requester", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
err error
|
||
|
|
qmr = &model.QueryMachineRequest{
|
||
|
|
Pagination: model.Pagination{
|
||
|
|
PageSize: 5,
|
||
|
|
PageNum: 1,
|
||
|
|
},
|
||
|
|
Requester: "seanan",
|
||
|
|
}
|
||
|
|
actualMachines []*model.Machine
|
||
|
|
)
|
||
|
|
if err = d.db.Model(&model.Machine{}).Where("id = ?", tMachine.ID).Update("status", model.CreatingMachineInMerlin).Error; err != nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
_, actualMachines, err = d.QueryMachines(nil, qmr)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
for _, m := range actualMachines {
|
||
|
|
if m.Name == tMachine.Name {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
So(true, ShouldBeFalse)
|
||
|
|
}))
|
||
|
|
|
||
|
|
Convey("Cannot find the creating machines by other requester", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
err error
|
||
|
|
qmr = &model.QueryMachineRequest{
|
||
|
|
Pagination: model.Pagination{
|
||
|
|
PageSize: 5,
|
||
|
|
PageNum: 1,
|
||
|
|
},
|
||
|
|
Requester: "other",
|
||
|
|
}
|
||
|
|
actualMachines []*model.Machine
|
||
|
|
)
|
||
|
|
if err = d.db.Model(&model.Machine{}).Where("id = ?", tMachine.ID).Update("status", model.CreatingMachineInMerlin).Error; err != nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
_, actualMachines, err = d.QueryMachines(nil, qmr)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
for _, m := range actualMachines {
|
||
|
|
if m.Name == tMachine.Name {
|
||
|
|
So(true, ShouldBeFalse)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}))
|
||
|
|
|
||
|
|
Convey("Find the machines filter by username", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
err error
|
||
|
|
qmr = &model.QueryMachineRequest{
|
||
|
|
Pagination: model.Pagination{
|
||
|
|
PageSize: 5,
|
||
|
|
PageNum: 1,
|
||
|
|
},
|
||
|
|
Username: "sean",
|
||
|
|
}
|
||
|
|
names = []string{"test-machine-0-0"}
|
||
|
|
actualMachines []*model.Machine
|
||
|
|
)
|
||
|
|
_, actualMachines, err = d.QueryMachines(names, qmr)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
for _, m := range actualMachines {
|
||
|
|
if m.Name == tMachine.Name {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
So(true, ShouldBeFalse)
|
||
|
|
}))
|
||
|
|
|
||
|
|
Convey("Find the machines filter by machine name", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
err error
|
||
|
|
qmr = &model.QueryMachineRequest{
|
||
|
|
Pagination: model.Pagination{
|
||
|
|
PageSize: 5,
|
||
|
|
PageNum: 1,
|
||
|
|
},
|
||
|
|
MachineName: "test-machine",
|
||
|
|
}
|
||
|
|
names = []string{"test-machine-0-0"}
|
||
|
|
actualMachines []*model.Machine
|
||
|
|
)
|
||
|
|
_, actualMachines, err = d.QueryMachines(names, qmr)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
for _, m := range actualMachines {
|
||
|
|
if m.Name == tMachine.Name {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
So(true, ShouldBeFalse)
|
||
|
|
}))
|
||
|
|
|
||
|
|
Convey("Find the machines filter by BusinessUnit", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
err error
|
||
|
|
qmr = &model.QueryMachineRequest{
|
||
|
|
Pagination: model.Pagination{
|
||
|
|
PageSize: 5,
|
||
|
|
PageNum: 1,
|
||
|
|
},
|
||
|
|
TreeNode: model.TreeNode{
|
||
|
|
BusinessUnit: "test",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
names = []string{"test-machine-0-0"}
|
||
|
|
actualMachines []*model.Machine
|
||
|
|
)
|
||
|
|
_, actualMachines, err = d.QueryMachines(names, qmr)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
for _, m := range actualMachines {
|
||
|
|
if m.Name == tMachine.Name {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
So(true, ShouldBeFalse)
|
||
|
|
}))
|
||
|
|
|
||
|
|
Convey("Find the machines filter by BusinessUnit and Project", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
err error
|
||
|
|
qmr = &model.QueryMachineRequest{
|
||
|
|
Pagination: model.Pagination{
|
||
|
|
PageSize: 5,
|
||
|
|
PageNum: 1,
|
||
|
|
},
|
||
|
|
TreeNode: model.TreeNode{
|
||
|
|
BusinessUnit: "test",
|
||
|
|
Project: "ep",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
names = []string{"test-machine-0-0"}
|
||
|
|
actualMachines []*model.Machine
|
||
|
|
)
|
||
|
|
_, actualMachines, err = d.QueryMachines(names, qmr)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
for _, m := range actualMachines {
|
||
|
|
if m.Name == tMachine.Name {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
So(true, ShouldBeFalse)
|
||
|
|
}))
|
||
|
|
|
||
|
|
Convey("Find the machines filter by BusinessUnit, Project and App", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
err error
|
||
|
|
qmr = &model.QueryMachineRequest{
|
||
|
|
Pagination: model.Pagination{
|
||
|
|
PageSize: 5,
|
||
|
|
PageNum: 1,
|
||
|
|
},
|
||
|
|
TreeNode: model.TreeNode{
|
||
|
|
BusinessUnit: "test",
|
||
|
|
Project: "ep",
|
||
|
|
App: "merlin",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
names = []string{"test-machine-0-0"}
|
||
|
|
actualMachines []*model.Machine
|
||
|
|
)
|
||
|
|
_, actualMachines, err = d.QueryMachines(names, qmr)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
for _, m := range actualMachines {
|
||
|
|
if m.Name == tMachine.Name {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
So(true, ShouldBeFalse)
|
||
|
|
}))
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUpdateMachineEndTime(t *testing.T) {
|
||
|
|
Convey("The EndTime and DelayStatus should be updated", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
actualMachine = &model.Machine{}
|
||
|
|
expectTime = time.Now().AddDate(0, 1, 0)
|
||
|
|
expectDelayStatus = 1
|
||
|
|
err error
|
||
|
|
)
|
||
|
|
err = d.UpdateMachineEndTime(tMachine.ID, expectDelayStatus, expectTime)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
if err = d.db.Where("id = ?", tMachine.ID).First(actualMachine).Error; err != nil {
|
||
|
|
log.Error("find machine err(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
So(actualMachine.EndTime.Format("2006-01-02 15:04:05"), ShouldEqual, expectTime.Format("2006-01-02 15:04:05"))
|
||
|
|
So(actualMachine.DelayStatus, ShouldEqual, expectDelayStatus)
|
||
|
|
}))
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUpdateMachineDelayStatus(t *testing.T) {
|
||
|
|
Convey("The DelayStatus should be updated", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
actualMachine = &model.Machine{}
|
||
|
|
expectDelayStatus = 1
|
||
|
|
err error
|
||
|
|
)
|
||
|
|
err = d.UpdateMachineDelayStatus(tMachine.ID, expectDelayStatus)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
if err = d.db.Where("id = ?", tMachine.ID).First(actualMachine).Error; err != nil {
|
||
|
|
log.Error("find machine err(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
So(actualMachine.DelayStatus, ShouldEqual, expectDelayStatus)
|
||
|
|
}))
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestQueryPathAndPodNamesMapping(t *testing.T) {
|
||
|
|
Convey("Find path and podNames mapping when the machine exceeds 20 minutes", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
pathAndPodNames map[string][]string
|
||
|
|
err error
|
||
|
|
)
|
||
|
|
if err = d.db.Model(&model.Machine{}).Where("id = ?", tMachine.ID).Update("status", model.CreatingMachineInMerlin).Update("ctime", time.Now().AddDate(0, 0, -1)).Error; err != nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
pathAndPodNames, err = d.QueryPathAndPodNamesMapping()
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
expectPath := tMachine.ToTreeNode().TreePath()
|
||
|
|
for _, pn := range pathAndPodNames[expectPath] {
|
||
|
|
if pn == tMachine.PodName {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
So(true, ShouldBeFalse)
|
||
|
|
}))
|
||
|
|
|
||
|
|
Convey("cannot find path and podNames mapping when the machine does not exceed 20 minutes", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
pathAndPodNames map[string][]string
|
||
|
|
err error
|
||
|
|
)
|
||
|
|
if err = d.db.Model(&model.Machine{}).Where("id = ?", tMachine.ID).Update("status", model.CreatingMachineInMerlin).Error; err != nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
pathAndPodNames, err = d.QueryPathAndPodNamesMapping()
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
expectPath := tMachine.ToTreeNode().TreePath()
|
||
|
|
for _, pn := range pathAndPodNames[expectPath] {
|
||
|
|
if pn == tMachine.PodName {
|
||
|
|
So(true, ShouldBeFalse)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}))
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUpdateMachineStatusByPodNames(t *testing.T) {
|
||
|
|
Convey("cannot find path and podNames mapping when the machine does not exceed 20 minutes", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
err error
|
||
|
|
actualMachine *model.Machine
|
||
|
|
expectStatus = model.BootMachineInMerlin
|
||
|
|
)
|
||
|
|
if err = d.db.Model(&model.Machine{}).Where("id = ?", tMachine.ID).Update("status", model.CreatingMachineInMerlin).Error; err != nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
err = d.UpdateMachineStatusByPodNames([]string{tMachine.PodName}, expectStatus)
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
if err = d.db.Where("id = ?", tMachine.ID).First(actualMachine).Error; err != nil {
|
||
|
|
log.Error("find machine err(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
So(actualMachine.Status, ShouldEqual, expectStatus)
|
||
|
|
}))
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestQueryMachinesByPodNames(t *testing.T) {
|
||
|
|
Convey("cannot find path and podNames mapping when the machine does not exceed 20 minutes", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
err error
|
||
|
|
actualMachines []*model.Machine
|
||
|
|
)
|
||
|
|
actualMachines, err = d.QueryMachinesByPodNames([]string{tMachine.PodName})
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
for _, m := range actualMachines {
|
||
|
|
if m.ID == tMachine.ID {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
So(true, ShouldBeFalse)
|
||
|
|
}))
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestInsertMachines(t *testing.T) {
|
||
|
|
Convey("Insert 2 machines", t, machineFunc(func() {
|
||
|
|
var (
|
||
|
|
testMachine2 = "test-machine-2"
|
||
|
|
testMachine3 = "test-machine-3"
|
||
|
|
ins = []*model.CreateInstance{
|
||
|
|
{
|
||
|
|
Instance: model.Instance{
|
||
|
|
InstanceName: testMachine2,
|
||
|
|
},
|
||
|
|
InstanceCreateStatus: model.CreatingMachineInPass,
|
||
|
|
}, {
|
||
|
|
Instance: model.Instance{
|
||
|
|
InstanceName: testMachine3,
|
||
|
|
},
|
||
|
|
InstanceCreateStatus: model.CreateFailedMachineInPaas,
|
||
|
|
},
|
||
|
|
}
|
||
|
|
u = "seanan"
|
||
|
|
gmr = &model.GenMachinesRequest{
|
||
|
|
Env: model.Env{
|
||
|
|
ClusterID: 1,
|
||
|
|
NetworkID: 1,
|
||
|
|
},
|
||
|
|
PaasMachine: model.PaasMachine{
|
||
|
|
Name: "test-machine",
|
||
|
|
Image: "test-Image",
|
||
|
|
CPURequest: 1000,
|
||
|
|
MemoryRequest: 1024,
|
||
|
|
DiskRequest: 20,
|
||
|
|
VolumnMount: "/data",
|
||
|
|
},
|
||
|
|
Nodes: []*model.Node{
|
||
|
|
{
|
||
|
|
BusinessUnit: "test",
|
||
|
|
Project: "ep",
|
||
|
|
App: "merlin",
|
||
|
|
TreeID: 1234,
|
||
|
|
},
|
||
|
|
},
|
||
|
|
Comment: "test",
|
||
|
|
Amount: 1,
|
||
|
|
}
|
||
|
|
err error
|
||
|
|
actualMachine []*model.Machine
|
||
|
|
flag = 0
|
||
|
|
)
|
||
|
|
err = d.InsertMachines(u, gmr, ins)
|
||
|
|
defer func() {
|
||
|
|
if err = d.db.Where("name IN (?)", []string{testMachine2, testMachine3}).Delete(&model.Machine{}).Error; err != nil {
|
||
|
|
log.Error("Failed to delete machine(%v) for test, err(%v)", tMachine, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}()
|
||
|
|
So(err, ShouldBeNil)
|
||
|
|
if err = d.db.Where("name IN (?)", []string{testMachine2, testMachine3}).Find(&actualMachine).Error; err != nil {
|
||
|
|
log.Error("Find machiens err(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for _, m := range actualMachine {
|
||
|
|
if m.Name == testMachine2 && m.Status == model.CreatingMachineInMerlin {
|
||
|
|
flag++
|
||
|
|
}
|
||
|
|
if m.Name == testMachine3 && m.Status == model.ImmediatelyFailedMachineInMerlin {
|
||
|
|
flag += 2
|
||
|
|
}
|
||
|
|
}
|
||
|
|
So(flag, ShouldEqual, 3)
|
||
|
|
}))
|
||
|
|
}
|