test: improve coverage for storage and handlers (Phase 6) (#80)

* test: add error path tests for json and flatbuffers engines (Phase 6)

json_test.go (+93 lines):
- TestJSONEngineInvalidGzip: invalid gzip data error path
- TestJSONEngineInvalidJSONInGzip: invalid JSON in gzip file
- TestJSONEngineInvalidJSON: invalid plain JSON file
- TestJSONEngineEntityWithNoType: non-map entity handling
- TestJSONEngineEntitiesNotArray: invalid entities format

flatbuffers_test.go (+186 lines):
- TestFlatBuffersEngineChunkCountError: manifest read error path
- TestFlatBuffersEngineConvertInvalidJSON: invalid JSON error path
- TestFlatBuffersEngineConvertContextCancelled: context cancellation
- TestFlatBuffersEngineConvertWithEvents: events conversion coverage
- TestFlatBuffersEngineConvertWithCrewInVehicle: crew data coverage

Coverage: storage 92.9% → 95.0%

* test: add error path tests for handlers (Phase 6)

handler_test.go (+190 lines):
- TestGetOperationManifest_JSONError: manifest load error for JSON
- TestGetOperationManifest_ProtobufReadError: reader error for protobuf
- TestGetOperationChunk_JSONNotSupported: chunk request on JSON format
- TestGetCapture_MissingFile: missing capture file error
- TestGetCaptureFile_MissingFile: missing capture file download error

Coverage: server 89.9% → 90.3%
- GetOperationManifest: 79.2% → 87.5%

Author: fank

internal/server/handler_test.go

@@ -1734,3 +1734,193 @@ func TestStoreOperation_WrongSecret(t *testing.T) {
 	err = hdlr.StoreOperation(c)
 	assert.Equal(t, echo.ErrForbidden, err)
 }
+
+func TestGetOperationManifest_JSONError(t *testing.T) {
+	dir := t.TempDir()
+	pathDB := filepath.Join(dir, "test.db")
+	dataDir := filepath.Join(dir, "data")
+	err := os.MkdirAll(dataDir, 0755)
+	require.NoError(t, err)
+
+	repo, err := NewRepoOperation(pathDB)
+	require.NoError(t, err)
+	defer repo.db.Close()
+
+	ctx := context.Background()
+
+	// Store operation with json format
+	op := &Operation{
+		WorldName:        "altis",
+		MissionName:      "JSON Error Test",
+		MissionDuration:  3600,
+		Filename:         "missing_json_file",
+		Date:             "2026-01-30",
+		Tag:              "coop",
+		StorageFormat:    "json",
+		ConversionStatus: "completed",
+	}
+	err = repo.Store(ctx, op)
+	require.NoError(t, err)
+
+	// Register JSON engine (but don't create the file)
+	storage.RegisterEngine(storage.NewJSONEngine(dataDir))
+
+	hdlr := Handler{
+		repoOperation: repo,
+		setting:       Setting{Data: dataDir},
+	}
+
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/operations/1/manifest", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+	c.SetParamNames("id")
+	c.SetParamValues("1")
+
+	err = hdlr.GetOperationManifest(c)
+	assert.Error(t, err)
+	httpErr, ok := err.(*echo.HTTPError)
+	assert.True(t, ok)
+	assert.Equal(t, http.StatusInternalServerError, httpErr.Code)
+}
+
+func TestGetOperationManifest_ProtobufReadError(t *testing.T) {
+	dir := t.TempDir()
+	pathDB := filepath.Join(dir, "test.db")
+	dataDir := filepath.Join(dir, "data")
+	err := os.MkdirAll(dataDir, 0755)
+	require.NoError(t, err)
+
+	repo, err := NewRepoOperation(pathDB)
+	require.NoError(t, err)
+	defer repo.db.Close()
+
+	ctx := context.Background()
+
+	// Store operation with protobuf format
+	op := &Operation{
+		WorldName:        "altis",
+		MissionName:      "Protobuf Error Test",
+		MissionDuration:  3600,
+		Filename:         "missing_protobuf",
+		Date:             "2026-01-30",
+		Tag:              "coop",
+		StorageFormat:    "protobuf",
+		ConversionStatus: "completed",
+	}
+	err = repo.Store(ctx, op)
+	require.NoError(t, err)
+
+	// Register protobuf engine (but don't create the manifest file)
+	storage.RegisterEngine(storage.NewProtobufEngine(dataDir))
+
+	hdlr := Handler{
+		repoOperation: repo,
+		setting:       Setting{Data: dataDir},
+	}
+
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/operations/1/manifest", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+	c.SetParamNames("id")
+	c.SetParamValues("1")
+
+	err = hdlr.GetOperationManifest(c)
+	assert.Error(t, err)
+	httpErr, ok := err.(*echo.HTTPError)
+	assert.True(t, ok)
+	assert.Equal(t, http.StatusInternalServerError, httpErr.Code)
+}
+
+func TestGetOperationChunk_JSONNotSupported(t *testing.T) {
+	dir := t.TempDir()
+	pathDB := filepath.Join(dir, "test.db")
+	dataDir := filepath.Join(dir, "data")
+	err := os.MkdirAll(dataDir, 0755)
+	require.NoError(t, err)
+
+	repo, err := NewRepoOperation(pathDB)
+	require.NoError(t, err)
+	defer repo.db.Close()
+
+	ctx := context.Background()
+
+	// Store operation with json format
+	op := &Operation{
+		WorldName:        "altis",
+		MissionName:      "JSON Chunk Test",
+		MissionDuration:  3600,
+		Filename:         "json_chunk_test",
+		Date:             "2026-01-30",
+		Tag:              "coop",
+		StorageFormat:    "json",
+		ConversionStatus: "completed",
+	}
+	err = repo.Store(ctx, op)
+	require.NoError(t, err)
+
+	// Register JSON engine
+	storage.RegisterEngine(storage.NewJSONEngine(dataDir))
+
+	hdlr := Handler{
+		repoOperation: repo,
+		setting:       Setting{Data: dataDir},
+	}
+
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/operations/1/chunks/0", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+	c.SetParamNames("id", "index")
+	c.SetParamValues("1", "0")
+
+	err = hdlr.GetOperationChunk(c)
+	assert.Error(t, err)
+	httpErr, ok := err.(*echo.HTTPError)
+	assert.True(t, ok)
+	// JSON engine returns error for chunked loading, handler returns 404
+	assert.Equal(t, http.StatusNotFound, httpErr.Code)
+}
+
+func TestGetCapture_MissingFile(t *testing.T) {
+	dir := t.TempDir()
+	dataDir := filepath.Join(dir, "data")
+	err := os.MkdirAll(dataDir, 0755)
+	require.NoError(t, err)
+
+	hdlr := Handler{
+		setting: Setting{Data: dataDir},
+	}
+
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/data/nonexistent", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+	c.SetParamNames("name")
+	c.SetParamValues("nonexistent")
+
+	err = hdlr.GetCapture(c)
+	assert.Error(t, err)
+}
+
+func TestGetCaptureFile_MissingFile(t *testing.T) {
+	dir := t.TempDir()
+	dataDir := filepath.Join(dir, "data")
+	err := os.MkdirAll(dataDir, 0755)
+	require.NoError(t, err)
+
+	hdlr := Handler{
+		setting: Setting{Data: dataDir},
+	}
+
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/file/nonexistent", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+	c.SetParamNames("name")
+	c.SetParamValues("nonexistent")
+
+	err = hdlr.GetCaptureFile(c)
+	assert.Error(t, err)
+}

internal/storage/flatbuffers_test.go

@@ -660,3 +660,189 @@ func TestPbManifestToStorageManifestEmpty(t *testing.T) {
 	assert.Empty(t, manifest.Entities)
 	assert.Empty(t, manifest.Events)
 }
+
+func TestFlatBuffersEngineChunkCountError(t *testing.T) {
+	dir := t.TempDir()
+	engine := NewFlatBuffersEngine(dir)
+
+	// ChunkCount should fail when GetManifest fails (no manifest file)
+	_, err := engine.ChunkCount(context.Background(), "nonexistent")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "read manifest")
+}
+
+func TestFlatBuffersEngineConvertInvalidJSON(t *testing.T) {
+	dir := t.TempDir()
+	inputPath := filepath.Join(dir, "invalid.json")
+	outputPath := filepath.Join(dir, "output")
+
+	// Create invalid JSON
+	err := os.WriteFile(inputPath, []byte("{ invalid json }"), 0644)
+	require.NoError(t, err)
+
+	engine := NewFlatBuffersEngine(dir)
+	err = engine.Convert(context.Background(), inputPath, outputPath)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "load JSON")
+}
+
+func TestFlatBuffersEngineConvertContextCancelled(t *testing.T) {
+	dir := t.TempDir()
+	inputPath := filepath.Join(dir, "test.json")
+	outputPath := filepath.Join(dir, "output")
+
+	// Create valid JSON with many frames to allow context cancellation
+	testJSON := `{
+		"worldName": "altis",
+		"missionName": "Context Cancel Test",
+		"endFrame": 1000,
+		"captureDelay": 1,
+		"entities": [
+			{
+				"id": 0,
+				"type": "unit",
+				"name": "Player1",
+				"startFrameNum": 0,
+				"positions": []
+			}
+		]
+	}`
+
+	err := os.WriteFile(inputPath, []byte(testJSON), 0644)
+	require.NoError(t, err)
+
+	engine := NewFlatBuffersEngine(dir)
+
+	// Create already cancelled context
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	err = engine.Convert(ctx, inputPath, outputPath)
+	require.Error(t, err)
+	assert.ErrorIs(t, err, context.Canceled)
+}
+
+func TestFlatBuffersEngineConvertWithEvents(t *testing.T) {
+	dir := t.TempDir()
+	inputPath := filepath.Join(dir, "events.json")
+	outputPath := filepath.Join(dir, "output")
+
+	// Create JSON with events
+	testJSON := `{
+		"worldName": "altis",
+		"missionName": "Events Test",
+		"endFrame": 5,
+		"captureDelay": 1,
+		"entities": [
+			{
+				"id": 0,
+				"type": "unit",
+				"name": "Shooter",
+				"side": "WEST",
+				"startFrameNum": 0,
+				"positions": [
+					[[100, 200], 45, 1, 0, "Shooter", 1],
+					[[100, 200], 45, 1, 0, "Shooter", 1],
+					[[100, 200], 45, 1, 0, "Shooter", 1],
+					[[100, 200], 45, 1, 0, "Shooter", 1],
+					[[100, 200], 45, 1, 0, "Shooter", 1]
+				]
+			},
+			{
+				"id": 1,
+				"type": "unit",
+				"name": "Target",
+				"side": "EAST",
+				"startFrameNum": 0,
+				"positions": [
+					[[150, 250], 180, 1, 0, "Target", 0],
+					[[150, 250], 180, 1, 0, "Target", 0],
+					[[150, 250], 180, 0, 0, "Target", 0],
+					[[150, 250], 180, 0, 0, "Target", 0],
+					[[150, 250], 180, 0, 0, "Target", 0]
+				]
+			}
+		],
+		"events": [
+			[1, "hit", 0, 1, "arifle_MX", 50],
+			[2, "killed", 0, 1, "arifle_MX"]
+		]
+	}`
+
+	err := os.WriteFile(inputPath, []byte(testJSON), 0644)
+	require.NoError(t, err)
+
+	engine := NewFlatBuffersEngine(dir)
+	err = engine.Convert(context.Background(), inputPath, outputPath)
+	require.NoError(t, err)
+
+	// Verify manifest has events
+	newEngine := NewFlatBuffersEngine(filepath.Dir(outputPath))
+	manifest, err := newEngine.GetManifest(context.Background(), "output")
+	require.NoError(t, err)
+
+	assert.Len(t, manifest.Events, 2)
+	assert.Equal(t, "hit", manifest.Events[0].Type)
+	assert.Equal(t, "killed", manifest.Events[1].Type)
+}
+
+func TestFlatBuffersEngineConvertWithCrewInVehicle(t *testing.T) {
+	dir := t.TempDir()
+	inputPath := filepath.Join(dir, "crew.json")
+	outputPath := filepath.Join(dir, "output")
+
+	// Create JSON with vehicle crew
+	testJSON := `{
+		"worldName": "altis",
+		"missionName": "Crew Test",
+		"endFrame": 3,
+		"captureDelay": 1,
+		"entities": [
+			{
+				"id": 0,
+				"type": "unit",
+				"name": "Driver",
+				"side": "WEST",
+				"startFrameNum": 0,
+				"positions": [
+					[[100, 200], 45, 1, 1, "Driver", 1],
+					[[100, 200], 45, 1, 1, "Driver", 1],
+					[[100, 200], 45, 1, 1, "Driver", 1]
+				]
+			},
+			{
+				"id": 1,
+				"type": "vehicle",
+				"name": "Truck",
+				"class": "B_Truck_01",
+				"startFrameNum": 0,
+				"positions": [
+					[[100, 200], 90, 1, [0]],
+					[[101, 201], 91, 1, [0]],
+					[[102, 202], 92, 1, [0]]
+				]
+			}
+		]
+	}`
+
+	err := os.WriteFile(inputPath, []byte(testJSON), 0644)
+	require.NoError(t, err)
+
+	engine := NewFlatBuffersEngine(dir)
+	err = engine.Convert(context.Background(), inputPath, outputPath)
+	require.NoError(t, err)
+
+	// Verify chunk has crew data
+	newEngine := NewFlatBuffersEngine(filepath.Dir(outputPath))
+	chunk, err := newEngine.GetChunk(context.Background(), "output", 0)
+	require.NoError(t, err)
+
+	// Find vehicle entity in chunk
+	for _, frame := range chunk.Frames {
+		for _, entity := range frame.Entities {
+			if entity.EntityID == 1 { // Vehicle
+				assert.NotEmpty(t, entity.CrewIDs, "Vehicle should have crew")
+			}
+		}
+	}
+}