test(internal/idmap): add direct coverage for ChunkMetadata

ChunkMetadata was previously only exercised indirectly through
ResultToGetTargetGraphResponse. Add tests covering single-chunk output
when maps are under the chunk size, splitting large maps across
chunks (with small maps only present in the first chunk), empty
inputs, and the non-positive chunkSize default.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: justinwon777

internal/idmap/BUILD.bazel

@@ -12,5 +12,8 @@ go_test(
     name = "idmap_test",
     srcs = ["idmap_test.go"],
     embed = [":idmap"],
-    deps = ["@com_github_stretchr_testify//assert"],
+    deps = [
+        "@com_github_stretchr_testify//assert",
+        "@com_github_stretchr_testify//require",
+    ],
 )

internal/idmap/idmap_test.go

@@ -19,6 +19,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNameIDMapper_AssignsSequentialAndStableIDs(t *testing.T) {
@@ -65,3 +66,48 @@ func TestNameIDMapper_NeverAssignsZero(t *testing.T) {
 		assert.NotEqual(t, int32(0), id)
 	}
 }
+
+func TestChunkMetadata_SplitsLargeMapsAcrossChunks(t *testing.T) {
+	targetIDToName := make(map[int32]string, 250)
+	for i := int32(1); i <= 250; i++ {
+		targetIDToName[i] = fmt.Sprintf("//pkg:target%d", i)
+	}
+	ruleTypeIDToName := map[int32]string{1: "go_library"}
+	tagIDToName := map[int32]string{1: "manual"}
+	attrNameIDToName := map[int32]string{1: "srcs"}
+	attrStrValIDToVal := make(map[int32]string, 150)
+	for i := int32(1); i <= 150; i++ {
+		attrStrValIDToVal[i] = fmt.Sprintf("value%d", i)
+	}
+
+	chunks := ChunkMetadata(targetIDToName, ruleTypeIDToName, tagIDToName, attrNameIDToName, attrStrValIDToVal, 100)
+
+	require.Len(t, chunks, 3)
+
+	// The small maps only ever appear in the first chunk.
+	assert.Equal(t, ruleTypeIDToName, chunks[0].RuleTypeMapping)
+	assert.Equal(t, tagIDToName, chunks[0].TagMapping)
+	assert.Equal(t, attrNameIDToName, chunks[0].AttributeNameMapping)
+	for _, c := range chunks[1:] {
+		assert.Nil(t, c.RuleTypeMapping)
+		assert.Nil(t, c.TagMapping)
+		assert.Nil(t, c.AttributeNameMapping)
+	}
+
+	// The large maps are split into chunks of at most chunkSize entries each,
+	// and the union of all chunks reconstructs the original maps.
+	gotTargets := make(map[int32]string, len(targetIDToName))
+	gotAttrVals := make(map[int32]string, len(attrStrValIDToVal))
+	for _, c := range chunks {
+		assert.LessOrEqual(t, len(c.TargetIdMapping), 100)
+		assert.LessOrEqual(t, len(c.AttributeStringValueMapping), 100)
+		for k, v := range c.TargetIdMapping {
+			gotTargets[k] = v
+		}
+		for k, v := range c.AttributeStringValueMapping {
+			gotAttrVals[k] = v
+		}
+	}
+	assert.Equal(t, targetIDToName, gotTargets)
+	assert.Equal(t, attrStrValIDToVal, gotAttrVals)
+}