gilles/onvif-go
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cleanup

Browse Source
This commit is contained in:
ProtoTess
2026-01-16 04:58:24 +00:00
parent 19db372cdc
commit 9cf30e2c41
541 changed files with 1880 additions and 185062 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cmd/generate-tests/main.go
+758 -101
View File
@@ -6,8 +6,10 @@ import (
"log"
"os"
"path/filepath"
"sort"
"strings"
"text/template"
"time"
onviftesting "github.com/0x524a/onvif-go/testing"
)
@@ -16,6 +18,10 @@ var (
captureArchive = flag.String("capture", "", "Path to XML capture archive (.tar.gz)")
outputDir = flag.String("output", "./", "Output directory for generated test file")
packageName = flag.String("package", "onvif_test", "Package name for generated test")
updateRegistry = flag.Bool("update-registry", true, "Update registry.json with camera info")
registryPath = flag.String("registry", "", "Path to registry.json (default: testdata/captures/registry.json)")
coverageReport = flag.Bool("coverage-report", false, "Generate coverage report from registry")
coverageOutput = flag.String("coverage-output", "", "Output path for coverage report (default: stdout)")
)
const testTemplate = `package {{.PackageName}}
@@ -29,12 +35,14 @@ import (
onviftesting "github.com/0x524a/onvif-go/testing"
)
// Test{{.CameraName}} tests ONVIF client against {{.CameraDescription}} captured responses
// Test{{.CameraName}} tests ONVIF client against {{.CameraDescription}} captured responses.
// Capture format: V2 with parameter-aware matching
// Total captured operations: {{.TotalExchanges}}
func Test{{.CameraName}}(t *testing.T) {
// Load capture archive (relative to project root)
captureArchive := "{{.CaptureArchiveRelPath}}"
mockServer, err := onviftesting.NewMockSOAPServer(captureArchive)
mockServer, err := onviftesting.NewMockSOAPServerV2(captureArchive)
if err != nil {
t.Fatalf("Failed to create mock server: %v", err)
}
@@ -52,69 +60,48 @@ func Test{{.CameraName}}(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
t.Run("GetDeviceInformation", func(t *testing.T) {
info, err := client.GetDeviceInformation(ctx)
if err != nil {
t.Errorf("GetDeviceInformation failed: %v", err)
return
}
// Validate expected values
if info.Manufacturer == "" {
t.Error("Manufacturer is empty")
}
if info.Model == "" {
t.Error("Model is empty")
}
if info.FirmwareVersion == "" {
t.Error("FirmwareVersion is empty")
}
t.Logf("Device: %s %s (Firmware: %s)", info.Manufacturer, info.Model, info.FirmwareVersion)
// =========================================================================
// Device Service Operations
// =========================================================================
{{range .DeviceTests}}
t.Run("{{.Name}}", func(t *testing.T) {
{{.Code}}
})
t.Run("GetSystemDateAndTime", func(t *testing.T) {
_, err := client.GetSystemDateAndTime(ctx)
if err != nil {
t.Errorf("GetSystemDateAndTime failed: %v", err)
}
{{end}}
// =========================================================================
// Media Service Operations
// =========================================================================
{{if .NeedsInit}}
// Initialize to discover service endpoints (required for Media/PTZ/Imaging)
if err := client.Initialize(ctx); err != nil {
t.Fatalf("Failed to initialize client: %v", err)
}
{{end}}
{{range .MediaTests}}
t.Run("{{.Name}}", func(t *testing.T) {
{{.Code}}
})
t.Run("GetCapabilities", func(t *testing.T) {
caps, err := client.GetCapabilities(ctx)
if err != nil {
t.Errorf("GetCapabilities failed: %v", err)
return
}
if caps.Device == nil {
t.Error("Device capabilities is nil")
}
if caps.Media == nil {
t.Error("Media capabilities is nil")
}
t.Logf("Capabilities: Device=%v, Media=%v, Imaging=%v, PTZ=%v",
caps.Device != nil, caps.Media != nil, caps.Imaging != nil, caps.PTZ != nil)
{{end}}
// =========================================================================
// Profile-Dependent Operations
// =========================================================================
{{range .ProfileTests}}
t.Run("{{.Name}}", func(t *testing.T) {
{{.Code}}
})
t.Run("GetProfiles", func(t *testing.T) {
profiles, err := client.GetProfiles(ctx)
if err != nil {
t.Errorf("GetProfiles failed: %v", err)
return
}
if len(profiles) == 0 {
t.Error("No profiles returned")
}
t.Logf("Found %d profile(s)", len(profiles))
for i, profile := range profiles {
t.Logf(" Profile %d: %s (Token: %s)", i+1, profile.Name, profile.Token)
}
{{end}}
// =========================================================================
// PTZ Operations
// =========================================================================
{{range .PTZTests}}
t.Run("{{.Name}}", func(t *testing.T) {
{{.Code}}
})
{{range .AdditionalTests}}
{{end}}
// =========================================================================
// Imaging Operations
// =========================================================================
{{range .ImagingTests}}
t.Run("{{.Name}}", func(t *testing.T) {
{{.Code}}
})
@@ -127,17 +114,43 @@ type TestData struct {
CameraName string
CameraDescription string
CaptureArchiveRelPath string
AdditionalTests []AdditionalTest
TotalExchanges int
NeedsInit bool
DeviceTests []GeneratedTest
MediaTests []GeneratedTest
ProfileTests []GeneratedTest
PTZTests []GeneratedTest
ImagingTests []GeneratedTest
}
type AdditionalTest struct {
type GeneratedTest struct {
Name string
Code string
}
// operationInfo holds info about captured operations
type operationInfo struct {
OperationName string
ServiceType onviftesting.ServiceType
Parameters map[string]interface{}
Success bool
}
func main() {
flag.Parse()
// Set default registry path
regPath := *registryPath
if regPath == "" {
regPath = onviftesting.DefaultRegistryPath
}
// Handle coverage report mode
if *coverageReport {
generateCoverageReport(regPath)
return
}
if *captureArchive == "" {
fmt.Println("Error: -capture flag is required")
fmt.Println()
@@ -146,18 +159,29 @@ func main() {
fmt.Println()
fmt.Println("Example:")
fmt.Println(" ./generate-tests -capture camera-logs/Bosch_FLEXIDOME_indoor_5100i_IR_8.71.0066_xmlcapture_*.tar.gz")
fmt.Println()
fmt.Println("Coverage report:")
fmt.Println(" ./generate-tests -coverage-report")
os.Exit(1)
}
// Load capture to get camera info
capture, err := onviftesting.LoadCaptureFromArchive(*captureArchive)
outputFile := generateTests()
// Update registry if requested
if *updateRegistry {
updateCameraRegistry(regPath, *captureArchive, outputFile)
}
}
func generateTests() string {
// Load capture with V2 support
capture, metadata, err := onviftesting.LoadCaptureFromArchiveV2(*captureArchive)
if err != nil {
log.Fatalf("Failed to load capture: %v", err)
}
// Extract camera name from archive filename
baseName := filepath.Base(*captureArchive)
// Remove _xmlcapture_timestamp.tar.gz suffix
parts := strings.Split(baseName, "_xmlcapture_")
cameraID := parts[0]
@@ -166,45 +190,44 @@ func main() {
cameraName = strings.ReplaceAll(cameraName, ".", "")
cameraName = strings.ReplaceAll(cameraName, " ", "")
// Get device info from first exchange (GetDeviceInformation)
// Get camera description from metadata or extract from captures
cameraDesc := cameraID
if len(capture.Exchanges) > 0 {
// Try to parse device info from response
if metadata != nil && metadata.CameraInfo.Manufacturer != "" {
cameraDesc = fmt.Sprintf("%s %s (Firmware: %s)",
metadata.CameraInfo.Manufacturer,
metadata.CameraInfo.Model,
metadata.CameraInfo.FirmwareVersion)
} else {
// Try to extract from GetDeviceInformation response
for _, ex := range capture.Exchanges {
if !strings.Contains(ex.RequestBody, "GetDeviceInformation") {
continue
}
// Extract manufacturer and model from response
manufacturer := extractXMLValue(ex.ResponseBody, "Manufacturer")
model := extractXMLValue(ex.ResponseBody, "Model")
firmware := extractXMLValue(ex.ResponseBody, "FirmwareVersion")
if manufacturer != "" && model != "" {
cameraDesc = fmt.Sprintf("%s %s (Firmware: %s)", manufacturer, model, firmware)
}
break
}
}
// Prepare test data
// Make archive path relative if inside output directory
relArchivePath := *captureArchive
// If archive is in a sibling directory to output, make it relative
if absOutput, err := filepath.Abs(*outputDir); err == nil {
if absArchive, err := filepath.Abs(*captureArchive); err == nil {
if rel, err := filepath.Rel(filepath.Dir(absOutput), absArchive); err == nil {
relArchivePath = rel
if ex.OperationName == "GetDeviceInformation" && ex.Success {
manufacturer := extractXMLValue(ex.ResponseBody, "Manufacturer")
model := extractXMLValue(ex.ResponseBody, "Model")
firmware := extractXMLValue(ex.ResponseBody, "FirmwareVersion")
if manufacturer != "" && model != "" {
cameraDesc = fmt.Sprintf("%s %s (Firmware: %s)", manufacturer, model, firmware)
}
break
}
}
}
// Analyze captured operations
ops := analyzeOperations(capture)
// Generate tests by service type
testData := TestData{
PackageName: *packageName,
CameraName: cameraName,
CameraDescription: cameraDesc,
CaptureArchiveRelPath: relArchivePath,
AdditionalTests: []AdditionalTest{},
CaptureArchiveRelPath: makeRelativePath(*captureArchive, *outputDir),
TotalExchanges: len(capture.Exchanges),
NeedsInit: hasNonDeviceOperations(ops),
DeviceTests: generateDeviceTests(ops),
MediaTests: generateMediaTests(ops),
ProfileTests: generateProfileDependentTests(ops),
PTZTests: generatePTZTests(ops),
ImagingTests: generateImagingTests(ops),
}
// Generate test file
@@ -213,7 +236,6 @@ func main() {
log.Fatalf("Failed to parse template: %v", err)
}
// Create output file
outputFile := filepath.Join(*outputDir, fmt.Sprintf("%s_test.go", strings.ToLower(cameraID)))
f, err := os.Create(outputFile) //nolint:gosec // Filename is generated from test data, safe
if err != nil {
@@ -225,26 +247,481 @@ func main() {
if err := tmpl.Execute(f, testData); err != nil {
_ = f.Close()
//nolint:gocritic // Fatalf exits, defer won't run - this is acceptable
log.Fatalf("Failed to execute template: %v", err)
}
fmt.Printf("✓ Generated test file: %s\n", outputFile)
fmt.Printf(" Camera: %s\n", cameraDesc)
fmt.Printf(" Captured operations: %d\n", len(capture.Exchanges))
fmt.Printf(" Generated subtests: Device=%d, Media=%d, Profile=%d, PTZ=%d, Imaging=%d\n",
len(testData.DeviceTests), len(testData.MediaTests), len(testData.ProfileTests),
len(testData.PTZTests), len(testData.ImagingTests))
fmt.Println()
fmt.Println("Run tests with:")
fmt.Printf(" go test -v %s\n", outputFile)
return outputFile
}
func analyzeOperations(capture *onviftesting.CameraCaptureV2) []operationInfo {
var ops []operationInfo
seen := make(map[string]bool)
for _, ex := range capture.Exchanges {
// Create unique key for deduplication
key := ex.OperationName
if token := ex.GetProfileToken(); token != "" {
key += "_" + token
} else if token := ex.GetConfigurationToken(); token != "" {
key += "_" + token
} else if token := ex.GetVideoSourceToken(); token != "" {
key += "_" + token
}
if seen[key] {
continue
}
seen[key] = true
ops = append(ops, operationInfo{
OperationName: ex.OperationName,
ServiceType: ex.ServiceType,
Parameters: ex.Parameters,
Success: ex.Success,
})
}
return ops
}
func hasNonDeviceOperations(ops []operationInfo) bool {
for _, op := range ops {
switch op.ServiceType {
case onviftesting.ServiceMedia, onviftesting.ServicePTZ, onviftesting.ServiceImaging:
return true
}
}
return false
}
func generateDeviceTests(ops []operationInfo) []GeneratedTest {
var tests []GeneratedTest
// Standard device tests
deviceOps := map[string]string{
"GetDeviceInformation": `info, err := client.GetDeviceInformation(ctx)
if err != nil {
t.Errorf("GetDeviceInformation failed: %v", err)
return
}
if info.Manufacturer == "" {
t.Error("Manufacturer is empty")
}
if info.Model == "" {
t.Error("Model is empty")
}
t.Logf("Device: %s %s (Firmware: %s)", info.Manufacturer, info.Model, info.FirmwareVersion)`,
"GetSystemDateAndTime": `_, err := client.GetSystemDateAndTime(ctx)
if err != nil {
t.Errorf("GetSystemDateAndTime failed: %v", err)
}`,
"GetCapabilities": `caps, err := client.GetCapabilities(ctx)
if err != nil {
t.Errorf("GetCapabilities failed: %v", err)
return
}
t.Logf("Capabilities: Device=%v, Media=%v, Imaging=%v, PTZ=%v",
caps.Device != nil, caps.Media != nil, caps.Imaging != nil, caps.PTZ != nil)`,
"GetHostname": `hostname, err := client.GetHostname(ctx)
if err != nil {
t.Errorf("GetHostname failed: %v", err)
return
}
t.Logf("Hostname: %s", hostname)`,
"GetScopes": `scopes, err := client.GetScopes(ctx)
if err != nil {
t.Errorf("GetScopes failed: %v", err)
return
}
t.Logf("Scopes: %d", len(scopes))`,
"GetNetworkInterfaces": `interfaces, err := client.GetNetworkInterfaces(ctx)
if err != nil {
t.Errorf("GetNetworkInterfaces failed: %v", err)
return
}
t.Logf("Network interfaces: %d", len(interfaces))`,
"GetServices": `services, err := client.GetServices(ctx, true)
if err != nil {
t.Errorf("GetServices failed: %v", err)
return
}
t.Logf("Services: %d", len(services))`,
}
// Generate tests for captured operations
for _, op := range ops {
if op.ServiceType != onviftesting.ServiceDevice && op.ServiceType != onviftesting.ServiceUnknown {
continue
}
if code, ok := deviceOps[op.OperationName]; ok {
tests = append(tests, GeneratedTest{
Name: op.OperationName,
Code: code,
})
delete(deviceOps, op.OperationName) // Don't duplicate
}
}
// Sort by name for consistent output
sort.Slice(tests, func(i, j int) bool {
return tests[i].Name < tests[j].Name
})
return tests
}
func generateMediaTests(ops []operationInfo) []GeneratedTest {
var tests []GeneratedTest
mediaOps := map[string]string{
"GetProfiles": `profiles, err := client.GetProfiles(ctx)
if err != nil {
t.Errorf("GetProfiles failed: %v", err)
return
}
if len(profiles) == 0 {
t.Error("No profiles returned")
}
t.Logf("Found %d profile(s)", len(profiles))`,
"GetVideoSources": `sources, err := client.GetVideoSources(ctx)
if err != nil {
t.Errorf("GetVideoSources failed: %v", err)
return
}
t.Logf("Video sources: %d", len(sources))`,
"GetVideoSourceConfigurations": `configs, err := client.GetVideoSourceConfigurations(ctx)
if err != nil {
t.Errorf("GetVideoSourceConfigurations failed: %v", err)
return
}
t.Logf("Video source configs: %d", len(configs))`,
"GetVideoEncoderConfigurations": `configs, err := client.GetVideoEncoderConfigurations(ctx)
if err != nil {
t.Errorf("GetVideoEncoderConfigurations failed: %v", err)
return
}
t.Logf("Video encoder configs: %d", len(configs))`,
"GetAudioSources": `sources, err := client.GetAudioSources(ctx)
if err != nil {
t.Errorf("GetAudioSources failed: %v", err)
return
}
t.Logf("Audio sources: %d", len(sources))`,
"GetAudioSourceConfigurations": `configs, err := client.GetAudioSourceConfigurations(ctx)
if err != nil {
t.Errorf("GetAudioSourceConfigurations failed: %v", err)
return
}
t.Logf("Audio source configs: %d", len(configs))`,
"GetMetadataConfigurations": `configs, err := client.GetMetadataConfigurations(ctx)
if err != nil {
t.Errorf("GetMetadataConfigurations failed: %v", err)
return
}
t.Logf("Metadata configs: %d", len(configs))`,
}
for _, op := range ops {
if op.ServiceType != onviftesting.ServiceMedia {
continue
}
if code, ok := mediaOps[op.OperationName]; ok {
tests = append(tests, GeneratedTest{
Name: op.OperationName,
Code: code,
})
delete(mediaOps, op.OperationName)
}
}
sort.Slice(tests, func(i, j int) bool {
return tests[i].Name < tests[j].Name
})
return tests
}
func generateProfileDependentTests(ops []operationInfo) []GeneratedTest {
var tests []GeneratedTest
// Group operations by profile token
profileOps := make(map[string][]operationInfo)
for _, op := range ops {
if token, ok := op.Parameters["ProfileToken"].(string); ok && token != "" {
profileOps[token] = append(profileOps[token], op)
}
}
// Generate GetStreamURI tests for each profile
for token, opList := range profileOps {
for _, op := range opList {
switch op.OperationName {
case "GetStreamURI":
testName := fmt.Sprintf("GetStreamURI_%s", sanitizeToken(token))
tests = append(tests, GeneratedTest{
Name: testName,
Code: fmt.Sprintf(`uri, err := client.GetStreamURI(ctx, "%s")
if err != nil {
t.Errorf("GetStreamURI failed: %%v", err)
return
}
if uri.URI == "" {
t.Error("Stream URI is empty")
}
t.Logf("Stream URI: %%s", uri.URI)`, token),
})
case "GetSnapshotURI":
testName := fmt.Sprintf("GetSnapshotURI_%s", sanitizeToken(token))
tests = append(tests, GeneratedTest{
Name: testName,
Code: fmt.Sprintf(`uri, err := client.GetSnapshotURI(ctx, "%s")
if err != nil {
t.Errorf("GetSnapshotURI failed: %%v", err)
return
}
if uri.URI == "" {
t.Error("Snapshot URI is empty")
}
t.Logf("Snapshot URI: %%s", uri.URI)`, token),
})
case "GetProfile":
testName := fmt.Sprintf("GetProfile_%s", sanitizeToken(token))
tests = append(tests, GeneratedTest{
Name: testName,
Code: fmt.Sprintf(`profile, err := client.GetProfile(ctx, "%s")
if err != nil {
t.Errorf("GetProfile failed: %%v", err)
return
}
if profile.Token != "%s" {
t.Errorf("Expected token %%s, got %%s", "%s", profile.Token)
}
t.Logf("Profile: %%s", profile.Name)`, token, token, token),
})
}
}
}
// Deduplicate tests
seen := make(map[string]bool)
var uniqueTests []GeneratedTest
for _, t := range tests {
if !seen[t.Name] {
seen[t.Name] = true
uniqueTests = append(uniqueTests, t)
}
}
sort.Slice(uniqueTests, func(i, j int) bool {
return uniqueTests[i].Name < uniqueTests[j].Name
})
return uniqueTests
}
func generatePTZTests(ops []operationInfo) []GeneratedTest {
var tests []GeneratedTest
ptzOps := map[string]string{
"GetNodes": `nodes, err := client.GetNodes(ctx)
if err != nil {
t.Errorf("GetNodes failed: %v", err)
return
}
t.Logf("PTZ nodes: %d", len(nodes))`,
"GetConfigurations": `configs, err := client.GetConfigurations(ctx)
if err != nil {
t.Errorf("GetConfigurations failed: %v", err)
return
}
t.Logf("PTZ configs: %d", len(configs))`,
}
// Group by profile token for status and presets
profileOps := make(map[string][]operationInfo)
for _, op := range ops {
if op.ServiceType != onviftesting.ServicePTZ {
continue
}
if code, ok := ptzOps[op.OperationName]; ok {
tests = append(tests, GeneratedTest{
Name: op.OperationName,
Code: code,
})
delete(ptzOps, op.OperationName)
continue
}
if token, ok := op.Parameters["ProfileToken"].(string); ok && token != "" {
profileOps[token] = append(profileOps[token], op)
}
}
// Generate profile-specific PTZ tests
for token, opList := range profileOps {
for _, op := range opList {
switch op.OperationName {
case "GetStatus":
testName := fmt.Sprintf("PTZ_GetStatus_%s", sanitizeToken(token))
tests = append(tests, GeneratedTest{
Name: testName,
Code: fmt.Sprintf(`status, err := client.GetStatus(ctx, "%s")
if err != nil {
t.Errorf("GetStatus failed: %%v", err)
return
}
t.Logf("PTZ Status retrieved for profile %s")
_ = status`, token, token),
})
case "GetPresets":
testName := fmt.Sprintf("PTZ_GetPresets_%s", sanitizeToken(token))
tests = append(tests, GeneratedTest{
Name: testName,
Code: fmt.Sprintf(`presets, err := client.GetPresets(ctx, "%s")
if err != nil {
t.Errorf("GetPresets failed: %%v", err)
return
}
t.Logf("Found %%d preset(s) for profile %s", len(presets))`, token, token),
})
}
}
}
// Deduplicate
seen := make(map[string]bool)
var uniqueTests []GeneratedTest
for _, t := range tests {
if !seen[t.Name] {
seen[t.Name] = true
uniqueTests = append(uniqueTests, t)
}
}
sort.Slice(uniqueTests, func(i, j int) bool {
return uniqueTests[i].Name < uniqueTests[j].Name
})
return uniqueTests
}
func generateImagingTests(ops []operationInfo) []GeneratedTest {
var tests []GeneratedTest
// Group by video source token
sourceOps := make(map[string][]operationInfo)
for _, op := range ops {
if op.ServiceType != onviftesting.ServiceImaging {
continue
}
if token, ok := op.Parameters["VideoSourceToken"].(string); ok && token != "" {
sourceOps[token] = append(sourceOps[token], op)
}
}
for token, opList := range sourceOps {
for _, op := range opList {
switch op.OperationName {
case "GetImagingSettings":
testName := fmt.Sprintf("GetImagingSettings_%s", sanitizeToken(token))
tests = append(tests, GeneratedTest{
Name: testName,
Code: fmt.Sprintf(`settings, err := client.GetImagingSettings(ctx, "%s")
if err != nil {
t.Errorf("GetImagingSettings failed: %%v", err)
return
}
t.Logf("Imaging settings retrieved for source %s")
_ = settings`, token, token),
})
case "GetOptions":
testName := fmt.Sprintf("GetImagingOptions_%s", sanitizeToken(token))
tests = append(tests, GeneratedTest{
Name: testName,
Code: fmt.Sprintf(`options, err := client.GetOptions(ctx, "%s")
if err != nil {
t.Errorf("GetOptions failed: %%v", err)
return
}
t.Logf("Imaging options retrieved for source %s")
_ = options`, token, token),
})
}
}
}
// Deduplicate
seen := make(map[string]bool)
var uniqueTests []GeneratedTest
for _, t := range tests {
if !seen[t.Name] {
seen[t.Name] = true
uniqueTests = append(uniqueTests, t)
}
}
sort.Slice(uniqueTests, func(i, j int) bool {
return uniqueTests[i].Name < uniqueTests[j].Name
})
return uniqueTests
}
func sanitizeToken(token string) string {
// Make token safe for test name
token = strings.ReplaceAll(token, "-", "_")
token = strings.ReplaceAll(token, ".", "_")
token = strings.ReplaceAll(token, " ", "_")
// Truncate if too long
if len(token) > 20 {
token = token[:20]
}
return token
}
func makeRelativePath(archivePath, outputDir string) string {
if absOutput, err := filepath.Abs(outputDir); err == nil {
if absArchive, err := filepath.Abs(archivePath); err == nil {
if rel, err := filepath.Rel(filepath.Dir(absOutput), absArchive); err == nil {
return rel
}
}
}
return archivePath
}
func extractXMLValue(xmlStr, tagName string) string {
// Simple extraction for basic tags
start := fmt.Sprintf("<%s>", tagName)
end := fmt.Sprintf("</%s>", tagName)
startIdx := strings.Index(xmlStr, start)
if startIdx == -1 {
// Try with namespace prefix
start = fmt.Sprintf(":%s>", tagName)
startIdx = strings.Index(xmlStr, start)
if startIdx == -1 {
@@ -257,7 +734,6 @@ func extractXMLValue(xmlStr, tagName string) string {
endIdx := strings.Index(xmlStr[startIdx:], end)
if endIdx == -1 {
// Try with namespace prefix
end = fmt.Sprintf(":/%s>", tagName)
endIdx = strings.Index(xmlStr[startIdx:], end)
if endIdx == -1 {
@@ -267,3 +743,184 @@ func extractXMLValue(xmlStr, tagName string) string {
return strings.TrimSpace(xmlStr[startIdx : startIdx+endIdx])
}
// updateCameraRegistry updates the registry with camera information from the capture.
func updateCameraRegistry(regPath, archivePath, testFile string) {
registry, err := onviftesting.LoadRegistry(regPath)
if err != nil {
log.Printf("Warning: Failed to load registry: %v", err)
return
}
entry, err := onviftesting.CreateCameraEntryFromCapture(archivePath)
if err != nil {
log.Printf("Warning: Failed to create registry entry: %v", err)
return
}
// Set the test file path (relative to registry directory)
if testFile != "" {
regDir := filepath.Dir(regPath)
if absTest, err := filepath.Abs(testFile); err == nil {
if absRegDir, err := filepath.Abs(regDir); err == nil {
if rel, err := filepath.Rel(absRegDir, absTest); err == nil {
entry.TestFile = rel
}
}
}
if entry.TestFile == "" {
entry.TestFile = filepath.Base(testFile)
}
}
// Add or update the camera entry
registry.AddCamera(*entry)
// Update coverage statistics
updateRegistryCoverage(registry, archivePath)
// Save registry
if err := onviftesting.SaveRegistry(registry, regPath); err != nil {
log.Printf("Warning: Failed to save registry: %v", err)
return
}
fmt.Printf("✓ Registry updated: %s\n", regPath)
fmt.Printf(" Camera ID: %s\n", entry.ID)
fmt.Printf(" Total cameras in registry: %d\n", len(registry.Cameras))
}
// updateRegistryCoverage calculates coverage from captured operations.
func updateRegistryCoverage(registry *onviftesting.Registry, archivePath string) {
capture, _, err := onviftesting.LoadCaptureFromArchiveV2(archivePath)
if err != nil {
return
}
// Count unique operations per service
serviceCounts := make(map[string]map[string]bool)
for _, ex := range capture.Exchanges {
service := string(ex.ServiceType)
if service == "" || service == "Unknown" {
continue
}
if serviceCounts[service] == nil {
serviceCounts[service] = make(map[string]bool)
}
serviceCounts[service][ex.OperationName] = true
}
// Get totals from operations registry
opCounts := onviftesting.GetOperationCount()
// Update coverage
registry.Coverage = make(map[string]onviftesting.Coverage)
for service, ops := range serviceCounts {
total := 0
switch service {
case "Device":
total = opCounts.Device
case "Media":
total = opCounts.Media
case "PTZ":
total = opCounts.PTZ
case "Imaging":
total = opCounts.Imaging
case "Event":
total = opCounts.Event
case "DeviceIO":
total = opCounts.DeviceIO
}
registry.Coverage[service] = onviftesting.Coverage{
Total: total,
Captured: len(ops),
}
}
}
// generateCoverageReport generates a coverage report from the registry.
func generateCoverageReport(regPath string) {
registry, err := onviftesting.LoadRegistry(regPath)
if err != nil {
log.Fatalf("Failed to load registry: %v", err)
}
// Generate markdown report
report := generateCoverageMarkdown(registry)
// Output to file or stdout
if *coverageOutput != "" {
if err := os.WriteFile(*coverageOutput, []byte(report), 0600); err != nil { //nolint:mnd
log.Fatalf("Failed to write coverage report: %v", err)
}
fmt.Printf("✓ Coverage report written to: %s\n", *coverageOutput)
} else {
fmt.Println(report)
}
}
// generateCoverageMarkdown creates a markdown coverage report.
func generateCoverageMarkdown(registry *onviftesting.Registry) string {
var sb strings.Builder
sb.WriteString("# ONVIF Operation Coverage Report\n\n")
sb.WriteString(fmt.Sprintf("Generated: %s\n\n", time.Now().Format("2006-01-02 15:04:05")))
// Summary
sb.WriteString("## Summary\n\n")
sb.WriteString(fmt.Sprintf("- **Total Cameras**: %d\n", len(registry.Cameras)))
total, captured := registry.GetTotalCoverage()
if total > 0 {
sb.WriteString(fmt.Sprintf("- **Overall Coverage**: %.1f%% (%d/%d operations)\n\n",
float64(captured)/float64(total)*100, captured, total))
}
// Cameras
if len(registry.Cameras) > 0 {
sb.WriteString("## Registered Cameras\n\n")
sb.WriteString("| Manufacturer | Model | Firmware | Operations | Capabilities |\n")
sb.WriteString("|--------------|-------|----------|------------|---------------|\n")
for _, cam := range registry.Cameras {
caps := strings.Join(cam.Capabilities, ", ")
sb.WriteString(fmt.Sprintf("| %s | %s | %s | %d | %s |\n",
cam.Manufacturer, cam.Model, cam.Firmware, cam.OperationsCaptured, caps))
}
sb.WriteString("\n")
}
// Coverage by service
if len(registry.Coverage) > 0 {
sb.WriteString("## Coverage by Service\n\n")
sb.WriteString("| Service | Total | Captured | Coverage |\n")
sb.WriteString("|---------|-------|----------|----------|\n")
services := []string{"Device", "Media", "PTZ", "Imaging", "Event", "DeviceIO"}
for _, service := range services {
if cov, ok := registry.Coverage[service]; ok {
pct := 0.0
if cov.Total > 0 {
pct = float64(cov.Captured) / float64(cov.Total) * 100
}
sb.WriteString(fmt.Sprintf("| %s | %d | %d | %.1f%% |\n",
service, cov.Total, cov.Captured, pct))
}
}
sb.WriteString("\n")
}
// Missing operations
sb.WriteString("## Operation Specifications\n\n")
opCounts := onviftesting.GetOperationCount()
sb.WriteString(fmt.Sprintf("- Device: %d operations defined\n", opCounts.Device))
sb.WriteString(fmt.Sprintf("- Media: %d operations defined\n", opCounts.Media))
sb.WriteString(fmt.Sprintf("- PTZ: %d operations defined\n", opCounts.PTZ))
sb.WriteString(fmt.Sprintf("- Imaging: %d operations defined\n", opCounts.Imaging))
sb.WriteString(fmt.Sprintf("- Event: %d operations defined\n", opCounts.Event))
sb.WriteString(fmt.Sprintf("- DeviceIO: %d operations defined\n", opCounts.DeviceIO))
sb.WriteString(fmt.Sprintf("\n**Total**: %d read-only operations tracked\n", opCounts.Total))
return sb.String()
}