two/internal/api/agent/vm_test.go
GnomeZworc 14640680f7
f-88: api: nom obligatoire des interfaces de VM, migration nic-<i> #88
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-30 00:24:37 +01:00

610 lines
22 KiB
Go

package agentapi
import (
"bytes"
"encoding/base64"
"encoding/json"
"net/http"
"net/http/httptest"
"sort"
"strings"
"testing"
"git.g3e.fr/syonad/two/pkg/db/kv"
"github.com/dgraph-io/badger/v4"
)
// --- vmFromDB ---
func TestVmFromDB_SingleDisk(t *testing.T) {
entries := map[string]string{
"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",
"vm/vm-1/memory": "512",
"vm/vm-1/cpus": "1",
"vm/vm-1/disk/xvda": "/data/root.qcow2",
}
vm, err := vmFromDB("vm-1", entries)
if err != nil {
t.Fatalf("vmFromDB a échoué : %v", err)
}
if len(vm.Storage) != 1 {
t.Fatalf("attendu 1 disque, obtenu %d", len(vm.Storage))
}
if vm.Storage[0].Dev != "xvda" || vm.Storage[0].Path != "/data/root.qcow2" {
t.Errorf("disque inattendu : %+v", vm.Storage[0])
}
}
func TestVmFromDB_MultiDisk(t *testing.T) {
entries := map[string]string{
"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",
"vm/vm-2/memory": "1024",
"vm/vm-2/cpus": "2",
"vm/vm-2/disk/xvda": "/data/root.qcow2",
"vm/vm-2/disk/xvdb": "/data/data.qcow2",
}
vm, err := vmFromDB("vm-2", entries)
if err != nil {
t.Fatalf("vmFromDB a échoué : %v", err)
}
if len(vm.Storage) != 2 {
t.Fatalf("attendu 2 disques, obtenu %d", len(vm.Storage))
}
sort.Slice(vm.Storage, func(i, j int) bool { return vm.Storage[i].Dev < vm.Storage[j].Dev })
if vm.Storage[0].Dev != "xvda" || vm.Storage[1].Dev != "xvdb" {
t.Errorf("devs attendus [xvda xvdb], obtenus [%s %s]", vm.Storage[0].Dev, vm.Storage[1].Dev)
}
}
func TestVmFromDB_SlotGap(t *testing.T) {
// xvdb absent — xvda et xvdc seulement
entries := map[string]string{
"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",
"vm/vm-3/memory": "512",
"vm/vm-3/cpus": "1",
"vm/vm-3/disk/xvda": "/data/root.qcow2",
"vm/vm-3/disk/xvdc": "/data/extra.qcow2",
}
vm, err := vmFromDB("vm-3", entries)
if err != nil {
t.Fatalf("vmFromDB a échoué : %v", err)
}
if len(vm.Storage) != 2 {
t.Fatalf("attendu 2 disques, obtenu %d", len(vm.Storage))
}
devs := map[string]bool{}
for _, s := range vm.Storage {
devs[s.Dev] = true
}
if !devs["xvda"] || !devs["xvdc"] {
t.Errorf("attendu xvda et xvdc, obtenus %v", devs)
}
if devs["xvdb"] {
t.Error("xvdb ne devrait pas apparaître")
}
}
// --- POST /vms ---
func TestStartVM_MultiDisk(t *testing.T) {
s, db := newTestServer(t)
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")
body, _ := json.Marshal(VMCreateRequest{
Name: "vm-10",
Interfaces: []VMInterface{
{Name: "nic-sn-1", Subnet: "sn-1", IP: "10.0.0.10", MAC: "52:54:00:00:00:05", Primary: true},
},
Storage: []VMStorage{
{Path: "/data/root.qcow2", Dev: "vda"},
{Path: "/data/data.qcow2", Dev: "xvda"},
},
Memory: 1024,
CPUs: 2,
})
w := httptest.NewRecorder()
s.VmsHandler(w, httptest.NewRequest(http.MethodPost, "/vms", bytes.NewReader(body)))
if w.Code != http.StatusAccepted {
t.Fatalf("attendu 202, obtenu %d : %s", w.Code, w.Body.String())
}
for _, dev := range []string{"vda", "xvda"} {
if _, err := kv.GetFromDB(db, "vm/vm-10/disk/"+dev); err != nil {
t.Errorf("disk/%s absent en DB après création", dev)
}
}
if _, err := kv.GetFromDB(db, "vm/vm-10/volume_path"); err == nil {
t.Error("volume_path ne devrait plus exister en DB")
}
}
func TestStartVM_StorageReturnedInResponse(t *testing.T) {
s, db := newTestServer(t)
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")
body, _ := json.Marshal(VMCreateRequest{
Name: "vm-11",
Interfaces: []VMInterface{
{Name: "nic-sn-1", Subnet: "sn-1", IP: "10.0.0.11", MAC: "52:54:00:00:00:05", Primary: true},
},
Storage: []VMStorage{
{Path: "/data/root.qcow2", Dev: "xvda"},
},
})
w := httptest.NewRecorder()
s.VmsHandler(w, httptest.NewRequest(http.MethodPost, "/vms", bytes.NewReader(body)))
if w.Code != http.StatusAccepted {
t.Fatalf("attendu 202, obtenu %d", w.Code)
}
var vm VM
json.NewDecoder(w.Body).Decode(&vm)
if len(vm.Storage) != 1 {
t.Fatalf("attendu 1 disque dans la réponse, obtenu %d", len(vm.Storage))
}
if vm.Storage[0].Dev != "xvda" || vm.Storage[0].Path != "/data/root.qcow2" {
t.Errorf("disque inattendu dans la réponse : %+v", vm.Storage[0])
}
}
func TestStartVM_RejectsInvalidDiskDev(t *testing.T) {
for _, dev := range []string{"sda", "sdb", "vdb", "xvd", "xvdA", "xvdaa", ""} {
s, db := newTestServer(t)
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")
body, _ := json.Marshal(VMCreateRequest{
Name: "vm-12",
Interfaces: []VMInterface{{Name: "nic-sn-1", Subnet: "sn-1", IP: "10.0.0.12", MAC: "52:54:00:00:00:05", Primary: true}},
Storage: []VMStorage{{Path: "/data/root.qcow2", Dev: "vda"}, {Path: "/data/data.qcow2", Dev: dev}},
})
w := httptest.NewRecorder()
s.VmsHandler(w, httptest.NewRequest(http.MethodPost, "/vms", bytes.NewReader(body)))
if w.Code != http.StatusBadRequest {
t.Errorf("dev %q : attendu 400, obtenu %d", dev, w.Code)
}
if !strings.Contains(w.Body.String(), "storage 1: dev") {
t.Errorf("dev %q : message inattendu %s", dev, w.Body.String())
}
if _, err := kv.GetFromDB(db, "vm/vm-12/state"); err == nil {
t.Errorf("dev %q : la VM ne doit pas être enregistrée", dev)
}
}
}
// --- POST /vms : objet metadata ---
func postVM(t *testing.T, name string, meta VMMetadata) (*httptest.ResponseRecorder, *badger.DB) {
t.Helper()
s, db := newTestServer(t)
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")
body, _ := json.Marshal(VMCreateRequest{
Name: name,
Interfaces: []VMInterface{{Name: "nic-sn-1", Subnet: "sn-1", IP: "10.0.0.20", MAC: "52:54:00:00:00:05", Primary: true}},
Storage: []VMStorage{{Path: "/data/root.qcow2", Dev: "vda"}},
Memory: 1024,
CPUs: 2,
Metadata: meta,
})
w := httptest.NewRecorder()
s.VmsHandler(w, httptest.NewRequest(http.MethodPost, "/vms", bytes.NewReader(body)))
return w, db
}
func TestStartVM_UserDataIsDecodedFromBase64(t *testing.T) {
plain := "#cloud-config\npackages:\n - nginx\n"
encoded := base64.StdEncoding.EncodeToString([]byte(plain))
w, db := postVM(t, "vm-md1", VMMetadata{UserData: encoded})
if w.Code != http.StatusAccepted {
t.Fatalf("attendu 202, obtenu %d : %s", w.Code, w.Body.String())
}
got, err := kv.GetFromDB(db, "vm/vm-md1/metadata/user-data")
if err != nil {
t.Fatalf("user-data absent en DB : %v", err)
}
if got != plain {
t.Errorf("user-data décodé attendu %q, obtenu %q", plain, got)
}
}
func TestStartVM_InvalidBase64IsRejected(t *testing.T) {
w, db := postVM(t, "vm-md2", VMMetadata{UserData: "ceci n'est pas du base64 !!"})
if w.Code != http.StatusBadRequest {
t.Fatalf("un base64 invalide doit être refusé en 400, obtenu %d : %s", w.Code, w.Body.String())
}
if _, err := kv.GetFromDB(db, "vm/vm-md2/state"); err == nil {
t.Error("aucune VM ne doit être créée quand la requête est refusée")
}
}
func TestStartVM_InvalidBase64ErrorNamesTheField(t *testing.T) {
w, _ := postVM(t, "vm-md3", VMMetadata{UserData: "@@@"})
if !strings.Contains(w.Body.String(), "user_data") {
t.Errorf("le message doit nommer le champ fautif : %s", w.Body.String())
}
}
func TestStartVM_NoUserDataWritesNoDocument(t *testing.T) {
w, db := postVM(t, "vm-md4", VMMetadata{SSHKey: "ssh-ed25519 AAAA user@host"})
if w.Code != http.StatusAccepted {
t.Fatalf("attendu 202, obtenu %d : %s", w.Code, w.Body.String())
}
entries, err := kv.ListByPrefix(db, "vm/vm-md4/metadata/")
if err != nil {
t.Fatalf("ListByPrefix : %v", err)
}
if len(entries) != 0 {
t.Errorf("sans user_data, aucun document ne doit être stocké : %v", entries)
}
}
func TestStartVM_PasswordAndSSHKeyComeFromMetadata(t *testing.T) {
w, db := postVM(t, "vm-md5", VMMetadata{
Password: "$6$rounds$hash",
SSHKey: "ssh-ed25519 AAAA user@host",
})
if w.Code != http.StatusAccepted {
t.Fatalf("attendu 202, obtenu %d : %s", w.Code, w.Body.String())
}
if got, _ := kv.GetFromDB(db, "vm/vm-md5/password"); got != "$6$rounds$hash" {
t.Errorf("password attendu depuis metadata, obtenu %q", got)
}
if got, _ := kv.GetFromDB(db, "vm/vm-md5/sshkey"); got != "ssh-ed25519 AAAA user@host" {
t.Errorf("sshkey attendu depuis metadata, obtenu %q", got)
}
}
func TestStartVM_EmptyBase64MeansNoDocument(t *testing.T) {
w, db := postVM(t, "vm-md6", VMMetadata{UserData: base64.StdEncoding.EncodeToString([]byte(""))})
if w.Code != http.StatusAccepted {
t.Fatalf("attendu 202, obtenu %d : %s", w.Code, w.Body.String())
}
entries, _ := kv.ListByPrefix(db, "vm/vm-md6/metadata/")
if len(entries) != 0 {
t.Errorf("un base64 vide est indiscernable d'un champ absent : %v", entries)
}
}
// --- interfaces multiples ---
func TestVmFromDB_MultipleInterfacesSortedByIndex(t *testing.T) {
vm, err := vmFromDB("vm-multi", map[string]string{
"vm/vm-multi/state": "running",
"vm/vm-multi/nic/1/subnet": "sn-2",
"vm/vm-multi/nic/1/ip": "10.2.0.5",
"vm/vm-multi/nic/1/mac": "52:54:00:aa:bb:cc",
"vm/vm-multi/nic/0/subnet": "sn-1",
"vm/vm-multi/nic/0/ip": "10.1.0.5",
"vm/vm-multi/nic/0/primary": "true",
"vm/vm-multi/disk/vda": "/data/root.qcow2",
})
if err != nil {
t.Fatalf("vmFromDB : %v", err)
}
if len(vm.Interfaces) != 2 {
t.Fatalf("2 interfaces attendues, obtenu %d : %+v", len(vm.Interfaces), vm.Interfaces)
}
if vm.Interfaces[0].Subnet != "sn-1" || !vm.Interfaces[0].Primary {
t.Errorf("la première doit être l'index 0, primaire : %+v", vm.Interfaces[0])
}
if vm.Interfaces[1].Subnet != "sn-2" || vm.Interfaces[1].Primary {
t.Errorf("la seconde doit être l'index 1, non primaire : %+v", vm.Interfaces[1])
}
if vm.Interfaces[1].MAC != "52:54:00:aa:bb:cc" {
t.Errorf("la mac de la seconde doit être rendue : %+v", vm.Interfaces[1])
}
}
func TestStartVM_StoresAllInterfaces(t *testing.T) {
s, db := newTestServer(t)
for sn, cidr := range map[string]string{"sn-1": "10.1.0.0/24", "sn-2": "10.2.0.0/24"} {
kv.AddInDB(db, "subnet/"+sn+"/state", "running")
kv.AddInDB(db, "subnet/"+sn+"/vpc", "vpc-1")
kv.AddInDB(db, "subnet/"+sn+"/cidr", cidr)
}
body, _ := json.Marshal(VMCreateRequest{
Name: "vm-multi",
Interfaces: []VMInterface{
{Name: "nic-sn-1", Subnet: "sn-1", IP: "10.1.0.5", MAC: "52:54:00:00:00:05", Primary: true},
{Name: "nic-sn-2", Subnet: "sn-2", IP: "10.2.0.5", MAC: "52:54:00:aa:bb:cc"},
},
Storage: []VMStorage{{Path: "/data/root.qcow2", Dev: "vda"}},
})
w := httptest.NewRecorder()
s.VmsHandler(w, httptest.NewRequest(http.MethodPost, "/vms", bytes.NewReader(body)))
if w.Code != http.StatusAccepted {
t.Fatalf("attendu 202, obtenu %d : %s", w.Code, w.Body.String())
}
if got, _ := kv.GetFromDB(db, "vm/vm-multi/nic/1/subnet"); got != "sn-2" {
t.Errorf("seconde interface non stockée : %q", got)
}
if got, _ := kv.GetFromDB(db, "vm/vm-multi/nic/1/mac"); got != "52:54:00:aa:bb:cc" {
t.Errorf("mac de la seconde interface non stockée telle quelle : %q", got)
}
if got, _ := kv.GetFromDB(db, "vm/vm-multi/nic/0/primary"); got != "true" {
t.Errorf("primaire non marquée : %q", got)
}
if _, err := kv.GetFromDB(db, "vm/vm-multi/nic/1/primary"); err == nil {
t.Error("une interface non primaire ne doit pas porter la clé primary")
}
}
func TestStartVM_StoresDHCPServerOnlyWhenRequested(t *testing.T) {
s, db := newTestServer(t)
for sn, cidr := range map[string]string{"sn-1": "10.1.0.0/24", "sn-2": "10.2.0.0/24"} {
kv.AddInDB(db, "subnet/"+sn+"/state", "running")
kv.AddInDB(db, "subnet/"+sn+"/vpc", "vpc-1")
kv.AddInDB(db, "subnet/"+sn+"/cidr", cidr)
}
body, _ := json.Marshal(VMCreateRequest{
Name: "vm-pxe",
Interfaces: []VMInterface{
{Name: "nic-sn-1", Subnet: "sn-1", IP: "10.1.0.5", MAC: "52:54:00:00:00:05", Primary: true},
{Name: "nic-sn-2", Subnet: "sn-2", IP: "10.2.0.5", MAC: "52:54:00:aa:bb:cc", DHCPServer: true},
},
Storage: []VMStorage{{Path: "/data/root.qcow2", Dev: "vda"}},
})
w := httptest.NewRecorder()
s.VmsHandler(w, httptest.NewRequest(http.MethodPost, "/vms", bytes.NewReader(body)))
if w.Code != http.StatusAccepted {
t.Fatalf("attendu 202, obtenu %d : %s", w.Code, w.Body.String())
}
if got, _ := kv.GetFromDB(db, "vm/vm-pxe/nic/1/dhcp_server"); got != "true" {
t.Errorf("dhcp_server de la seconde interface non stocké : %q", got)
}
if _, err := kv.GetFromDB(db, "vm/vm-pxe/nic/0/dhcp_server"); err == nil {
t.Error("une interface sans dhcp_server ne doit pas porter la clé")
}
}
func TestVmFromDB_ReturnsDHCPServer(t *testing.T) {
vm, err := vmFromDB("vm-pxe", map[string]string{
"vm/vm-pxe/state": "running",
"vm/vm-pxe/nic/0/subnet": "sn-1",
"vm/vm-pxe/nic/0/ip": "10.1.0.5",
"vm/vm-pxe/nic/0/primary": "true",
"vm/vm-pxe/nic/1/subnet": "sn-2",
"vm/vm-pxe/nic/1/ip": "10.2.0.5",
"vm/vm-pxe/nic/1/dhcp_server": "true",
"vm/vm-pxe/disk/vda": "/data/root.qcow2",
})
if err != nil {
t.Fatalf("vmFromDB : %v", err)
}
if len(vm.Interfaces) != 2 {
t.Fatalf("2 interfaces attendues : %+v", vm.Interfaces)
}
if vm.Interfaces[0].DHCPServer || !vm.Interfaces[1].DHCPServer {
t.Errorf("dhcp_server attendu sur l'index 1 seulement : %+v", vm.Interfaces)
}
raw, _ := json.Marshal(vm.Interfaces[0])
if !strings.Contains(string(raw), `"dhcp_server":false`) {
t.Errorf("dhcp_server faux absent du JSON : %s", raw)
}
}
func TestStartVM_RejectsZeroOrTwoPrimaries(t *testing.T) {
cases := map[string][]VMInterface{
"aucune primaire": {{Name: "nic-sn-1", Subnet: "sn-1", IP: "10.1.0.5", MAC: "52:54:00:00:00:05"}},
"deux primaires": {
{Name: "nic-sn-1", Subnet: "sn-1", IP: "10.1.0.5", MAC: "52:54:00:00:00:05", Primary: true},
{Name: "nic-sn-2", Subnet: "sn-2", IP: "10.2.0.5", MAC: "52:54:00:00:00:05", Primary: true},
},
}
for label, ifaces := range cases {
s, db := newTestServer(t)
for sn, cidr := range map[string]string{"sn-1": "10.1.0.0/24", "sn-2": "10.2.0.0/24"} {
kv.AddInDB(db, "subnet/"+sn+"/state", "running")
kv.AddInDB(db, "subnet/"+sn+"/vpc", "vpc-1")
kv.AddInDB(db, "subnet/"+sn+"/cidr", cidr)
}
body, _ := json.Marshal(VMCreateRequest{
Name: "vm-bad",
Interfaces: ifaces,
Storage: []VMStorage{{Path: "/data/root.qcow2", Dev: "vda"}},
})
w := httptest.NewRecorder()
s.VmsHandler(w, httptest.NewRequest(http.MethodPost, "/vms", bytes.NewReader(body)))
if w.Code != http.StatusBadRequest {
t.Errorf("%s : attendu 400, obtenu %d — %s", label, w.Code, w.Body.String())
}
}
}
func TestStartVM_RejectsAnInterfaceWithoutMAC(t *testing.T) {
s, db := newTestServer(t)
for sn, cidr := range map[string]string{"sn-1": "10.1.0.0/24", "sn-2": "10.2.0.0/24"} {
kv.AddInDB(db, "subnet/"+sn+"/state", "running")
kv.AddInDB(db, "subnet/"+sn+"/vpc", "vpc-1")
kv.AddInDB(db, "subnet/"+sn+"/cidr", cidr)
}
body, _ := json.Marshal(VMCreateRequest{
Name: "vm-nomac",
Interfaces: []VMInterface{
{Name: "nic-sn-1", Subnet: "sn-1", IP: "10.1.0.5", MAC: "52:54:00:00:00:05", Primary: true},
{Name: "nic-sn-2", Subnet: "sn-2", IP: "10.2.0.5"},
},
Storage: []VMStorage{{Path: "/data/root.qcow2", Dev: "vda"}},
})
w := httptest.NewRecorder()
s.VmsHandler(w, httptest.NewRequest(http.MethodPost, "/vms", bytes.NewReader(body)))
if w.Code != http.StatusBadRequest || !strings.Contains(w.Body.String(), "interface 1: mac is required") {
t.Errorf("attendu 400 nommant l'interface 1, obtenu %d — %s", w.Code, w.Body.String())
}
if _, err := kv.GetFromDB(db, "vm/vm-nomac/state"); err == nil {
t.Error("une VM refusée ne doit laisser aucune trace en base")
}
}
func TestStartVM_RejectsReservedOrForeignAddresses(t *testing.T) {
cases := map[string]string{
"passerelle anycast": "10.0.0.254",
"relais": "10.0.0.253",
"adresse réseau": "10.0.0.0",
"broadcast": "10.0.0.255",
"hors cidr": "10.0.1.5",
"gateway explicite": "10.0.0.1",
}
for label, ip := range cases {
s, db := newTestServer(t)
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.254")
kv.AddInDB(db, "subnet/sn-1/relay_ip", "10.0.0.253")
kv.AddInDB(db, "subnet/sn-1/gateway", "10.0.0.1")
body, _ := json.Marshal(VMCreateRequest{
Name: "vm-ip",
Interfaces: []VMInterface{{Name: "nic-sn-1", Subnet: "sn-1", IP: ip, MAC: "52:54:00:00:00:05", Primary: true}},
Storage: []VMStorage{{Path: "/data/root.qcow2", Dev: "vda"}},
})
w := httptest.NewRecorder()
s.VmsHandler(w, httptest.NewRequest(http.MethodPost, "/vms", bytes.NewReader(body)))
if w.Code != http.StatusUnprocessableEntity {
t.Errorf("%s : attendu 422, obtenu %d — %s", label, w.Code, w.Body.String())
}
if _, err := kv.GetFromDB(db, "vm/vm-ip/state"); err == nil {
t.Errorf("%s : la VM ne doit pas être créée", label)
}
}
}
func TestStartVM_AcceptsHostAddressBesideReservedOnes(t *testing.T) {
s, db := newTestServer(t)
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.254")
kv.AddInDB(db, "subnet/sn-1/relay_ip", "10.0.0.253")
body, _ := json.Marshal(VMCreateRequest{
Name: "vm-ip",
Interfaces: []VMInterface{{Name: "nic-sn-1", Subnet: "sn-1", IP: "10.0.0.252", MAC: "52:54:00:00:00:05", Primary: true}},
Storage: []VMStorage{{Path: "/data/root.qcow2", Dev: "vda"}},
})
w := httptest.NewRecorder()
s.VmsHandler(w, httptest.NewRequest(http.MethodPost, "/vms", bytes.NewReader(body)))
if w.Code != http.StatusAccepted {
t.Fatalf("attendu 202, obtenu %d : %s", w.Code, w.Body.String())
}
}
func TestStartVM_RejectsSubnetWithoutCIDR(t *testing.T) {
s, db := newTestServer(t)
kv.AddInDB(db, "subnet/sn-1/state", "running")
kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-1")
body, _ := json.Marshal(VMCreateRequest{
Name: "vm-ip",
Interfaces: []VMInterface{{Name: "nic-sn-1", Subnet: "sn-1", IP: "10.0.0.5", MAC: "52:54:00:00:00:05", Primary: true}},
Storage: []VMStorage{{Path: "/data/root.qcow2", Dev: "vda"}},
})
w := httptest.NewRecorder()
s.VmsHandler(w, httptest.NewRequest(http.MethodPost, "/vms", bytes.NewReader(body)))
if w.Code != http.StatusUnprocessableEntity || !strings.Contains(w.Body.String(), "has no cidr") {
t.Errorf("attendu 422 « has no cidr », obtenu %d : %s", w.Code, w.Body.String())
}
}
func TestStartVM_RejectsAnInterfaceWithoutOrWithADuplicateName(t *testing.T) {
cases := []struct {
label string
ifaces []VMInterface
msg string
}{
{"nom absent", []VMInterface{
{Name: "nic-a", Subnet: "sn-1", IP: "10.1.0.5", MAC: "52:54:00:00:00:05", Primary: true},
{Subnet: "sn-2", IP: "10.2.0.5", MAC: "52:54:00:aa:bb:cc"},
}, "interface 1: name is required"},
{"nom en double", []VMInterface{
{Name: "nic-a", Subnet: "sn-1", IP: "10.1.0.5", MAC: "52:54:00:00:00:05", Primary: true},
{Name: "nic-a", Subnet: "sn-2", IP: "10.2.0.5", MAC: "52:54:00:aa:bb:cc"},
}, `interface 1: name \"nic-a\" is already used by interface 0`},
}
for _, c := range cases {
s, db := newTestServer(t)
for sn, cidr := range map[string]string{"sn-1": "10.1.0.0/24", "sn-2": "10.2.0.0/24"} {
kv.AddInDB(db, "subnet/"+sn+"/state", "running")
kv.AddInDB(db, "subnet/"+sn+"/vpc", "vpc-1")
kv.AddInDB(db, "subnet/"+sn+"/cidr", cidr)
}
body, _ := json.Marshal(VMCreateRequest{
Name: "vm-names",
Interfaces: c.ifaces,
Storage: []VMStorage{{Path: "/data/root.qcow2", Dev: "vda"}},
})
w := httptest.NewRecorder()
s.VmsHandler(w, httptest.NewRequest(http.MethodPost, "/vms", bytes.NewReader(body)))
if w.Code != http.StatusBadRequest || !strings.Contains(w.Body.String(), c.msg) {
t.Errorf("%s : attendu 400 « %s », obtenu %d — %s", c.label, c.msg, w.Code, w.Body.String())
}
if _, err := kv.GetFromDB(db, "vm/vm-names/state"); err == nil {
t.Errorf("%s : une VM refusée ne doit laisser aucune trace en base", c.label)
}
}
}
func TestStartVM_StoresAndReturnsInterfaceNames(t *testing.T) {
s, db := newTestServer(t)
for sn, cidr := range map[string]string{"sn-1": "10.1.0.0/24", "sn-2": "10.2.0.0/24"} {
kv.AddInDB(db, "subnet/"+sn+"/state", "running")
kv.AddInDB(db, "subnet/"+sn+"/vpc", "vpc-1")
kv.AddInDB(db, "subnet/"+sn+"/cidr", cidr)
}
body, _ := json.Marshal(VMCreateRequest{
Name: "vm-named",
Interfaces: []VMInterface{
{Name: "nic-a1b2", Subnet: "sn-1", IP: "10.1.0.5", MAC: "52:54:00:00:00:05", Primary: true},
{Name: "nic-c3d4", Subnet: "sn-2", IP: "10.2.0.5", MAC: "52:54:00:aa:bb:cc"},
},
Storage: []VMStorage{{Path: "/data/root.qcow2", Dev: "vda"}},
})
w := httptest.NewRecorder()
s.VmsHandler(w, httptest.NewRequest(http.MethodPost, "/vms", bytes.NewReader(body)))
if w.Code != http.StatusAccepted {
t.Fatalf("attendu 202, obtenu %d : %s", w.Code, w.Body.String())
}
for key, want := range map[string]string{"vm/vm-named/nic/0/name": "nic-a1b2", "vm/vm-named/nic/1/name": "nic-c3d4"} {
if got, err := kv.GetFromDB(db, key); err != nil || got != want {
t.Errorf("%s = %q (%v), attendu %q", key, got, err, want)
}
}
w = httptest.NewRecorder()
s.VmByNameHandler(w, httptest.NewRequest(http.MethodGet, "/vms/vm-named", nil))
var got VM
json.NewDecoder(w.Body).Decode(&got)
if len(got.Interfaces) != 2 || got.Interfaces[0].Name != "nic-a1b2" || got.Interfaces[1].Name != "nic-c3d4" {
t.Errorf("interfaces renvoyées : %+v", got.Interfaces)
}
}