feat: amd gpu (#831)

test/amd_smi_test.dart

@@ -0,0 +1,412 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:server_box/data/model/server/amd.dart';
+
+const _amdSmiRaw = '''
+[
+  {
+    "name": "AMD Radeon RX 7900 XTX",
+    "device_id": "0",
+    "temp": 45,
+    "power_draw": 120,
+    "power_cap": 355,
+    "memory": {
+      "total": 24576,
+      "used": 1024,
+      "unit": "MB",
+      "processes": [
+        {
+          "pid": 2456,
+          "name": "firefox",
+          "memory": 512
+        },
+        {
+          "pid": 3784,
+          "name": "blender",
+          "memory": 256
+        }
+      ]
+    },
+    "utilization": 75,
+    "fan_speed": 1200,
+    "clock_speed": 2400
+  },
+  {
+    "name": "AMD Radeon RX 6800 XT",
+    "device_id": "1",
+    "temp": 38,
+    "power_draw": 85,
+    "power_cap": 300,
+    "memory": {
+      "total": 16384,
+      "used": 512,
+      "unit": "MB",
+      "processes": []
+    },
+    "utilization": 25,
+    "fan_speed": 800,
+    "clock_speed": 2100
+  }
+]
+''';
+
+const _amdSmiRocmRaw = '''
+[
+  {
+    "card_model": "AMD Radeon RX 6700 XT",
+    "gpu_id": "card0",
+    "temperature": "42°C",
+    "power_draw": "95",
+    "power_cap": "230",
+    "vram": {
+      "total_memory": 12288,
+      "used_memory": 768,
+      "unit": "MiB",
+      "processes": [
+        {
+          "pid": 1234,
+          "process_name": "game.exe",
+          "used_memory": 512
+        }
+      ]
+    },
+    "gpu_util": "60%",
+    "fan_rpm": "950 RPM",
+    "sclk": "1800MHz"
+  }
+]
+''';
+
+const _amdSmiAlternativeRaw = '''
+[
+  {
+    "device_name": "Radeon RX 580",
+    "gpu_temp": 55,
+    "current_power": 150,
+    "power_limit": 185,
+    "memory": {
+      "total": 8192,
+      "used": 2048,
+      "unit": "MB"
+    },
+    "activity": 90,
+    "fan_speed": 1500,
+    "gpu_clock": 1366
+  }
+]
+''';
+
+const _amdSmiEdgeCasesRaw = '''
+[
+  {
+    "name": "Unknown AMD GPU",
+    "device_id": "",
+    "temp": null,
+    "power": null,
+    "memory": {},
+    "utilization": null,
+    "fan_speed": null,
+    "clock_speed": null
+  },
+  {
+    "name": "AMD Test GPU",
+    "device_id": "test",
+    "temp": "50°C",
+    "power_draw": 100,
+    "memory": {
+      "total": "16384MB",
+      "used": "2048MB"
+    },
+    "utilization": "80%",
+    "fan_speed": "1100 RPM",
+    "clock_speed": "2000 MHz"
+  }
+]
+''';
+
+const _invalidJson = '''
+{
+  "invalid": "not an array"
+}
+''';
+
+const _emptyArray = '[]';
+
+const _malformedJson = '''
+[
+  {
+    "name": "Test GPU"
+    // missing closing brace
+''';
+
+void main() {
+  group('AmdSmi JSON parsing', () {
+    test('parse standard AMD SMI output', () {
+      final gpus = AmdSmi.fromJson(_amdSmiRaw);
+      expect(gpus.length, 2);
+
+      final gpu1 = gpus[0];
+      expect(gpu1.name, 'AMD Radeon RX 7900 XTX');
+      expect(gpu1.deviceId, '0');
+      expect(gpu1.temp, 45);
+      expect(gpu1.power, '120W / 355W');
+      expect(gpu1.memory.total, 24576);
+      expect(gpu1.memory.used, 1024);
+      expect(gpu1.memory.unit, 'MB');
+      expect(gpu1.memory.processes.length, 2);
+      expect(gpu1.memory.processes[0].pid, 2456);
+      expect(gpu1.memory.processes[0].name, 'firefox');
+      expect(gpu1.memory.processes[0].memory, 512);
+      expect(gpu1.memory.processes[1].pid, 3784);
+      expect(gpu1.memory.processes[1].name, 'blender');
+      expect(gpu1.memory.processes[1].memory, 256);
+      expect(gpu1.utilization, 75);
+      expect(gpu1.fanSpeed, 1200);
+      expect(gpu1.clockSpeed, 2400);
+
+      final gpu2 = gpus[1];
+      expect(gpu2.name, 'AMD Radeon RX 6800 XT');
+      expect(gpu2.deviceId, '1');
+      expect(gpu2.temp, 38);
+      expect(gpu2.power, '85W / 300W');
+      expect(gpu2.memory.total, 16384);
+      expect(gpu2.memory.used, 512);
+      expect(gpu2.memory.unit, 'MB');
+      expect(gpu2.memory.processes.length, 0);
+      expect(gpu2.utilization, 25);
+      expect(gpu2.fanSpeed, 800);
+      expect(gpu2.clockSpeed, 2100);
+    });
+
+    test('parse ROCm SMI output with different field names', () {
+      final gpus = AmdSmi.fromJson(_amdSmiRocmRaw);
+      expect(gpus.length, 1);
+
+      final gpu = gpus[0];
+      expect(gpu.name, 'AMD Radeon RX 6700 XT');
+      expect(gpu.deviceId, 'card0');
+      expect(gpu.temp, 42);
+      expect(gpu.power, '95W / 230W');
+      expect(gpu.memory.total, 12288);
+      expect(gpu.memory.used, 768);
+      expect(gpu.memory.unit, 'MiB');
+      expect(gpu.memory.processes.length, 1);
+      expect(gpu.memory.processes[0].pid, 1234);
+      expect(gpu.memory.processes[0].name, 'game.exe');
+      expect(gpu.memory.processes[0].memory, 512);
+      expect(gpu.utilization, 60);
+      expect(gpu.fanSpeed, 950);
+      expect(gpu.clockSpeed, 1800);
+    });
+
+    test('parse alternative field names', () {
+      final gpus = AmdSmi.fromJson(_amdSmiAlternativeRaw);
+      expect(gpus.length, 1);
+
+      final gpu = gpus[0];
+      expect(gpu.name, 'Radeon RX 580');
+      expect(gpu.deviceId, '0');
+      expect(gpu.temp, 55);
+      expect(gpu.power, '150W / 185W');
+      expect(gpu.memory.total, 8192);
+      expect(gpu.memory.used, 2048);
+      expect(gpu.memory.unit, 'MB');
+      expect(gpu.memory.processes.length, 0);
+      expect(gpu.utilization, 90);
+      expect(gpu.fanSpeed, 1500);
+      expect(gpu.clockSpeed, 1366);
+    });
+
+    test('handle edge cases and string parsing', () {
+      final gpus = AmdSmi.fromJson(_amdSmiEdgeCasesRaw);
+      expect(gpus.length, 2);
+
+      final gpu1 = gpus[0];
+      expect(gpu1.name, 'Unknown AMD GPU');
+      expect(gpu1.deviceId, '');
+      expect(gpu1.temp, 0);
+      expect(gpu1.power, 'N/A');
+      expect(gpu1.memory.total, 0);
+      expect(gpu1.memory.used, 0);
+      expect(gpu1.memory.unit, 'MB');
+      expect(gpu1.memory.processes.length, 0);
+      expect(gpu1.utilization, 0);
+      expect(gpu1.fanSpeed, 0);
+      expect(gpu1.clockSpeed, 0);
+
+      final gpu2 = gpus[1];
+      expect(gpu2.name, 'AMD Test GPU');
+      expect(gpu2.deviceId, 'test');
+      expect(gpu2.temp, 50);
+      expect(gpu2.power, '100W');
+      expect(gpu2.memory.total, 16384);
+      expect(gpu2.memory.used, 2048);
+      expect(gpu2.memory.unit, 'MB');
+      expect(gpu2.utilization, 80);
+      expect(gpu2.fanSpeed, 1100);
+      expect(gpu2.clockSpeed, 2000);
+    });
+
+    test('handle invalid JSON gracefully', () {
+      final gpus1 = AmdSmi.fromJson(_invalidJson);
+      expect(gpus1.length, 0);
+
+      final gpus2 = AmdSmi.fromJson(_malformedJson);
+      expect(gpus2.length, 0);
+
+      final gpus3 = AmdSmi.fromJson('invalid json');
+      expect(gpus3.length, 0);
+    });
+
+    test('handle empty array', () {
+      final gpus = AmdSmi.fromJson(_emptyArray);
+      expect(gpus.length, 0);
+    });
+  });
+
+  group('AmdSmi helper methods', () {
+    test('_parseIntValue handles various input types', () {
+      expect(AmdSmi.fromJson('[{"name":"test","temp":42}]')[0].temp, 42);
+      expect(AmdSmi.fromJson('[{"name":"test","temp":"45°C"}]')[0].temp, 45);
+      expect(AmdSmi.fromJson('[{"name":"test","temp":"1200 RPM"}]')[0].temp, 1200);
+      expect(AmdSmi.fromJson('[{"name":"test","temp":"N/A"}]')[0].temp, 0);
+      expect(AmdSmi.fromJson('[{"name":"test","temp":null}]')[0].temp, 0);
+    });
+
+    test('_formatPower handles different power scenarios', () {
+      final gpu1 = AmdSmi.fromJson('[{"name":"test","power_draw":100,"power_cap":200}]')[0];
+      expect(gpu1.power, '100W / 200W');
+
+      final gpu2 = AmdSmi.fromJson('[{"name":"test","power_draw":50}]')[0];
+      expect(gpu2.power, '50W');
+
+      final gpu3 = AmdSmi.fromJson('[{"name":"test"}]')[0];
+      expect(gpu3.power, 'N/A');
+    });
+
+    test('_parseMemory handles missing memory data', () {
+      final gpu = AmdSmi.fromJson('[{"name":"test"}]')[0];
+      expect(gpu.memory.total, 0);
+      expect(gpu.memory.used, 0);
+      expect(gpu.memory.unit, 'MB');
+      expect(gpu.memory.processes.length, 0);
+    });
+
+    test('_parseProcess filters invalid processes', () {
+      const jsonWithInvalidProcess = '''
+      [
+        {
+          "name": "Test GPU",
+          "memory": {
+            "processes": [
+              {
+                "pid": 0,
+                "name": "invalid",
+                "memory": 100
+              },
+              {
+                "pid": 1234,
+                "name": "valid",
+                "memory": 200
+              }
+            ]
+          }
+        }
+      ]
+      ''';
+      
+      final gpu = AmdSmi.fromJson(jsonWithInvalidProcess)[0];
+      expect(gpu.memory.processes.length, 1);
+      expect(gpu.memory.processes[0].pid, 1234);
+      expect(gpu.memory.processes[0].name, 'valid');
+    });
+  });
+
+  group('AmdSmi data classes', () {
+    test('AmdSmiItem toString', () {
+      final memory = AmdSmiMem(8192, 2048, 'MB', []);
+      final item = AmdSmiItem(
+        deviceId: '0',
+        name: 'Test GPU',
+        temp: 45,
+        power: '100W / 200W',
+        memory: memory,
+        utilization: 75,
+        fanSpeed: 1200,
+        clockSpeed: 2400,
+      );
+
+      final toString = item.toString();
+      expect(toString, contains('Test GPU'));
+      expect(toString, contains('45'));
+      expect(toString, contains('100W / 200W'));
+      expect(toString, contains('75%'));
+    });
+
+    test('AmdSmiMem toString', () {
+      final process = AmdSmiMemProcess(1234, 'test', 512);
+      final memory = AmdSmiMem(8192, 2048, 'MB', [process]);
+
+      final toString = memory.toString();
+      expect(toString, contains('8192'));
+      expect(toString, contains('2048'));
+      expect(toString, contains('MB'));
+      expect(toString, contains('1'));
+    });
+
+    test('AmdSmiMemProcess toString', () {
+      final process = AmdSmiMemProcess(1234, 'firefox', 512);
+
+      final toString = process.toString();
+      expect(toString, contains('1234'));
+      expect(toString, contains('firefox'));
+      expect(toString, contains('512'));
+    });
+  });
+
+  group('AmdSmi robustness', () {
+    test('handles malformed GPU objects gracefully', () {
+      const malformedGpuJson = '''
+      [
+        {
+          "name": "Valid GPU",
+          "temp": 45
+        },
+        {
+          "malformed": true
+        },
+        {
+          "name": "Another Valid GPU",
+          "temp": 50
+        }
+      ]
+      ''';
+
+      final gpus = AmdSmi.fromJson(malformedGpuJson);
+      expect(gpus.length, 3);
+      expect(gpus[0].name, 'Valid GPU');
+      expect(gpus[0].temp, 45);
+      expect(gpus[1].name, 'Unknown AMD GPU');
+      expect(gpus[1].temp, 0);
+      expect(gpus[2].name, 'Another Valid GPU');
+      expect(gpus[2].temp, 50);
+    });
+
+    test('handles missing required fields with defaults', () {
+      const minimalGpuJson = '''
+      [
+        {}
+      ]
+      ''';
+
+      final gpus = AmdSmi.fromJson(minimalGpuJson);
+      expect(gpus.length, 1);
+      expect(gpus[0].name, 'Unknown AMD GPU');
+      expect(gpus[0].deviceId, '0');
+      expect(gpus[0].temp, 0);
+      expect(gpus[0].power, 'N/A');
+      expect(gpus[0].utilization, 0);
+      expect(gpus[0].fanSpeed, 0);
+      expect(gpus[0].clockSpeed, 0);
+    });
+  });
+}