bee/audit/internal/collector/storage_scsi_test.go

package collector

import (
	"testing"

	"bee/audit/internal/schema"
)

func TestApplySCSISmartctlTelemetry(t *testing.T) {
	t.Parallel()

	raw := map[string]any{
		"power_on_time": map[string]any{
			"hours": float64(32123),
		},
		"accumulated_start_stop_cycles":       float64(17),
		"scsi_grown_defect_list":              float64(4),
		"percentage_used_endurance_indicator": float64(12),
		"logical_block_size":                  float64(4096),
		"logical_blocks_written":              float64(1000),
		"logical_blocks_read":                 float64(2000),
	}

	var disk schema.HardwareStorage
	status := storageHealthStatus{}
	applySCSISmartctlTelemetry(&disk, raw, &status)

	if disk.PowerOnHours == nil || *disk.PowerOnHours != 32123 {
		t.Fatalf("power_on_hours=%v want 32123", disk.PowerOnHours)
	}
	if disk.PowerCycles == nil || *disk.PowerCycles != 17 {
		t.Fatalf("power_cycles=%v want 17", disk.PowerCycles)
	}
	if disk.ReallocatedSectors == nil || *disk.ReallocatedSectors != 4 {
		t.Fatalf("reallocated=%v want 4", disk.ReallocatedSectors)
	}
	if disk.WrittenBytes == nil || *disk.WrittenBytes != 4096000 {
		t.Fatalf("written_bytes=%v want 4096000", disk.WrittenBytes)
	}
	if disk.ReadBytes == nil || *disk.ReadBytes != 8192000 {
		t.Fatalf("read_bytes=%v want 8192000", disk.ReadBytes)
	}
	if disk.LogicalBlockSizeBytes == nil || *disk.LogicalBlockSizeBytes != 4096 {
		t.Fatalf("logical_block_size_bytes=%v want 4096", disk.LogicalBlockSizeBytes)
	}
	if disk.MetadataBytesPerBlock == nil || *disk.MetadataBytesPerBlock != 0 {
		t.Fatalf("metadata_bytes_per_block=%v want 0", disk.MetadataBytesPerBlock)
	}
	if disk.LifeUsedPct == nil || *disk.LifeUsedPct != 12 {
		t.Fatalf("life_used_pct=%v want 12", disk.LifeUsedPct)
	}
	if disk.LifeRemainingPct == nil || *disk.LifeRemainingPct != 88 {
		t.Fatalf("life_remaining_pct=%v want 88", disk.LifeRemainingPct)
	}
	if status.reallocatedSectors != 4 {
		t.Fatalf("status.reallocated=%d want 4", status.reallocatedSectors)
	}
	if status.lifeRemainingPct != 88 {
		t.Fatalf("status.life_remaining_pct=%d want 88", status.lifeRemainingPct)
	}
}

func TestApplySCSISmartctlTelemetryDoesNotOverwriteExistingValues(t *testing.T) {
	t.Parallel()

	powerOnHours := int64(10)
	writtenBytes := int64(20)
	lifeRemaining := 30.0
	disk := schema.HardwareStorage{
		PowerOnHours:     &powerOnHours,
		WrittenBytes:     &writtenBytes,
		LifeRemainingPct: &lifeRemaining,
	}
	raw := map[string]any{
		"power_on_time":                       map[string]any{"hours": float64(999)},
		"logical_block_size":                  float64(512),
		"logical_blocks_written":              float64(999),
		"percentage_used_endurance_indicator": float64(50),
	}

	applySCSISmartctlTelemetry(&disk, raw, nil)

	if *disk.PowerOnHours != 10 {
		t.Fatalf("power_on_hours overwritten: got %d want 10", *disk.PowerOnHours)
	}
	if *disk.WrittenBytes != 20 {
		t.Fatalf("written_bytes overwritten: got %d want 20", *disk.WrittenBytes)
	}
	if disk.LogicalBlockSizeBytes == nil || *disk.LogicalBlockSizeBytes != 512 {
		t.Fatalf("logical_block_size_bytes=%v want 512", disk.LogicalBlockSizeBytes)
	}
	if disk.MetadataBytesPerBlock == nil || *disk.MetadataBytesPerBlock != 0 {
		t.Fatalf("metadata_bytes_per_block=%v want 0", disk.MetadataBytesPerBlock)
	}
	if *disk.LifeRemainingPct != 30 {
		t.Fatalf("life_remaining_pct overwritten: got %v want 30", *disk.LifeRemainingPct)
	}
	if disk.LifeUsedPct == nil || *disk.LifeUsedPct != 50 {
		t.Fatalf("life_used_pct=%v want 50", disk.LifeUsedPct)
	}
}

func TestSmartctlModelNamePrefersATAModelName(t *testing.T) {
	t.Parallel()

	info := smartctlInfo{
		ModelName:     "Samsung SSD 970 EVO",
		ScsiModelName: "should not be used",
	}
	if got := smartctlModelName(info); got != "Samsung SSD 970 EVO" {
		t.Fatalf("model=%q want %q", got, "Samsung SSD 970 EVO")
	}
}

func TestSmartctlModelNameFallsBackToScsiModelName(t *testing.T) {
	t.Parallel()

	// NVMe drive exposed through a RAID/HBA passthrough as /dev/sdX:
	// smartctl reports it over the SCSI protocol, so model_name is empty
	// and the model only shows up as scsi_model_name.
	info := smartctlInfo{
		ScsiModelName: "NVMe SSSTC CA6-8D1024",
		ScsiVendor:    "NVMe",
		ScsiProduct:   "SSSTC CA6-8D1024",
	}
	if got := smartctlModelName(info); got != "NVMe SSSTC CA6-8D1024" {
		t.Fatalf("model=%q want %q", got, "NVMe SSSTC CA6-8D1024")
	}
}

func TestSmartctlModelNameFallsBackToScsiVendorProduct(t *testing.T) {
	t.Parallel()

	info := smartctlInfo{
		ScsiVendor:  "NVMe",
		ScsiProduct: "SSSTC CA6-8D1024",
	}
	if got := smartctlModelName(info); got != "NVMe SSSTC CA6-8D1024" {
		t.Fatalf("model=%q want %q", got, "NVMe SSSTC CA6-8D1024")
	}
}

func TestSmartctlModelNameEmptyWhenNoFieldsSet(t *testing.T) {
	t.Parallel()

	if got := smartctlModelName(smartctlInfo{}); got != "" {
		t.Fatalf("model=%q want empty", got)
	}
}