127 lines
3.5 KiB
Go
127 lines
3.5 KiB
Go
package docker
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// TestIntegrationInfo dijalankan hanya bila docker socket tersedia —
|
|
// di CI runner tanpa socket, test di-skip otomatis.
|
|
func TestIntegrationInfo(t *testing.T) {
|
|
if _, err := os.Stat("/var/run/docker.sock"); err != nil {
|
|
t.Skip("docker socket tidak ada — skip tes integrasi")
|
|
}
|
|
c, err := New()
|
|
if err != nil {
|
|
t.Fatalf("New: %v", err)
|
|
}
|
|
defer c.Close()
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
|
|
if err := c.Ping(ctx); err != nil {
|
|
t.Fatalf("Ping: %v", err)
|
|
}
|
|
info, err := c.Info(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Info: %v", err)
|
|
}
|
|
if info.ServerVersion == "" {
|
|
t.Fatal("ServerVersion kosong")
|
|
}
|
|
t.Logf("engine %s (API %s) · %d/%d kontainer berjalan · %d image · %d CPU · %d MB RAM",
|
|
info.ServerVersion, info.APIVersion, info.Running, info.Containers,
|
|
info.Images, info.CPUs, info.MemoryTotal/1024/1024)
|
|
|
|
items, err := c.ListContainers(ctx)
|
|
if err != nil {
|
|
t.Fatalf("ListContainers: %v", err)
|
|
}
|
|
t.Logf("ListContainers: %d kontainer", len(items))
|
|
for i, ct := range items {
|
|
if i >= 5 {
|
|
break
|
|
}
|
|
t.Logf(" - %-20s %-10s %s", ct.Name, ct.State, ct.Image)
|
|
}
|
|
|
|
images, err := c.ListImages(ctx)
|
|
if err != nil {
|
|
t.Fatalf("ListImages: %v", err)
|
|
}
|
|
volumes, err := c.ListVolumes(ctx)
|
|
if err != nil {
|
|
t.Fatalf("ListVolumes: %v", err)
|
|
}
|
|
networks, err := c.ListNetworks(ctx)
|
|
if err != nil {
|
|
t.Fatalf("ListNetworks: %v", err)
|
|
}
|
|
t.Logf("images=%d volumes=%d networks=%d", len(images), len(volumes), len(networks))
|
|
for _, ct := range items {
|
|
if ct.State != "running" {
|
|
continue
|
|
}
|
|
if b, err := c.InspectJSON(ctx, ct.ID); err != nil || len(b) == 0 {
|
|
t.Fatalf("InspectJSON(%s): err=%v len=%d", ct.Name, err, len(b))
|
|
}
|
|
if env, err := c.InspectEnv(ctx, ct.ID); err != nil || len(env) == 0 {
|
|
t.Fatalf("InspectEnv(%s): err=%v n=%d", ct.Name, err, len(env))
|
|
}
|
|
titles, rows, err := c.TopProcesses(ctx, ct.ID)
|
|
if err != nil || len(titles) == 0 || len(rows) == 0 {
|
|
t.Fatalf("TopProcesses(%s): err=%v titles=%d rows=%d", ct.Name, err, len(titles), len(rows))
|
|
}
|
|
t.Logf("inspect+env+top OK untuk %s (%d proses)", ct.Name, len(rows))
|
|
break
|
|
}
|
|
}
|
|
|
|
// TestIntegrationEvents — stream event daemon: buat volume unik via CLI,
|
|
// tunggu event `create`-nya muncul. Butuh docker CLI + socket.
|
|
func TestIntegrationEvents(t *testing.T) {
|
|
if _, err := os.Stat("/var/run/docker.sock"); err != nil {
|
|
t.Skip("docker socket tidak ada")
|
|
}
|
|
if _, err := exec.LookPath("docker"); err != nil {
|
|
t.Skip("docker CLI tidak ada")
|
|
}
|
|
c, err := New()
|
|
if err != nil {
|
|
t.Fatalf("New: %v", err)
|
|
}
|
|
defer c.Close()
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
|
defer cancel()
|
|
ch := c.StreamEvents(ctx)
|
|
time.Sleep(400 * time.Millisecond) // beri waktu stream tersambung
|
|
|
|
name := fmt.Sprintf("tiae2e%d", os.Getpid())
|
|
if out, err := exec.Command("docker", "volume", "create", name).CombinedOutput(); err != nil {
|
|
t.Skipf("docker volume create gagal: %v (%s)", err, out)
|
|
}
|
|
defer exec.Command("docker", "volume", "rm", name).Run() //nolint:errcheck
|
|
|
|
deadline := time.After(8 * time.Second)
|
|
for {
|
|
select {
|
|
case ev, ok := <-ch:
|
|
if !ok {
|
|
t.Fatal("stream event tertutup lebih awal")
|
|
}
|
|
if ev.Type == "volume" && ev.Actor == name && ev.Action == "create" {
|
|
t.Logf("event diterima: %s %s '%s'", ev.At.Format("15:04:05"), ev.Action, ev.Actor)
|
|
return
|
|
}
|
|
case <-deadline:
|
|
t.Fatal("event volume create tidak diterima dalam 8 dtk")
|
|
}
|
|
}
|
|
}
|