mock.go
143 lines1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
package mock
import (
"fmt"
"sync"
"congo.gg/pkg/platform"
"github.com/google/uuid"
)
// backend is a mock implementation for testing
type backend struct {
mu sync.RWMutex
servers map[string]*platform.Server
volumes map[string]*platform.Volume
ipCount int
}
// New creates a mock platform for testing
func New() *platform.Platform {
return &platform.Platform{
Backend: &backend{
servers: make(map[string]*platform.Server),
volumes: make(map[string]*platform.Volume),
},
}
}
// CreateServer creates a mock server
func (b *backend) CreateServer(opts platform.ServerOptions) (*platform.Server, error) {
b.mu.Lock()
defer b.mu.Unlock()
// Check if server with this name already exists
for _, s := range b.servers {
if s.Name == opts.Name {
return nil, fmt.Errorf("server with name %q already exists", opts.Name)
}
}
b.ipCount++
server := &platform.Server{
ID: uuid.New().String(),
Name: opts.Name,
Size: string(opts.Size),
Region: string(opts.Region),
IP: fmt.Sprintf("10.0.0.%d", b.ipCount),
Status: "active",
}
b.servers[server.ID] = server
return server, nil
}
// GetServer retrieves a server by name
func (b *backend) GetServer(name string) (*platform.Server, error) {
b.mu.RLock()
defer b.mu.RUnlock()
for _, s := range b.servers {
if s.Name == name {
return s, nil
}
}
return nil, platform.ErrNotFound
}
// DeleteServer removes a server by ID
func (b *backend) DeleteServer(id string) error {
b.mu.Lock()
defer b.mu.Unlock()
if _, ok := b.servers[id]; !ok {
return platform.ErrNotFound
}
delete(b.servers, id)
return nil
}
// CreateVolume creates a mock volume
func (b *backend) CreateVolume(name string, sizeGB int, region platform.Region) (*platform.Volume, error) {
b.mu.Lock()
defer b.mu.Unlock()
// Check if volume with this name already exists
for _, v := range b.volumes {
if v.Name == name {
return nil, fmt.Errorf("volume with name %q already exists", name)
}
}
volume := &platform.Volume{
ID: uuid.New().String(),
Name: name,
Size: sizeGB,
Region: string(region),
}
b.volumes[volume.ID] = volume
return volume, nil
}
// GetVolume retrieves a volume by name
func (b *backend) GetVolume(name string) (*platform.Volume, error) {
b.mu.RLock()
defer b.mu.RUnlock()
for _, v := range b.volumes {
if v.Name == name {
return v, nil
}
}
return nil, platform.ErrNotFound
}
// AttachVolume attaches a volume to a server
func (b *backend) AttachVolume(volumeID, serverID string) error {
b.mu.Lock()
defer b.mu.Unlock()
volume, ok := b.volumes[volumeID]
if !ok {
return platform.ErrNotFound
}
if _, ok := b.servers[serverID]; !ok {
return platform.ErrNotFound
}
volume.ServerID = serverID
return nil
}
// DetachVolume detaches a volume from its server
func (b *backend) DetachVolume(volumeID string) error {
b.mu.Lock()
defer b.mu.Unlock()
volume, ok := b.volumes[volumeID]
if !ok {
return platform.ErrNotFound
}
volume.ServerID = ""
return nil
}