| // Copyright The Prometheus Authors |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| //go:build linux |
| |
| package sysfs |
| |
| import ( |
| "os" |
| "path/filepath" |
| "testing" |
| |
| "github.com/google/go-cmp/cmp" |
| ) |
| |
| func TestNVMeClass(t *testing.T) { |
| // Check if test fixtures exist |
| if _, err := os.Stat(sysTestFixtures); os.IsNotExist(err) { |
| t.Skip("Test fixtures not available, skipping NVMe class tests") |
| return |
| } |
| |
| fs, err := NewFS(sysTestFixtures) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| got, err := fs.NVMeClass() |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| want := NVMeClass{ |
| "nvme0": NVMeDevice{ |
| Name: "nvme0", |
| FirmwareRevision: "1B2QEXP7", |
| Model: "Samsung SSD 970 PRO 512GB", |
| Serial: "S680HF8N190894I", |
| State: "live", |
| ControllerID: "1997", |
| Namespaces: []NVMeNamespace{ |
| { |
| ID: "0", |
| UsedBlocks: 488281250, |
| SizeBlocks: 3906250000, |
| LogicalBlockSize: 4096, |
| ANAState: "optimized", |
| UsedBytes: 2000000000000, |
| SizeBytes: 16000000000000, |
| CapacityBytes: 16000000000000, |
| }, |
| }, |
| }, |
| } |
| |
| if diff := cmp.Diff(want, got); diff != "" { |
| t.Fatalf("unexpected NVMe class (-want +got):\n%s", diff) |
| } |
| } |
| |
| func TestNVMeNamespaceParsingWithMockData(t *testing.T) { |
| // Create a temporary directory structure for testing namespace parsing |
| tempDir := t.TempDir() |
| |
| // Create mock NVMe device directory structure |
| deviceDir := filepath.Join(tempDir, "class", "nvme", "nvme0") |
| err := os.MkdirAll(deviceDir, 0o755) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| // Create device files |
| deviceFiles := map[string]string{ |
| "firmware_rev": "1B2QEXP7", |
| "model": "Samsung SSD 970 PRO 512GB", |
| "serial": "S680HF8N190894I", |
| "state": "live", |
| "cntlid": "1997", |
| } |
| |
| for filename, content := range deviceFiles { |
| err := os.WriteFile(filepath.Join(deviceDir, filename), []byte(content), 0o644) |
| if err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| // Create mock namespace directory and files |
| namespaceDir := filepath.Join(deviceDir, "nvme0c0n1") |
| err = os.MkdirAll(filepath.Join(namespaceDir, "queue"), 0o755) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| namespaceFiles := map[string]string{ |
| "nuse": "123456", |
| "size": "1000215216", |
| "ana_state": "optimized", |
| "queue/logical_block_size": "512", |
| } |
| |
| for filename, content := range namespaceFiles { |
| filePath := filepath.Join(namespaceDir, filename) |
| err := os.WriteFile(filePath, []byte(content), 0o644) |
| if err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| // Create filesystem and test |
| fs, err := NewFS(tempDir) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| got, err := fs.NVMeClass() |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| // Verify the device was parsed correctly |
| if len(got) != 1 { |
| t.Fatalf("Expected 1 device, got %d", len(got)) |
| } |
| |
| device, exists := got["nvme0"] |
| if !exists { |
| t.Fatal("Expected nvme0 device not found") |
| } |
| |
| // Verify device properties |
| if device.Name != "nvme0" { |
| t.Errorf("Expected device name nvme0, got %s", device.Name) |
| } |
| |
| if device.Model != "Samsung SSD 970 PRO 512GB" { |
| t.Errorf("Expected model 'Samsung SSD 970 PRO 512GB', got %s", device.Model) |
| } |
| |
| // Verify namespace was parsed correctly |
| if len(device.Namespaces) != 1 { |
| t.Fatalf("Expected 1 namespace, got %d", len(device.Namespaces)) |
| } |
| |
| namespace := device.Namespaces[0] |
| expectedNamespace := NVMeNamespace{ |
| ID: "1", |
| UsedBlocks: 123456, |
| SizeBlocks: 1000215216, |
| LogicalBlockSize: 512, |
| ANAState: "optimized", |
| UsedBytes: 123456 * 512, |
| SizeBytes: 1000215216 * 512, |
| CapacityBytes: 1000215216 * 512, |
| } |
| |
| if diff := cmp.Diff(expectedNamespace, namespace); diff != "" { |
| t.Fatalf("unexpected NVMe namespace (-want +got):\n%s", diff) |
| } |
| } |
| |
| func TestNVMeMultipleNamespaces(t *testing.T) { |
| // Create a temporary directory structure for testing multiple namespaces |
| tempDir := t.TempDir() |
| |
| // Create mock NVMe device directory structure |
| deviceDir := filepath.Join(tempDir, "class", "nvme", "nvme1") |
| err := os.MkdirAll(deviceDir, 0o755) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| // Create device files |
| deviceFiles := map[string]string{ |
| "firmware_rev": "2C3DEXP8", |
| "model": "Test NVMe SSD 1TB", |
| "serial": "TEST123456789", |
| "state": "live", |
| "cntlid": "2048", |
| } |
| |
| for filename, content := range deviceFiles { |
| err := os.WriteFile(filepath.Join(deviceDir, filename), []byte(content), 0o644) |
| if err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| // Create multiple mock namespace directories |
| namespaces := []struct { |
| dirName string |
| nsID string |
| nuse string |
| size string |
| anaState string |
| blockSize string |
| }{ |
| {"nvme1c0n1", "1", "100000", "2000000000", "optimized", "4096"}, |
| {"nvme1c0n2", "2", "50000", "1000000000", "active", "512"}, |
| } |
| |
| for _, ns := range namespaces { |
| namespaceDir := filepath.Join(deviceDir, ns.dirName) |
| err = os.MkdirAll(filepath.Join(namespaceDir, "queue"), 0o755) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| namespaceFiles := map[string]string{ |
| "nuse": ns.nuse, |
| "size": ns.size, |
| "ana_state": ns.anaState, |
| "queue/logical_block_size": ns.blockSize, |
| } |
| |
| for filename, content := range namespaceFiles { |
| filePath := filepath.Join(namespaceDir, filename) |
| err := os.WriteFile(filePath, []byte(content), 0o644) |
| if err != nil { |
| t.Fatal(err) |
| } |
| } |
| } |
| |
| // Create filesystem and test |
| fs, err := NewFS(tempDir) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| got, err := fs.NVMeClass() |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| // Verify the device was parsed correctly |
| if len(got) != 1 { |
| t.Fatalf("Expected 1 device, got %d", len(got)) |
| } |
| |
| device, exists := got["nvme1"] |
| if !exists { |
| t.Fatal("Expected nvme1 device not found") |
| } |
| |
| // Verify both namespaces were parsed correctly |
| if len(device.Namespaces) != 2 { |
| t.Fatalf("Expected 2 namespaces, got %d", len(device.Namespaces)) |
| } |
| |
| // Find namespace 1 |
| var ns1, ns2 *NVMeNamespace |
| findNamespaces: |
| for i := range device.Namespaces { |
| switch device.Namespaces[i].ID { |
| case "1": |
| ns1 = &device.Namespaces[i] |
| if ns2 != nil { |
| break findNamespaces |
| } |
| case "2": |
| ns2 = &device.Namespaces[i] |
| if ns1 != nil { |
| break findNamespaces |
| } |
| } |
| } |
| |
| if ns1 == nil { |
| t.Fatal("Namespace 1 not found") |
| } |
| if ns2 == nil { |
| t.Fatal("Namespace 2 not found") |
| } |
| |
| // Verify namespace 1 |
| expectedNS1 := NVMeNamespace{ |
| ID: "1", |
| UsedBlocks: 100000, |
| SizeBlocks: 2000000000, |
| LogicalBlockSize: 4096, |
| ANAState: "optimized", |
| UsedBytes: 100000 * 4096, |
| SizeBytes: 2000000000 * 4096, |
| CapacityBytes: 2000000000 * 4096, |
| } |
| |
| if diff := cmp.Diff(expectedNS1, *ns1); diff != "" { |
| t.Errorf("unexpected NVMe namespace 1 (-want +got):\n%s", diff) |
| } |
| |
| // Verify namespace 2 |
| expectedNS2 := NVMeNamespace{ |
| ID: "2", |
| UsedBlocks: 50000, |
| SizeBlocks: 1000000000, |
| LogicalBlockSize: 512, |
| ANAState: "active", |
| UsedBytes: 50000 * 512, |
| SizeBytes: 1000000000 * 512, |
| CapacityBytes: 1000000000 * 512, |
| } |
| |
| if diff := cmp.Diff(expectedNS2, *ns2); diff != "" { |
| t.Errorf("unexpected NVMe namespace 2 (-want +got):\n%s", diff) |
| } |
| } |
| |
| func TestNVMeNamespaceMissingFiles(t *testing.T) { |
| // Test graceful handling of missing namespace files |
| tempDir := t.TempDir() |
| |
| // Create mock NVMe device directory structure |
| deviceDir := filepath.Join(tempDir, "class", "nvme", "nvme2") |
| err := os.MkdirAll(deviceDir, 0o755) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| // Create device files |
| deviceFiles := map[string]string{ |
| "firmware_rev": "3D4EEXP9", |
| "model": "Incomplete Test SSD", |
| "serial": "INCOMPLETE123", |
| "state": "live", |
| "cntlid": "3072", |
| } |
| |
| for filename, content := range deviceFiles { |
| err := os.WriteFile(filepath.Join(deviceDir, filename), []byte(content), 0o644) |
| if err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| // Create namespace directory but with missing files |
| namespaceDir := filepath.Join(deviceDir, "nvme2c0n1") |
| err = os.MkdirAll(filepath.Join(namespaceDir, "queue"), 0o755) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| // Only create some files, leaving ana_state missing |
| namespaceFiles := map[string]string{ |
| "nuse": "75000", |
| "size": "1500000000", |
| "queue/logical_block_size": "4096", |
| // ana_state is intentionally missing |
| } |
| |
| for filename, content := range namespaceFiles { |
| filePath := filepath.Join(namespaceDir, filename) |
| err := os.WriteFile(filePath, []byte(content), 0o644) |
| if err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| // Create filesystem and test |
| fs, err := NewFS(tempDir) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| got, err := fs.NVMeClass() |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| // Verify the device was parsed correctly |
| if len(got) != 1 { |
| t.Fatalf("Expected 1 device, got %d", len(got)) |
| } |
| |
| device, exists := got["nvme2"] |
| if !exists { |
| t.Fatal("Expected nvme2 device not found") |
| } |
| |
| // Verify namespace was parsed correctly with default ana_state |
| if len(device.Namespaces) != 1 { |
| t.Fatalf("Expected 1 namespace, got %d", len(device.Namespaces)) |
| } |
| |
| namespace := device.Namespaces[0] |
| |
| // Should have default "unknown" ana_state |
| if namespace.ANAState != "unknown" { |
| t.Errorf("Expected ana_state 'unknown', got %s", namespace.ANAState) |
| } |
| |
| // Other values should be parsed correctly |
| if namespace.UsedBlocks != 75000 { |
| t.Errorf("Expected UsedBlocks 75000, got %d", namespace.UsedBlocks) |
| } |
| |
| if namespace.SizeBlocks != 1500000000 { |
| t.Errorf("Expected SizeBlocks 1500000000, got %d", namespace.SizeBlocks) |
| } |
| |
| if namespace.LogicalBlockSize != 4096 { |
| t.Errorf("Expected LogicalBlockSize 4096, got %d", namespace.LogicalBlockSize) |
| } |
| } |
