From 4b5793806b85b63498be88630f28a49abcead9cf Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Thu, 13 Aug 2026 23:32:00 +0200 Subject: [PATCH 1/3] f-37: code: add state lib in vm, subnet and vpc #37 Signed-off-by: GnomeZworc --- internal/subnet/create.go | 8 ++++---- internal/subnet/delete.go | 7 ++++--- internal/vm/create.go | 8 ++++---- internal/vm/delete.go | 8 ++++---- internal/vpc/create.go | 8 ++++---- internal/vpc/delete.go | 8 ++++---- 6 files changed, 24 insertions(+), 23 deletions(-) diff --git a/internal/subnet/create.go b/internal/subnet/create.go index a3faf46..75ef62e 100644 --- a/internal/subnet/create.go +++ b/internal/subnet/create.go @@ -7,18 +7,18 @@ import ( "git.g3e.fr/syonad/two/internal/ebtables" "git.g3e.fr/syonad/two/internal/netif" "git.g3e.fr/syonad/two/internal/netns" - "git.g3e.fr/syonad/two/pkg/db/kv" + "git.g3e.fr/syonad/two/internal/state" "git.g3e.fr/syonad/two/pkg/systemd" "github.com/dgraph-io/badger/v4" ) func CreateSubnet(db *badger.DB, subnetName string) error { - state, err := kv.GetFromDB(db, "subnet/"+subnetName+"/state") + current, err := state.Get(db, "subnet/"+subnetName) if err != nil { return err } - if state != "creating" { + if current != state.Creating { return nil } @@ -31,7 +31,7 @@ func CreateSubnet(db *badger.DB, subnetName string) error { return err } - return kv.AddInDB(db, "subnet/"+subnetName+"/state", "created") + return state.Set(db, "subnet/"+subnetName, state.Running) } func createSubnet(db *badger.DB, subnetName string, d subnetData) error { diff --git a/internal/subnet/delete.go b/internal/subnet/delete.go index f745eda..1175fd5 100644 --- a/internal/subnet/delete.go +++ b/internal/subnet/delete.go @@ -7,6 +7,7 @@ import ( "git.g3e.fr/syonad/two/internal/ebtables" "git.g3e.fr/syonad/two/internal/netif" "git.g3e.fr/syonad/two/internal/netns" + "git.g3e.fr/syonad/two/internal/state" "git.g3e.fr/syonad/two/pkg/db/kv" "git.g3e.fr/syonad/two/pkg/systemd" @@ -14,11 +15,11 @@ import ( ) func DeleteSubnet(db *badger.DB, subnetName string) error { - state, err := kv.GetFromDB(db, "subnet/"+subnetName+"/state") + current, err := state.Get(db, "subnet/"+subnetName) if err != nil { return err } - if state != "deleting" { + if current != state.Deleting { return nil } @@ -44,7 +45,7 @@ func DeleteSubnet(db *badger.DB, subnetName string) error { return fmt.Errorf("unknown subnet mode %q", d.mode) } - return kv.AddInDB(db, "subnet/"+subnetName+"/state", "deleted") + return state.Set(db, "subnet/"+subnetName, state.Deleted) } func stopDHCP(db *badger.DB, subnetName string, d subnetData) error { diff --git a/internal/vm/create.go b/internal/vm/create.go index 3e0d4a7..74ed0bb 100644 --- a/internal/vm/create.go +++ b/internal/vm/create.go @@ -12,17 +12,17 @@ import ( "git.g3e.fr/syonad/two/internal/netif" "git.g3e.fr/syonad/two/internal/netns" "git.g3e.fr/syonad/two/internal/qemu" - "git.g3e.fr/syonad/two/pkg/db/kv" + "git.g3e.fr/syonad/two/internal/state" "github.com/dgraph-io/badger/v4" ) func StartVM(db *badger.DB, name string, cfg *configuration.Config) error { - state, err := kv.GetFromDB(db, "vm/"+name+"/state") + current, err := state.Get(db, "vm/"+name) if err != nil { return err } - if state != "starting" { + if current != state.Creating { return nil } @@ -84,7 +84,7 @@ func StartVM(db *badger.DB, name string, cfg *configuration.Config) error { return fmt.Errorf("start qemu: %w", err) } - return kv.AddInDB(db, "vm/"+name+"/state", "started") + return state.Set(db, "vm/"+name, state.Running) } func copyFile(src, dst string) error { diff --git a/internal/vm/delete.go b/internal/vm/delete.go index 3d808e6..f1490f0 100644 --- a/internal/vm/delete.go +++ b/internal/vm/delete.go @@ -12,17 +12,17 @@ import ( "git.g3e.fr/syonad/two/internal/netif" "git.g3e.fr/syonad/two/internal/netns" "git.g3e.fr/syonad/two/internal/qmp" - "git.g3e.fr/syonad/two/pkg/db/kv" + "git.g3e.fr/syonad/two/internal/state" "github.com/dgraph-io/badger/v4" ) func StopVM(db *badger.DB, name string, cfg *configuration.Config) error { - state, err := kv.GetFromDB(db, "vm/"+name+"/state") + current, err := state.Get(db, "vm/"+name) if err != nil { return err } - if state != "stopping" { + if current != state.Deleting { return nil } @@ -65,7 +65,7 @@ func StopVM(db *badger.DB, name string, cfg *configuration.Config) error { os.Remove(varsPath) } - return kv.AddInDB(db, "vm/"+name+"/state", "stopped") + return state.Set(db, "vm/"+name, state.Deleted) } func waitQMPDead(socketPath string, timeout, poll time.Duration) { diff --git a/internal/vpc/create.go b/internal/vpc/create.go index 148f70c..52e2567 100644 --- a/internal/vpc/create.go +++ b/internal/vpc/create.go @@ -5,15 +5,15 @@ import ( "git.g3e.fr/syonad/two/internal/netif" "git.g3e.fr/syonad/two/internal/netns" - "git.g3e.fr/syonad/two/pkg/db/kv" + "git.g3e.fr/syonad/two/internal/state" "github.com/dgraph-io/badger/v4" ) func CreateVPC(db *badger.DB, name string) error { - if state, err := kv.GetFromDB(db, "vpc/"+name+"/state"); err != nil { + if current, err := state.Get(db, "vpc/"+name); err != nil { return err - } else if state == "creating" { + } else if current == state.Creating { vpcID := strings.SplitN(name, "-", 2)[1] if err := netns.Create(name); err != nil { @@ -48,7 +48,7 @@ func CreateVPC(db *badger.DB, name string) error { }); err != nil { return err } - kv.AddInDB(db, "vpc/"+name+"/state", "created") + return state.Set(db, "vpc/"+name, state.Running) } return nil } diff --git a/internal/vpc/delete.go b/internal/vpc/delete.go index dbd3a59..ff4d83f 100644 --- a/internal/vpc/delete.go +++ b/internal/vpc/delete.go @@ -5,15 +5,15 @@ import ( "git.g3e.fr/syonad/two/internal/netif" "git.g3e.fr/syonad/two/internal/netns" - "git.g3e.fr/syonad/two/pkg/db/kv" + "git.g3e.fr/syonad/two/internal/state" "github.com/dgraph-io/badger/v4" ) func DeleteVPC(db *badger.DB, name string) error { - if state, err := kv.GetFromDB(db, "vpc/"+name+"/state"); err != nil { + if current, err := state.Get(db, "vpc/"+name); err != nil { return err - } else if state == "deleting" { + } else if current == state.Deleting { vpcID := strings.SplitN(name, "-", 2)[1] if err := netif.DeleteLink("vp-" + vpcID + "-e"); err != nil { @@ -23,7 +23,7 @@ func DeleteVPC(db *badger.DB, name string) error { if err := netns.Delete(name); err != nil { return err } - kv.AddInDB(db, "vpc/"+name+"/state", "deleted") + return state.Set(db, "vpc/"+name, state.Deleted) } return nil From 576166f3f1df8dd83961206177d8fbd9e4be2338 Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Thu, 13 Aug 2026 23:37:46 +0200 Subject: [PATCH 2/3] f-37: code: use state and check state #37 Signed-off-by: GnomeZworc --- internal/dispatcher/agent/subnet_commands.go | 28 ++++++---- .../dispatcher/agent/subnet_commands_test.go | 50 +++++++++++++---- internal/dispatcher/agent/vm_commands.go | 28 ++++++---- internal/dispatcher/agent/vm_commands_test.go | 55 +++++++++++++++++-- internal/dispatcher/agent/vpc_commands.go | 23 +++++--- .../dispatcher/agent/vpc_commands_test.go | 47 ++++++++++++++-- 6 files changed, 179 insertions(+), 52 deletions(-) diff --git a/internal/dispatcher/agent/subnet_commands.go b/internal/dispatcher/agent/subnet_commands.go index a73ab2b..6033a40 100644 --- a/internal/dispatcher/agent/subnet_commands.go +++ b/internal/dispatcher/agent/subnet_commands.go @@ -6,6 +6,7 @@ import ( "time" configuration "git.g3e.fr/syonad/two/internal/config/agent" + "git.g3e.fr/syonad/two/internal/state" "git.g3e.fr/syonad/two/internal/subnet" "git.g3e.fr/syonad/two/pkg/db/kv" "github.com/dgraph-io/badger/v4" @@ -34,18 +35,18 @@ func (c CreateSubnetCommand) Prepare(db *badger.DB, cfg *configuration.Config) e if _, err := kv.GetFromDB(db, "subnet/"+c.Name+"/state"); err == nil { return fmt.Errorf("subnet %q already exists", c.Name) } - vpcState, err := kv.GetFromDB(db, "vpc/"+c.VPC+"/state") + vpcState, err := state.Get(db, "vpc/"+c.VPC) if err != nil { return fmt.Errorf("vpc %q not found", c.VPC) } - if vpcState == "deleting" || vpcState == "deleted" { + if vpcState != state.Creating && vpcState != state.Running { return fmt.Errorf("vpc %q is %s", c.VPC, vpcState) } localIface, ok := cfg.Interfaces[c.IfaceType] if !ok { localIface = cfg.DefaultInterface } - kv.AddInDB(db, "subnet/"+c.Name+"/state", "creating") + state.Set(db, c.Key(), state.Creating) kv.AddInDB(db, "subnet/"+c.Name+"/vpc", c.VPC) kv.AddInDB(db, "subnet/"+c.Name+"/mode", c.Mode) kv.AddInDB(db, "subnet/"+c.Name+"/local_iface", localIface) @@ -61,16 +62,19 @@ func (c CreateSubnetCommand) Prepare(db *badger.DB, cfg *configuration.Config) e func (c CreateSubnetCommand) Execute(db *badger.DB, cfg *configuration.Config) error { timeout := time.After(time.Duration(cfg.Dispatcher.TimeoutSeconds) * time.Second) for { - state, err := kv.GetFromDB(db, "vpc/"+c.VPC+"/state") + vpcState, err := state.Get(db, "vpc/"+c.VPC) if err != nil { return fmt.Errorf("vpc %q not found while waiting", c.VPC) } - if state == "created" { + if vpcState == state.Running { break } + if vpcState != state.Creating { + return fmt.Errorf("vpc %q is %s, cannot create subnet %q", c.VPC, vpcState, c.Name) + } select { case <-timeout: - return fmt.Errorf("timed out waiting for vpc %q to be created", c.VPC) + return fmt.Errorf("timed out waiting for vpc %q to be running", c.VPC) case <-time.After(time.Duration(cfg.Dispatcher.PollSeconds) * time.Second): } } @@ -84,21 +88,25 @@ type DeleteSubnetCommand struct { func (c DeleteSubnetCommand) Key() string { return "subnet/" + c.Name } func (c DeleteSubnetCommand) Prepare(db *badger.DB, _ *configuration.Config) error { - if _, err := kv.GetFromDB(db, "subnet/"+c.Name+"/state"); err != nil { + current, err := state.Get(db, c.Key()) + if err != nil { return fmt.Errorf("subnet %q not found", c.Name) } - return kv.AddInDB(db, "subnet/"+c.Name+"/state", "deleting") + if !state.CanDelete(current) { + return fmt.Errorf("subnet %q cannot be deleted while %s", c.Name, current) + } + return state.Set(db, c.Key(), state.Deleting) } func (c DeleteSubnetCommand) Execute(db *badger.DB, _ *configuration.Config) error { if err := subnet.DeleteSubnet(db, c.Name); err != nil { return err } - state, err := kv.GetFromDB(db, "subnet/"+c.Name+"/state") + current, err := state.Get(db, c.Key()) if err != nil { return err } - if state == "deleted" { + if current == state.Deleted { kv.DeleteInDB(db, "subnet/"+c.Name) } return nil diff --git a/internal/dispatcher/agent/subnet_commands_test.go b/internal/dispatcher/agent/subnet_commands_test.go index b6aacee..645f620 100644 --- a/internal/dispatcher/agent/subnet_commands_test.go +++ b/internal/dispatcher/agent/subnet_commands_test.go @@ -17,7 +17,7 @@ func testCfg() *configuration.Config { func TestCreateSubnetCommand_Prepare_Success(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") cmd := CreateSubnetCommand{ Name: "sn-1", VPC: "vpc-1", VxlanID: 100, IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24", @@ -37,7 +37,7 @@ func TestCreateSubnetCommand_Prepare_Success(t *testing.T) { func TestCreateSubnetCommand_Prepare_UsesIfaceTypeMapping(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") cmd := CreateSubnetCommand{ Name: "sn-1", VPC: "vpc-1", VxlanID: 100, IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24", @@ -51,7 +51,7 @@ func TestCreateSubnetCommand_Prepare_UsesIfaceTypeMapping(t *testing.T) { func TestCreateSubnetCommand_Prepare_UsesDefaultIfaceWhenTypeUnknown(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") cmd := CreateSubnetCommand{ Name: "sn-1", VPC: "vpc-1", VxlanID: 100, IfaceType: "inconnu", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24", @@ -65,8 +65,8 @@ func TestCreateSubnetCommand_Prepare_UsesDefaultIfaceWhenTypeUnknown(t *testing. func TestCreateSubnetCommand_Prepare_Duplicate(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") - kv.AddInDB(db, "subnet/sn-exist/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") + kv.AddInDB(db, "subnet/sn-exist/state", "running") cmd := CreateSubnetCommand{ Name: "sn-exist", VPC: "vpc-1", VxlanID: 100, IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24", @@ -113,7 +113,7 @@ func TestCreateSubnetCommand_Prepare_VPCDeleted(t *testing.T) { func TestCreateSubnetCommand_Prepare_DefaultsToVxlanMode(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") cmd := CreateSubnetCommand{ Name: "sn-1", VPC: "vpc-1", VxlanID: 100, IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24", @@ -130,7 +130,7 @@ func TestCreateSubnetCommand_Prepare_DefaultsToVxlanMode(t *testing.T) { func TestCreateSubnetCommand_Prepare_BridgeMode_Success(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") cmd := CreateSubnetCommand{ Name: "sn-1", VPC: "vpc-1", Mode: "bridge", IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24", @@ -150,7 +150,7 @@ func TestCreateSubnetCommand_Prepare_BridgeMode_Success(t *testing.T) { func TestCreateSubnetCommand_Prepare_BridgeMode_NoVxlanID(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") cmd := CreateSubnetCommand{ Name: "sn-1", VPC: "vpc-1", Mode: "bridge", IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24", @@ -163,7 +163,7 @@ func TestCreateSubnetCommand_Prepare_BridgeMode_NoVxlanID(t *testing.T) { func TestCreateSubnetCommand_Prepare_UnknownMode(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") cmd := CreateSubnetCommand{ Name: "sn-1", VPC: "vpc-1", Mode: "vlan", IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24", @@ -175,7 +175,7 @@ func TestCreateSubnetCommand_Prepare_UnknownMode(t *testing.T) { func TestCreateSubnetCommand_Prepare_DefaultRouteStored(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") cmd := CreateSubnetCommand{ Name: "sn-1", VPC: "vpc-1", VxlanID: 100, IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24", @@ -195,7 +195,7 @@ func TestCreateSubnetCommand_Prepare_DefaultRouteStored(t *testing.T) { func TestCreateSubnetCommand_Prepare_DefaultRouteFalseByDefault(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") cmd := CreateSubnetCommand{ Name: "sn-1", VPC: "vpc-1", VxlanID: 100, IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24", @@ -211,7 +211,7 @@ func TestCreateSubnetCommand_Prepare_DefaultRouteFalseByDefault(t *testing.T) { func TestDeleteSubnetCommand_Prepare_Success(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "subnet/sn-del/state", "created") + kv.AddInDB(db, "subnet/sn-del/state", "running") cmd := DeleteSubnetCommand{Name: "sn-del"} if err := cmd.Prepare(db, nil); err != nil { t.Fatalf("Prepare a échoué : %v", err) @@ -222,6 +222,32 @@ func TestDeleteSubnetCommand_Prepare_Success(t *testing.T) { } } +func TestDeleteSubnetCommand_Prepare_RefusedWhileCreating(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "subnet/sn-wip/state", "creating") + cmd := DeleteSubnetCommand{Name: "sn-wip"} + if err := cmd.Prepare(db, nil); err == nil { + t.Error("Prepare devrait refuser la suppression d'un subnet en creating") + } + s, _ := kv.GetFromDB(db, "subnet/sn-wip/state") + if s != "creating" { + t.Errorf("l'état ne devrait pas changer, obtenu %q", s) + } +} + +func TestDeleteSubnetCommand_Prepare_AllowedFromError(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "subnet/sn-ko/state", "error") + cmd := DeleteSubnetCommand{Name: "sn-ko"} + if err := cmd.Prepare(db, nil); err != nil { + t.Fatalf("Prepare devrait accepter un subnet en error : %v", err) + } + s, _ := kv.GetFromDB(db, "subnet/sn-ko/state") + if s != "deleting" { + t.Errorf("state attendu deleting, obtenu %q", s) + } +} + func TestDeleteSubnetCommand_Prepare_NotFound(t *testing.T) { _, db := newTestDispatcher(t) cmd := DeleteSubnetCommand{Name: "sn-inexistant"} diff --git a/internal/dispatcher/agent/vm_commands.go b/internal/dispatcher/agent/vm_commands.go index 4190f85..6b50629 100644 --- a/internal/dispatcher/agent/vm_commands.go +++ b/internal/dispatcher/agent/vm_commands.go @@ -8,6 +8,7 @@ import ( "time" configuration "git.g3e.fr/syonad/two/internal/config/agent" + "git.g3e.fr/syonad/two/internal/state" "git.g3e.fr/syonad/two/internal/vm" "git.g3e.fr/syonad/two/pkg/db/kv" "github.com/dgraph-io/badger/v4" @@ -36,18 +37,18 @@ func (c StartVMCommand) Prepare(db *badger.DB, _ *configuration.Config) error { if _, err := kv.GetFromDB(db, "vm/"+c.Name+"/state"); err == nil { return fmt.Errorf("vm %q already exists", c.Name) } - subnetState, err := kv.GetFromDB(db, "subnet/"+c.Subnet+"/state") + subnetState, err := state.Get(db, "subnet/"+c.Subnet) if err != nil { return fmt.Errorf("subnet %q not found", c.Subnet) } - if subnetState == "deleting" || subnetState == "deleted" { + if subnetState != state.Creating && subnetState != state.Running { return fmt.Errorf("subnet %q is %s", c.Subnet, subnetState) } port, err := allocateMetadataPort(db) if err != nil { return fmt.Errorf("allocate metadata port: %w", err) } - kv.AddInDB(db, "vm/"+c.Name+"/state", "starting") + state.Set(db, c.Key(), state.Creating) kv.AddInDB(db, "vm/"+c.Name+"/subnet", c.Subnet) kv.AddInDB(db, "vm/"+c.Name+"/ip", c.IP) kv.AddInDB(db, "vm/"+c.Name+"/metadata_port", strconv.Itoa(port)) @@ -93,16 +94,19 @@ func allocateMetadataPort(db *badger.DB) (int, error) { func (c StartVMCommand) Execute(db *badger.DB, cfg *configuration.Config) error { timeout := time.After(time.Duration(cfg.Dispatcher.TimeoutSeconds) * time.Second) for { - state, err := kv.GetFromDB(db, "subnet/"+c.Subnet+"/state") + subnetState, err := state.Get(db, "subnet/"+c.Subnet) if err != nil { return fmt.Errorf("subnet %q not found while waiting", c.Subnet) } - if state == "created" { + if subnetState == state.Running { break } + if subnetState != state.Creating { + return fmt.Errorf("subnet %q is %s, cannot start vm %q", c.Subnet, subnetState, c.Name) + } select { case <-timeout: - return fmt.Errorf("timed out waiting for subnet %q to be created", c.Subnet) + return fmt.Errorf("timed out waiting for subnet %q to be running", c.Subnet) case <-time.After(time.Duration(cfg.Dispatcher.PollSeconds) * time.Second): } } @@ -116,21 +120,25 @@ type StopVMCommand struct { func (c StopVMCommand) Key() string { return "vm/" + c.Name } func (c StopVMCommand) Prepare(db *badger.DB, _ *configuration.Config) error { - if _, err := kv.GetFromDB(db, "vm/"+c.Name+"/state"); err != nil { + current, err := state.Get(db, c.Key()) + if err != nil { return fmt.Errorf("vm %q not found", c.Name) } - return kv.AddInDB(db, "vm/"+c.Name+"/state", "stopping") + if !state.CanDelete(current) { + return fmt.Errorf("vm %q cannot be stopped while %s", c.Name, current) + } + return state.Set(db, c.Key(), state.Deleting) } func (c StopVMCommand) Execute(db *badger.DB, cfg *configuration.Config) error { if err := vm.StopVM(db, c.Name, cfg); err != nil { return err } - state, err := kv.GetFromDB(db, "vm/"+c.Name+"/state") + current, err := state.Get(db, c.Key()) if err != nil { return err } - if state == "stopped" { + if current == state.Deleted { kv.DeleteInDB(db, "vm/"+c.Name) } return nil diff --git a/internal/dispatcher/agent/vm_commands_test.go b/internal/dispatcher/agent/vm_commands_test.go index ba400b9..2747b0f 100644 --- a/internal/dispatcher/agent/vm_commands_test.go +++ b/internal/dispatcher/agent/vm_commands_test.go @@ -10,7 +10,7 @@ import ( func TestStartVMCommand_Prepare_SingleDisk(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "subnet/sn-1/state", "created") + kv.AddInDB(db, "subnet/sn-1/state", "running") kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-1") cmd := StartVMCommand{ @@ -34,7 +34,7 @@ func TestStartVMCommand_Prepare_SingleDisk(t *testing.T) { func TestStartVMCommand_Prepare_MultiDisk(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "subnet/sn-1/state", "created") + kv.AddInDB(db, "subnet/sn-1/state", "running") kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-1") cmd := StartVMCommand{ @@ -66,7 +66,7 @@ func TestStartVMCommand_Prepare_MultiDisk(t *testing.T) { func TestStartVMCommand_Prepare_SlotGap(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "subnet/sn-1/state", "created") + kv.AddInDB(db, "subnet/sn-1/state", "running") kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-1") // sdb absent au boot — slot réservé pour hotplug @@ -96,7 +96,7 @@ func TestStartVMCommand_Prepare_SlotGap(t *testing.T) { func TestStartVMCommand_Prepare_NoVolumePath(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "subnet/sn-1/state", "created") + kv.AddInDB(db, "subnet/sn-1/state", "running") kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-1") cmd := StartVMCommand{ @@ -114,9 +114,54 @@ func TestStartVMCommand_Prepare_NoVolumePath(t *testing.T) { } } +// --- StopVMCommand.Prepare --- + +func TestStopVMCommand_Prepare_Success(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "vm/vm-run/state", "running") + cmd := StopVMCommand{Name: "vm-run"} + if err := cmd.Prepare(db, nil); err != nil { + t.Fatalf("Prepare a échoué : %v", err) + } + s, _ := kv.GetFromDB(db, "vm/vm-run/state") + if s != "deleting" { + t.Errorf("state attendu deleting, obtenu %q", s) + } +} + +func TestStopVMCommand_Prepare_RefusedWhileCreating(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "vm/vm-wip/state", "creating") + cmd := StopVMCommand{Name: "vm-wip"} + if err := cmd.Prepare(db, nil); err == nil { + t.Error("Prepare devrait refuser l'arrêt d'une VM en creating") + } + s, _ := kv.GetFromDB(db, "vm/vm-wip/state") + if s != "creating" { + t.Errorf("l'état ne devrait pas changer, obtenu %q", s) + } +} + +func TestStopVMCommand_Prepare_AllowedFromError(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "vm/vm-ko/state", "error") + cmd := StopVMCommand{Name: "vm-ko"} + if err := cmd.Prepare(db, nil); err != nil { + t.Fatalf("Prepare devrait accepter une VM en error : %v", err) + } +} + +func TestStopVMCommand_Prepare_NotFound(t *testing.T) { + _, db := newTestDispatcher(t) + cmd := StopVMCommand{Name: "vm-inexistante"} + if err := cmd.Prepare(db, nil); err == nil { + t.Error("Prepare devrait échouer si la VM n'existe pas") + } +} + func TestStartVMCommand_Prepare_Duplicate(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vm/vm-exist/state", "started") + kv.AddInDB(db, "vm/vm-exist/state", "running") cmd := StartVMCommand{ Name: "vm-exist", diff --git a/internal/dispatcher/agent/vpc_commands.go b/internal/dispatcher/agent/vpc_commands.go index 4a0a1dc..9e26819 100644 --- a/internal/dispatcher/agent/vpc_commands.go +++ b/internal/dispatcher/agent/vpc_commands.go @@ -7,6 +7,7 @@ import ( "time" configuration "git.g3e.fr/syonad/two/internal/config/agent" + "git.g3e.fr/syonad/two/internal/state" "git.g3e.fr/syonad/two/internal/vpc" "git.g3e.fr/syonad/two/pkg/db/kv" "github.com/dgraph-io/badger/v4" @@ -29,7 +30,7 @@ func (c CreateVPCCommand) Prepare(db *badger.DB, _ *configuration.Config) error if err := kv.AddInDB(db, "vpc/"+c.Name+"/cidr", c.CIDR); err != nil { return err } - return kv.AddInDB(db, "vpc/"+c.Name+"/state", "creating") + return state.Set(db, c.Key(), state.Creating) } func (c CreateVPCCommand) Execute(db *badger.DB, _ *configuration.Config) error { @@ -43,9 +44,13 @@ type DeleteVPCCommand struct { func (c DeleteVPCCommand) Key() string { return "vpc/" + c.Name } func (c DeleteVPCCommand) Prepare(db *badger.DB, _ *configuration.Config) error { - if _, err := kv.GetFromDB(db, "vpc/"+c.Name+"/state"); err != nil { + current, err := state.Get(db, c.Key()) + if err != nil { return fmt.Errorf("vpc %q not found", c.Name) } + if !state.CanDelete(current) { + return fmt.Errorf("vpc %q cannot be deleted while %s", c.Name, current) + } entries, err := kv.ListByPrefix(db, "subnet/") if err != nil { return fmt.Errorf("failed to list subnets: %w", err) @@ -55,12 +60,12 @@ func (c DeleteVPCCommand) Prepare(db *badger.DB, _ *configuration.Config) error continue } subnetName := strings.Split(key, "/")[1] - state, err := kv.GetFromDB(db, "subnet/"+subnetName+"/state") - if err != nil || (state != "deleting" && state != "deleted") { + s, err := state.Get(db, "subnet/"+subnetName) + if err != nil || (s != state.Deleting && s != state.Deleted) { return fmt.Errorf("subnet %q must be deleted before deleting vpc %q", subnetName, c.Name) } } - return kv.AddInDB(db, "vpc/"+c.Name+"/state", "deleting") + return state.Set(db, c.Key(), state.Deleting) } func (c DeleteVPCCommand) Execute(db *badger.DB, cfg *configuration.Config) error { @@ -74,8 +79,8 @@ func (c DeleteVPCCommand) Execute(db *badger.DB, cfg *configuration.Config) erro for key, value := range entries { if strings.HasSuffix(key, "/vpc") && value == c.Name { subnetName := strings.Split(key, "/")[1] - state, _ := kv.GetFromDB(db, "subnet/"+subnetName+"/state") - if state == "deleting" { + s, _ := state.Get(db, "subnet/"+subnetName) + if s == state.Deleting { pending = true break } @@ -93,11 +98,11 @@ func (c DeleteVPCCommand) Execute(db *badger.DB, cfg *configuration.Config) erro if err := vpc.DeleteVPC(db, c.Name); err != nil { return err } - state, err := kv.GetFromDB(db, "vpc/"+c.Name+"/state") + current, err := state.Get(db, c.Key()) if err != nil { return err } - if state == "deleted" { + if current == state.Deleted { kv.DeleteInDB(db, "vpc/"+c.Name) } return nil diff --git a/internal/dispatcher/agent/vpc_commands_test.go b/internal/dispatcher/agent/vpc_commands_test.go index 9633733..78b3d98 100644 --- a/internal/dispatcher/agent/vpc_commands_test.go +++ b/internal/dispatcher/agent/vpc_commands_test.go @@ -32,7 +32,7 @@ func TestCreateVPCCommand_Prepare_NewVPC(t *testing.T) { func TestCreateVPCCommand_Prepare_Duplicate(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vpc-exist/state", "created") + kv.AddInDB(db, "vpc/vpc-exist/state", "running") cmd := CreateVPCCommand{Name: "vpc-exist", CIDR: "10.0.0.0/16"} if err := cmd.Prepare(db, nil); err == nil { t.Error("Prepare devrait échouer sur un VPC déjà existant") @@ -51,7 +51,7 @@ func TestCreateVPCCommand_Prepare_InvalidCIDR(t *testing.T) { func TestDeleteVPCCommand_Prepare_Success(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vpc-del/state", "created") + kv.AddInDB(db, "vpc/vpc-del/state", "running") cmd := DeleteVPCCommand{Name: "vpc-del"} if err := cmd.Prepare(db, nil); err != nil { t.Fatalf("Prepare a échoué : %v", err) @@ -70,10 +70,45 @@ func TestDeleteVPCCommand_Prepare_NotFound(t *testing.T) { } } +func TestDeleteVPCCommand_Prepare_RefusedWhileCreating(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "vpc/vpc-wip/state", "creating") + cmd := DeleteVPCCommand{Name: "vpc-wip"} + if err := cmd.Prepare(db, nil); err == nil { + t.Error("Prepare devrait refuser la suppression d'un VPC en creating") + } + s, _ := kv.GetFromDB(db, "vpc/vpc-wip/state") + if s != "creating" { + t.Errorf("l'état ne devrait pas changer, obtenu %q", s) + } +} + +func TestDeleteVPCCommand_Prepare_RefusedWhileDeleting(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "vpc/vpc-gone/state", "deleting") + cmd := DeleteVPCCommand{Name: "vpc-gone"} + if err := cmd.Prepare(db, nil); err == nil { + t.Error("Prepare devrait refuser un VPC déjà en deleting") + } +} + +func TestDeleteVPCCommand_Prepare_AllowedFromError(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "vpc/vpc-ko/state", "error") + cmd := DeleteVPCCommand{Name: "vpc-ko"} + if err := cmd.Prepare(db, nil); err != nil { + t.Fatalf("Prepare devrait accepter un VPC en error : %v", err) + } + s, _ := kv.GetFromDB(db, "vpc/vpc-ko/state") + if s != "deleting" { + t.Errorf("state attendu deleting, obtenu %q", s) + } +} + func TestDeleteVPCCommand_Prepare_BlockedByActiveSubnet(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vpc-busy/state", "created") - kv.AddInDB(db, "subnet/sn-1/state", "created") + kv.AddInDB(db, "vpc/vpc-busy/state", "running") + kv.AddInDB(db, "subnet/sn-1/state", "running") kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-busy") cmd := DeleteVPCCommand{Name: "vpc-busy"} if err := cmd.Prepare(db, nil); err == nil { @@ -83,7 +118,7 @@ func TestDeleteVPCCommand_Prepare_BlockedByActiveSubnet(t *testing.T) { func TestDeleteVPCCommand_Prepare_AllowedWhenSubnetDeleted(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vpc-ok/state", "created") + kv.AddInDB(db, "vpc/vpc-ok/state", "running") kv.AddInDB(db, "subnet/sn-1/state", "deleted") kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-ok") cmd := DeleteVPCCommand{Name: "vpc-ok"} @@ -94,7 +129,7 @@ func TestDeleteVPCCommand_Prepare_AllowedWhenSubnetDeleted(t *testing.T) { func TestDeleteVPCCommand_Prepare_AllowedWhenSubnetDeleting(t *testing.T) { _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vpc-ok/state", "created") + kv.AddInDB(db, "vpc/vpc-ok/state", "running") kv.AddInDB(db, "subnet/sn-1/state", "deleting") kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-ok") cmd := DeleteVPCCommand{Name: "vpc-ok"} From aa6611249b6fa77683da711139f87acdca9e8387 Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Thu, 13 Aug 2026 23:38:49 +0200 Subject: [PATCH 3/3] f-37: test: add test for state validation Signed-off-by: GnomeZworc --- internal/api/agent/subnet_test.go | 22 ++++++++-------- internal/api/agent/vm_test.go | 10 +++---- internal/api/agent/vpc_test.go | 43 +++++++++++++++++++++++++------ 3 files changed, 51 insertions(+), 24 deletions(-) diff --git a/internal/api/agent/subnet_test.go b/internal/api/agent/subnet_test.go index 36e42f7..1ff067a 100644 --- a/internal/api/agent/subnet_test.go +++ b/internal/api/agent/subnet_test.go @@ -28,7 +28,7 @@ func TestListSubnets_Empty(t *testing.T) { func TestListSubnets_WithData(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "subnet/sn-1/state", "created") + kv.AddInDB(db, "subnet/sn-1/state", "running") kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-1") kv.AddInDB(db, "subnet/sn-2/state", "creating") kv.AddInDB(db, "subnet/sn-2/vpc", "vpc-1") @@ -55,7 +55,7 @@ func TestListSubnets_InvalidMethod(t *testing.T) { func TestPostSubnet_Created(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") req := SubnetCreateRequest{ Name: "sn-new", VPC: "vpc-1", @@ -91,7 +91,7 @@ func TestPostSubnet_MissingFields(t *testing.T) { func TestPostSubnet_IfaceTypeOptional(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") req := SubnetCreateRequest{ Name: "sn-opt", VPC: "vpc-1", @@ -126,8 +126,8 @@ func TestPostSubnet_VPCNotFound(t *testing.T) { func TestPostSubnet_Duplicate(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") - kv.AddInDB(db, "subnet/sn-exist/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") + kv.AddInDB(db, "subnet/sn-exist/state", "running") req := SubnetCreateRequest{ Name: "sn-exist", VPC: "vpc-1", @@ -163,7 +163,7 @@ func TestPostSubnet_VPCDeleting(t *testing.T) { func TestPostSubnet_BridgeMode_Success(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") req := SubnetCreateRequest{ Name: "sn-br", VPC: "vpc-1", @@ -190,7 +190,7 @@ func TestPostSubnet_BridgeMode_Success(t *testing.T) { func TestPostSubnet_UnknownMode(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") req := SubnetCreateRequest{ Name: "sn-1", VPC: "vpc-1", @@ -219,7 +219,7 @@ func TestPostSubnet_InvalidBody(t *testing.T) { func TestGetSubnet_Found(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "subnet/sn-1/state", "created") + kv.AddInDB(db, "subnet/sn-1/state", "running") kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-1") kv.AddInDB(db, "subnet/sn-1/cidr", "10.0.0.0/24") kv.AddInDB(db, "subnet/sn-1/interface_ip", "10.0.0.1") @@ -231,7 +231,7 @@ func TestGetSubnet_Found(t *testing.T) { } var result Subnet json.NewDecoder(w.Body).Decode(&result) - if result.Name != "sn-1" || result.State != "created" { + if result.Name != "sn-1" || result.State != "running" { t.Errorf("résultat inattendu : %+v", result) } if result.VPC != "vpc-1" { @@ -261,7 +261,7 @@ func TestGetSubnet_EmptyName(t *testing.T) { func TestDeleteSubnet_Success(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "subnet/sn-del/state", "created") + kv.AddInDB(db, "subnet/sn-del/state", "running") req := httptest.NewRequest(http.MethodDelete, "/subnets/sn-del", nil) w := httptest.NewRecorder() s.SubnetByNameHandler(w, req) @@ -287,7 +287,7 @@ func TestDeleteSubnet_NotFound(t *testing.T) { func TestSubnetByName_InvalidMethod(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "subnet/sn-1/state", "created") + kv.AddInDB(db, "subnet/sn-1/state", "running") req := httptest.NewRequest(http.MethodPut, "/subnets/sn-1", nil) w := httptest.NewRecorder() s.SubnetByNameHandler(w, req) diff --git a/internal/api/agent/vm_test.go b/internal/api/agent/vm_test.go index 3af5968..db8bbd5 100644 --- a/internal/api/agent/vm_test.go +++ b/internal/api/agent/vm_test.go @@ -15,7 +15,7 @@ import ( func TestVmFromDB_SingleDisk(t *testing.T) { entries := map[string]string{ - "vm/vm-1/state": "started", + "vm/vm-1/state": "running", "vm/vm-1/subnet": "sn-1", "vm/vm-1/ip": "10.0.0.5", "vm/vm-1/metadata_port": "1234", @@ -37,7 +37,7 @@ func TestVmFromDB_SingleDisk(t *testing.T) { func TestVmFromDB_MultiDisk(t *testing.T) { entries := map[string]string{ - "vm/vm-2/state": "started", + "vm/vm-2/state": "running", "vm/vm-2/subnet": "sn-1", "vm/vm-2/ip": "10.0.0.6", "vm/vm-2/metadata_port": "1235", @@ -62,7 +62,7 @@ func TestVmFromDB_MultiDisk(t *testing.T) { func TestVmFromDB_SlotGap(t *testing.T) { // sdb absent — sda et sdc seulement entries := map[string]string{ - "vm/vm-3/state": "started", + "vm/vm-3/state": "running", "vm/vm-3/subnet": "sn-1", "vm/vm-3/ip": "10.0.0.7", "vm/vm-3/metadata_port": "1236", @@ -94,7 +94,7 @@ func TestVmFromDB_SlotGap(t *testing.T) { func TestStartVM_MultiDisk(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "subnet/sn-1/state", "created") + kv.AddInDB(db, "subnet/sn-1/state", "running") kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-1") body, _ := json.Marshal(VMCreateRequest{ @@ -128,7 +128,7 @@ func TestStartVM_MultiDisk(t *testing.T) { func TestStartVM_StorageReturnedInResponse(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "subnet/sn-1/state", "created") + kv.AddInDB(db, "subnet/sn-1/state", "running") kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-1") body, _ := json.Marshal(VMCreateRequest{ diff --git a/internal/api/agent/vpc_test.go b/internal/api/agent/vpc_test.go index 3516305..b5ba517 100644 --- a/internal/api/agent/vpc_test.go +++ b/internal/api/agent/vpc_test.go @@ -28,7 +28,7 @@ func TestListVpcs_Empty(t *testing.T) { func TestListVpcs_WithData(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "vpc/v1/state", "created") + kv.AddInDB(db, "vpc/v1/state", "running") kv.AddInDB(db, "vpc/v2/state", "creating") w := httptest.NewRecorder() s.VpcsHandler(w, httptest.NewRequest(http.MethodGet, "/vpcs", nil)) @@ -104,7 +104,7 @@ func TestPostVpc_InvalidCIDR(t *testing.T) { func TestPostVpc_Duplicate(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "vpc/vpc-exist/state", "created") + kv.AddInDB(db, "vpc/vpc-exist/state", "running") body, _ := json.Marshal(VPCCreateRequest{Name: "vpc-exist", CIDR: "10.0.0.0/16"}) w := httptest.NewRecorder() s.VpcsHandler(w, httptest.NewRequest(http.MethodPost, "/vpcs", bytes.NewReader(body))) @@ -126,7 +126,7 @@ func TestPostVpc_InvalidBody(t *testing.T) { func TestGetVpc_Found(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") req := httptest.NewRequest(http.MethodGet, "/vpcs/vpc-1", nil) w := httptest.NewRecorder() s.VpcByNameHandler(w, req) @@ -135,7 +135,7 @@ func TestGetVpc_Found(t *testing.T) { } var result VPC json.NewDecoder(w.Body).Decode(&result) - if result.Name != "vpc-1" || result.State != "created" { + if result.Name != "vpc-1" || result.State != "running" { t.Errorf("résultat inattendu : %+v", result) } } @@ -162,7 +162,7 @@ func TestGetVpc_EmptyName(t *testing.T) { func TestDeleteVpc_Success(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "vpc/vpc-del/state", "created") + kv.AddInDB(db, "vpc/vpc-del/state", "running") req := httptest.NewRequest(http.MethodDelete, "/vpcs/vpc-del", nil) w := httptest.NewRecorder() s.VpcByNameHandler(w, req) @@ -186,10 +186,37 @@ func TestDeleteVpc_NotFound(t *testing.T) { } } +func TestDeleteVpc_ConflictWhileCreating(t *testing.T) { + s, db := newTestServer(t) + kv.AddInDB(db, "vpc/vpc-wip/state", "creating") + req := httptest.NewRequest(http.MethodDelete, "/vpcs/vpc-wip", nil) + w := httptest.NewRecorder() + s.VpcByNameHandler(w, req) + if w.Code != http.StatusConflict { + t.Errorf("attendu 409, obtenu %d: %s", w.Code, w.Body.String()) + } +} + +func TestDeleteVpc_AllowedFromError(t *testing.T) { + s, db := newTestServer(t) + kv.AddInDB(db, "vpc/vpc-ko/state", "error") + req := httptest.NewRequest(http.MethodDelete, "/vpcs/vpc-ko", nil) + w := httptest.NewRecorder() + s.VpcByNameHandler(w, req) + if w.Code != http.StatusAccepted { + t.Fatalf("attendu 202, obtenu %d: %s", w.Code, w.Body.String()) + } + var result VPC + json.NewDecoder(w.Body).Decode(&result) + if result.State != "deleting" { + t.Errorf("state attendu deleting, obtenu %q", result.State) + } +} + func TestDeleteVpc_BlockedByActiveSubnet(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "vpc/vpc-busy/state", "created") - kv.AddInDB(db, "subnet/sn-1/state", "created") + kv.AddInDB(db, "vpc/vpc-busy/state", "running") + kv.AddInDB(db, "subnet/sn-1/state", "running") kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-busy") req := httptest.NewRequest(http.MethodDelete, "/vpcs/vpc-busy", nil) w := httptest.NewRecorder() @@ -201,7 +228,7 @@ func TestDeleteVpc_BlockedByActiveSubnet(t *testing.T) { func TestVpcByName_InvalidMethod(t *testing.T) { s, db := newTestServer(t) - kv.AddInDB(db, "vpc/vpc-1/state", "created") + kv.AddInDB(db, "vpc/vpc-1/state", "running") req := httptest.NewRequest(http.MethodPut, "/vpcs/vpc-1", nil) w := httptest.NewRecorder() s.VpcByNameHandler(w, req)