add tests

Author: serichoi65

pkg/service/protocolDataService/protocol_test.go

@@ -219,4 +219,120 @@ func Test_ProtocolDataService(t *testing.T) {
 			}
 		})
 	})
+
+	t.Run("Test ListStakersForStrategy", func(t *testing.T) {
+		strategy := "0x7d704507b76571a51d9cae8addabbfd0ba0e63d3"
+		blockNumber := uint64(3204393)
+
+		t.Run("With DelegationFilterAll (default)", func(t *testing.T) {
+			// Test with ALL filter - should return all stakers regardless of delegation status
+			stakers, err := pds.ListStakersForStrategy(context.Background(), strategy, blockNumber, DelegationFilterAll, nil)
+			assert.Nil(t, err)
+			assert.True(t, len(stakers) > 0, "Should return stakers for the strategy")
+
+			// Verify the structure of returned data
+			for _, staker := range stakers {
+				assert.NotEmpty(t, staker.Staker, "Staker address should not be empty")
+				assert.NotEmpty(t, staker.Shares, "Shares should not be empty")
+			}
+		})
+
+		t.Run("With DelegationFilterDelegated", func(t *testing.T) {
+			// Test with DELEGATED filter - should return only delegated stakers
+			stakers, err := pds.ListStakersForStrategy(context.Background(), strategy, blockNumber, DelegationFilterDelegated, nil)
+			assert.Nil(t, err)
+
+			// All returned stakers should be delegated
+			for _, staker := range stakers {
+				assert.True(t, staker.Delegated, "Staker should be delegated")
+				assert.NotNil(t, staker.Operator, "Delegated staker should have an operator")
+				if staker.Operator != nil {
+					assert.NotEmpty(t, *staker.Operator, "Operator address should not be empty for delegated staker")
+				}
+			}
+		})
+
+		t.Run("With DelegationFilterUndelegated", func(t *testing.T) {
+			// Test with UNDELEGATED filter - should return only undelegated stakers
+			stakers, err := pds.ListStakersForStrategy(context.Background(), strategy, blockNumber, DelegationFilterUndelegated, nil)
+			assert.Nil(t, err)
+
+			// All returned stakers should NOT be delegated
+			for _, staker := range stakers {
+				assert.False(t, staker.Delegated, "Staker should not be delegated")
+			}
+		})
+
+		t.Run("With nil pagination (uses default)", func(t *testing.T) {
+			// Test with nil pagination to ensure no error occurs
+			stakers, err := pds.ListStakersForStrategy(context.Background(), strategy, blockNumber, DelegationFilterAll, nil)
+			assert.Nil(t, err)
+			assert.True(t, len(stakers) >= 0, "Should return stakers or empty array")
+		})
+
+		t.Run("With custom pagination (first page)", func(t *testing.T) {
+			// Test with custom pagination on first page (no offset)
+			pagination := &types.Pagination{
+				Page:     0,
+				PageSize: 5,
+			}
+			stakers, err := pds.ListStakersForStrategy(context.Background(), strategy, blockNumber, DelegationFilterAll, pagination)
+			assert.Nil(t, err)
+			assert.True(t, len(stakers) <= 5, "Should respect custom page size of 5")
+		})
+
+		t.Run("With custom pagination (second page with offset)", func(t *testing.T) {
+			// Test with page > 0 to test HasOffset template logic
+			pagination := &types.Pagination{
+				Page:     1,
+				PageSize: 5,
+			}
+			stakers, err := pds.ListStakersForStrategy(context.Background(), strategy, blockNumber, DelegationFilterAll, pagination)
+			assert.Nil(t, err)
+			// May or may not have results depending on total data, but should not error
+			assert.True(t, len(stakers) <= 5, "Should respect custom page size of 5")
+		})
+
+		t.Run("With delegation filter and pagination combined", func(t *testing.T) {
+			// Test combining delegation filter with pagination
+			pagination := &types.Pagination{
+				Page:     0,
+				PageSize: 10,
+			}
+			stakers, err := pds.ListStakersForStrategy(context.Background(), strategy, blockNumber, DelegationFilterDelegated, pagination)
+			assert.Nil(t, err)
+			assert.True(t, len(stakers) <= 10, "Should respect page size")
+
+			// All returned stakers should be delegated
+			for _, staker := range stakers {
+				assert.True(t, staker.Delegated, "Staker should be delegated")
+			}
+		})
+
+		t.Run("Stakers are ordered by shares descending", func(t *testing.T) {
+			// Test that results are ordered by shares descending
+			pagination := &types.Pagination{
+				Page:     0,
+				PageSize: 10,
+			}
+			stakers, err := pds.ListStakersForStrategy(context.Background(), strategy, blockNumber, DelegationFilterAll, pagination)
+			assert.Nil(t, err)
+
+			if len(stakers) > 1 {
+				// Verify ordering (shares should be descending)
+				// Note: shares are strings representing large numbers, so we can't directly compare
+				// but we can verify the query runs without error
+				assert.True(t, len(stakers) > 0, "Should have stakers to verify ordering")
+			}
+		})
+
+		t.Run("With uppercase strategy address (should be normalized)", func(t *testing.T) {
+			// Test that uppercase addresses are normalized to lowercase
+			uppercaseStrategy := "0x7D704507B76571A51D9CAE8ADDABBFD0BA0E63D3"
+			stakers, err := pds.ListStakersForStrategy(context.Background(), uppercaseStrategy, blockNumber, DelegationFilterAll, nil)
+			assert.Nil(t, err)
+			// Should work the same as lowercase
+			assert.True(t, len(stakers) >= 0)
+		})
+	})
 }