Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

9.7 KB
Raw Blame
package monitoring

import (
	"context"
	"errors"
	"fmt"
	"math"
	"os"
	"os/exec"
	"strings"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// mockCommandRunner implements CommandRunner for testing
type mockCommandRunner struct {
	outputs       map[string]string // map command substring to output
	errs          map[string]error  // map command substring to error
	callCount     int
	sawDeadline   bool
	lastDeadline  time.Time
	lastHasDeadln bool
}

func (m *mockCommandRunner) Run(ctx context.Context, name string, args ...string) ([]byte, error) {
	m.callCount++
	if deadline, ok := ctx.Deadline(); ok {
		m.sawDeadline = true
		m.lastHasDeadln = true
		m.lastDeadline = deadline
	}

	fullCmd := name + " " + strings.Join(args, " ")

	// Check for errors first
	for k, v := range m.errs {
		if strings.Contains(fullCmd, k) {
			return nil, v
		}
	}

	// Check for outputs
	for k, v := range m.outputs {
		if strings.Contains(fullCmd, k) {
			return []byte(v), nil
		}
	}

	return nil, nil
}

func TestTemperatureCollector_Parsing(t *testing.T) {
	// Create dummy key file
	tmpKey := t.TempDir() + "/id_rsa"
	_ = os.WriteFile(tmpKey, []byte("dummy key"), 0600)

	tc := NewTemperatureCollectorWithPort("root", tmpKey, 22)
	tc.hostKeys = nil // Disable real network calls for host key verification
	runner := &mockCommandRunner{
		outputs: make(map[string]string),
		errs:    make(map[string]error),
	}
	tc.runner = runner

	// Test case: Valid sensors JSON (CPU + NVMe)
	sensorsJSON := `{
		"coretemp-isa-0000": {
			"Package id 0": { "temp1_input": 45.5 },
			"Core 0": { "temp2_input": 42.0 },
			"Core 1": { "temp3_input": 43.0 }
		},
		"nvme-pci-0100": {
			"Composite": { "temp1_input": 38.5 }
		}
	}`

	runner.outputs["sensors -j"] = sensorsJSON

	temp, err := tc.CollectTemperature(context.Background(), "node1", "node1")
	require.NoError(t, err)
	require.NotNil(t, temp)
	assert.True(t, temp.Available)
	assert.Equal(t, 45.5, temp.CPUPackage)
	assert.Len(t, temp.Cores, 2)
	assert.Len(t, temp.NVMe, 1)
	assert.Equal(t, 38.5, temp.NVMe[0].Temp)

	// Test case: Valid RPi fallback
	runner.outputs["sensors -j"] = ""         // Empty sensors output
	runner.outputs["thermal_zone0"] = "55123" // 55.123 C

	temp2, err := tc.CollectTemperature(context.Background(), "node2", "node2")
	require.NoError(t, err)
	require.NotNil(t, temp2)
	assert.InDelta(t, 55.123, temp2.CPUPackage, 0.001)

	// Test case: Both fail
	runner = &mockCommandRunner{
		errs: map[string]error{
			"sensors -j":    errors.New("command missing"),
			"thermal_zone0": errors.New("no file"),
		},
	}
	tc.runner = runner
	temp3, err := tc.CollectTemperature(context.Background(), "node3", "node3")
	require.NoError(t, err)
	assert.False(t, temp3.Available)
}

func TestTemperatureCollector_ParseSensorsJSON_Complex(t *testing.T) {
	tc := &TemperatureCollector{}

	// AMD GPU and specific chips
	jsonStr := `{
		"amdgpu-pci-0800": {
			"edge": { "temp1_input": 50.0 },
			"junction": { "temp2_input": 65.0 },
			"mem": { "temp3_input": 55.0 }
		},
		"k10temp-pci-00c3": {
			"Tctl": { "temp1_input": 60.5 },
			"Tccd1": { "temp3_input": 58.0 }
		}
	}`

	temp, err := tc.parseSensorsJSON(jsonStr)
	require.NoError(t, err)
	assert.True(t, temp.HasGPU)
	assert.Equal(t, 50.0, temp.GPU[0].Edge)
	assert.Equal(t, 65.0, temp.GPU[0].Junction)
	assert.Equal(t, 60.5, temp.CPUPackage) // Tctl mapped to package
}

func TestExtractTempInput_StringValues(t *testing.T) {
	t.Run("parses celsius strings with suffix", func(t *testing.T) {
		got := extractTempInput(map[string]interface{}{
			"temp1_input": "+44.5°C",
		})
		assert.InDelta(t, 44.5, got, 0.0001)
	})

	t.Run("parses millidegree strings", func(t *testing.T) {
		got := extractTempInput(map[string]interface{}{
			"temp1_input": "39000",
		})
		assert.InDelta(t, 39.0, got, 0.0001)
	})
}

func TestTemperatureCollector_ParseSensorsJSON_StringTemps(t *testing.T) {
	tc := &TemperatureCollector{}
	jsonStr := `{
		"coretemp-isa-0000": {
			"Package id 0": { "temp1_input": "+47.0°C" },
			"Core 0": { "temp2_input": "45.0" }
		},
		"nvme-pci-0100": {
			"Composite": { "temp1_input": "42000" }
		}
	}`

	temp, err := tc.parseSensorsJSON(jsonStr)
	require.NoError(t, err)
	require.NotNil(t, temp)
	assert.True(t, temp.Available)
	assert.InDelta(t, 47.0, temp.CPUPackage, 0.0001)
	require.Len(t, temp.NVMe, 1)
	assert.InDelta(t, 42.0, temp.NVMe[0].Temp, 0.0001)
}

func TestTemperatureCollector_ParseSensorsJSON_WrapperSMARTTemps(t *testing.T) {
	tc := &TemperatureCollector{}
	jsonStr := `{
		"sensors": {
			"coretemp-isa-0000": {
				"Package id 0": { "temp1_input": 46.0 }
			}
		},
		"smart": [
			{
				"device": "/dev/sda",
				"model": "Samsung SSD 860 EVO",
				"serial": "SATA-SERIAL-1",
				"wwn": "5-c50-1234",
				"type": "sata",
				"temperature": 34,
				"lastUpdated": "2026-05-26T18:00:00Z"
			}
		]
	}`

	temp, err := tc.parseSensorsJSON(jsonStr)
	require.NoError(t, err)
	require.NotNil(t, temp)
	assert.True(t, temp.Available)
	assert.True(t, temp.HasSMART)
	require.Len(t, temp.SMART, 1)
	assert.Equal(t, "/dev/sda", temp.SMART[0].Device)
	assert.Equal(t, "SATA-SERIAL-1", temp.SMART[0].Serial)
	assert.Equal(t, 34, temp.SMART[0].Temperature)
	assert.Equal(t, "sata", temp.SMART[0].Type)
	assert.False(t, temp.LegacySensorsFormat)
}

func TestTemperatureCollector_ParseSensorsJSON_FlagsLegacyFormat(t *testing.T) {
	tc := &TemperatureCollector{}

	// Raw `sensors -j` output, the shape forced by pre-rc.6 authorized_keys
	// entries. Disk (SMART) temperatures can never arrive on this path, so the
	// payload must be flagged for the outdated-sensor-setup notice.
	jsonStr := `{
		"coretemp-isa-0000": {
			"Package id 0": { "temp1_input": 47.0 }
		}
	}`

	temp, err := tc.parseSensorsJSON(jsonStr)
	require.NoError(t, err)
	require.NotNil(t, temp)
	assert.True(t, temp.Available)
	assert.True(t, temp.LegacySensorsFormat)
	assert.False(t, temp.HasSMART)
}

func TestDefaultCommandRunner_RejectsOversizedStdout(t *testing.T) {
	runner := &defaultCommandRunner{}
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	cmd := fmt.Sprintf("head -c %d /dev/zero", maxTemperatureCommandOutputSize+1)
	_, err := runner.Run(ctx, "sh", "-c", cmd)
	require.Error(t, err)
	require.ErrorIs(t, err, errTemperatureCommandOutputTooLarge)
}

func TestDefaultCommandRunner_RejectsOversizedStderr(t *testing.T) {
	runner := &defaultCommandRunner{}
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	cmd := fmt.Sprintf("head -c %d /dev/zero 1>&2; exit 1", maxTemperatureCommandOutputSize+1)
	_, err := runner.Run(ctx, "sh", "-c", cmd)
	require.Error(t, err)
	require.ErrorIs(t, err, errTemperatureCommandOutputTooLarge)
}

func TestTemperatureCollector_RunSSHCommand_OversizedOutput(t *testing.T) {
	tmpKey := t.TempDir() + "/id_rsa"
	require.NoError(t, os.WriteFile(tmpKey, []byte("dummy key"), 0600))

	tc := NewTemperatureCollectorWithPort("root", tmpKey, 22)
	tc.hostKeys = nil
	runner := &mockCommandRunner{
		outputs: make(map[string]string),
		errs:    make(map[string]error),
	}

	exitErr := buildExitErrorWithStderr(t, "Permission denied (publickey) from 10.0.0.2 using /home/pulse/.ssh/id_ed25519_sensors")
	runner.errs[""] = exitErr
	tc.runner = runner

	_, err := tc.runSSHCommand(context.Background(), "node1", "sensors -j")
	require.Error(t, err)
	assert.Contains(t, strings.ToLower(err.Error()), "authentication failed")
	assert.NotContains(t, err.Error(), "10.0.0.2")
	assert.NotContains(t, err.Error(), "id_ed25519_sensors")
}

func TestRunSSHCommand_AppliesDefaultTimeout(t *testing.T) {
	tmpKey := t.TempDir() + "/id_rsa"
	require.NoError(t, os.WriteFile(tmpKey, []byte("dummy key"), 0600))

	tc := NewTemperatureCollectorWithPort("root", tmpKey, 22)
	tc.hostKeys = nil
	runner := &mockCommandRunner{
		outputs: map[string]string{"": "{}"},
		errs:    make(map[string]error),
	}
	tc.runner = runner

	_, err := tc.runSSHCommand(context.Background(), "node1", "sensors -j")
	require.NoError(t, err)
	require.True(t, runner.sawDeadline, "runSSHCommand should enforce a timeout when caller context has no deadline")
	require.True(t, runner.lastHasDeadln)

	timeoutRemaining := time.Until(runner.lastDeadline)
	assert.Greater(t, timeoutRemaining, 0*time.Second)
	assert.LessOrEqual(t, timeoutRemaining, defaultSSHCommandTimeout+time.Second)
}

func buildExitErrorWithStderr(t *testing.T, stderr string) error {
	t.Helper()

	cmd := exec.Command("sh", "-c", "printf '%s' \"$PULSE_TEST_STDERR\" >&2; exit 255")
	cmd.Env = append(os.Environ(), "PULSE_TEST_STDERR="+stderr)
	_, err := cmd.Output()
	require.Error(t, err)

	var exitErr *exec.ExitError
	require.ErrorAs(t, err, &exitErr)

	return err
}

func TestExtractTempInputKeepsSensorUnits(t *testing.T) {
	for _, key := range []string{"fan1_input", "in1_input", "curr1_input", "power1_input", "freq1_input", "energy1_input", "temperature_input"} {
		for _, value := range []any{6152.0, 45, "+45.0°C"} {
			assert.True(t, math.IsNaN(extractTempInput(map[string]any{key: value})), "%s must not become Celsius", key)
		}
	}
	for range 32 {
		assert.Equal(t, 34.2, extractTempInput(map[string]any{"fan1_input": 6152.0, "in1_input": 12.1, "temp12_input": 34.2}))
	}
}

func TestTemperatureCollectorNonTemperatureInputIsNotTypedTemperature(t *testing.T) {
	for _, input := range []string{
		`{"coretemp-isa-0000":{"Package id 0":{"fan1_input":6152},"Core 0":{"in1_input":12.1}}}`,
		`{"nvme-pci-0200":{"Composite":{"power1_input":45}}}`,
		`{"amdgpu-pci-0300":{"edge":{"curr1_input":2.5}}}`,
		`{"nouveau-pci-0400":{"GPU core":{"freq1_input":2400}}}`,
	} {
		got, err := (&TemperatureCollector{}).parseSensorsJSON(input)
		require.NoError(t, err)
		assert.Zero(t, got.CPUPackage)
		assert.Zero(t, got.CPUMax)
		assert.Empty(t, got.Cores)
		assert.Empty(t, got.NVMe)
		assert.Empty(t, got.GPU)
	}
}