Allow Bidder to Override Callback Type in /setuid

config/bidderinfo.go

@@ -124,6 +124,9 @@ type Syncer struct {
 
 	// SupportCORS identifies if CORS is supported for the user syncing endpoints.
 	SupportCORS *bool `yaml:"supportCors" mapstructure:"support_cors"`
+
+	// ForceSyncType allows a bidder to override their callback type "b" for iframe, "i" for redirect
+	ForceSyncType string `yaml:"forceSyncType" mapstructure:"force_sync_type"`
 }
 
 // SyncerEndpoint specifies the configuration of the URL returned by the /cookie_sync endpoint

endpoints/cookie_sync_test.go

@@ -1996,6 +1996,10 @@ func (m *MockSyncer) GetSync(syncTypes []usersync.SyncType, privacyMacros macros
 	return args.Get(0).(usersync.Sync), args.Error(1)
 }
 
+func (m *MockSyncer) ForceResponseFormat() string {
+	return ""
+}
+
 type MockAnalyticsRunner struct {
 	mock.Mock
 }

endpoints/setuid.go

@@ -359,6 +359,10 @@ func isSyncerPriority(bidderNameFromSyncerQuery string, priorityGroups [][]strin
 // Returns either "b" (iframe), "i" (redirect), or an empty string "" (legacy behavior of an
 // empty response body with no content type).
 func getResponseFormat(query url.Values, syncer usersync.Syncer) (string, error) {
+	if syncer.ForceResponseFormat() != "" {
+		return syncer.ForceResponseFormat(), nil
+	}
+
 	format, formatProvided := query["f"]
 	formatEmpty := len(format) == 0 || format[0] == ""
 

endpoints/setuid_test.go

@@ -34,6 +34,7 @@ func TestSetUIDEndpoint(t *testing.T) {
 		gdprAllowsHostCookies  bool
 		gdprReturnsError       bool
 		gdprMalformed          bool
+		forceSyncType          string
 		expectedSyncs          map[string]string
 		expectedBody           string
 		expectedStatusCode     int
@@ -336,14 +337,25 @@ func TestSetUIDEndpoint(t *testing.T) {
 			expectedStatusCode:     http.StatusBadRequest,
 			expectedBody:           "invalid gpp_sid encoding, must be a csv list of integers",
 		},
+		{
+			uri:                    "/setuid?bidder=pubmatic&uid=123&f=b",
+			syncersBidderNameToKey: map[string]string{"pubmatic": "pubmatic"},
+			existingSyncs:          nil,
+			gdprAllowsHostCookies:  true,
+			forceSyncType:          "i",
+			expectedSyncs:          map[string]string{"pubmatic": "123"},
+			expectedStatusCode:     http.StatusOK,
+			expectedHeaders:        map[string]string{"Content-Length": "86", "Content-Type": "image/png"},
+			description:            "Set uid for valid bidder with iframe format, but it's overriden by forceType",
+		},
 	}
 
 	analytics := analyticsBuild.New(&config.Analytics{})
 	metrics := &metricsConf.NilMetricsEngine{}
 
 	for _, test := range testCases {
 		response := doRequest(makeRequest(test.uri, test.existingSyncs), analytics, metrics,
-			test.syncersBidderNameToKey, test.gdprAllowsHostCookies, test.gdprReturnsError, test.gdprMalformed, false, 0, nil)
+			test.syncersBidderNameToKey, test.gdprAllowsHostCookies, test.gdprReturnsError, test.gdprMalformed, false, 0, nil, test.forceSyncType)
 		assert.Equal(t, test.expectedStatusCode, response.Code, "Test Case: %s. /setuid returned unexpected error code", test.description)
 
 		if test.expectedSyncs != nil {
@@ -467,7 +479,7 @@ func TestSetUIDPriorityEjection(t *testing.T) {
 		request.AddCookie(httpCookie)
 
 		// Make Request to /setuid
-		response := doRequest(request, analytics, &metricsConf.NilMetricsEngine{}, syncersByBidder, true, false, false, false, test.givenMaxCookieSize, test.givenPriorityGroups)
+		response := doRequest(request, analytics, &metricsConf.NilMetricsEngine{}, syncersByBidder, true, false, false, false, test.givenMaxCookieSize, test.givenPriorityGroups, "")
 
 		if test.expectedWarning != "" {
 			assert.Equal(t, test.expectedWarning, response.Body.String(), test.description)
@@ -1333,7 +1345,7 @@ func TestSetUIDEndpointMetrics(t *testing.T) {
 		for _, v := range test.cookies {
 			addCookie(req, v)
 		}
-		response := doRequest(req, analyticsEngine, metricsEngine, test.syncersBidderNameToKey, test.gdprAllowsHostCookies, false, false, test.cfgAccountRequired, 0, nil)
+		response := doRequest(req, analyticsEngine, metricsEngine, test.syncersBidderNameToKey, test.gdprAllowsHostCookies, false, false, test.cfgAccountRequired, 0, nil, "")
 
 		assert.Equal(t, test.expectedResponseCode, response.Code, test.description)
 		analyticsEngine.AssertExpectations(t)
@@ -1349,7 +1361,7 @@ func TestOptedOut(t *testing.T) {
 	syncersBidderNameToKey := map[string]string{"pubmatic": "pubmatic"}
 	analytics := analyticsBuild.New(&config.Analytics{})
 	metrics := &metricsConf.NilMetricsEngine{}
-	response := doRequest(request, analytics, metrics, syncersBidderNameToKey, true, false, false, false, 0, nil)
+	response := doRequest(request, analytics, metrics, syncersBidderNameToKey, true, false, false, false, 0, nil, "")
 
 	assert.Equal(t, http.StatusUnauthorized, response.Code)
 }
@@ -1445,6 +1457,24 @@ func TestGetResponseFormat(t *testing.T) {
 			expectedFormat: "i",
 			description:    "parameter given is empty (by empty item), use default sync type redirect",
 		},
+		{
+			urlValues:      url.Values{"f": []string{""}},
+			syncer:         fakeSyncer{key: "a", defaultSyncType: usersync.SyncTypeRedirect},
+			expectedFormat: "i",
+			description:    "parameter given is empty (by empty item), use default sync type redirect",
+		},
+		{
+			urlValues:      url.Values{"f": []string{"b"}},
+			syncer:         fakeSyncer{key: "a", forceSyncType: "i"},
+			expectedFormat: "i",
+			description:    "parameter given as `b`, but force sync type is opposite",
+		},
+		{
+			urlValues:      url.Values{"f": []string{"i"}},
+			syncer:         fakeSyncer{key: "a", forceSyncType: "b"},
+			expectedFormat: "b",
+			description:    "parameter given as `i`, but force sync type is opposite",
+		},
 	}
 
 	for _, test := range testCases {
@@ -1544,7 +1574,7 @@ func makeRequest(uri string, existingSyncs map[string]string) *http.Request {
 	return request
 }
 
-func doRequest(req *http.Request, analytics analytics.Runner, metrics metrics.MetricsEngine, syncersBidderNameToKey map[string]string, gdprAllowsHostCookies, gdprReturnsError, gdprReturnsMalformedError, cfgAccountRequired bool, maxCookieSize int, priorityGroups [][]string) *httptest.ResponseRecorder {
+func doRequest(req *http.Request, analytics analytics.Runner, metrics metrics.MetricsEngine, syncersBidderNameToKey map[string]string, gdprAllowsHostCookies, gdprReturnsError, gdprReturnsMalformedError, cfgAccountRequired bool, maxCookieSize int, priorityGroups [][]string, forceSyncType string) *httptest.ResponseRecorder {
 	cfg := config.Configuration{
 		AccountRequired: cfgAccountRequired,
 		AccountDefaults: config.Account{},
@@ -1575,7 +1605,7 @@ func doRequest(req *http.Request, analytics analytics.Runner, metrics metrics.Me
 
 	syncersByBidder := make(map[string]usersync.Syncer)
 	for bidderName, syncerKey := range syncersBidderNameToKey {
-		syncersByBidder[bidderName] = fakeSyncer{key: syncerKey, defaultSyncType: usersync.SyncTypeIFrame}
+		syncersByBidder[bidderName] = fakeSyncer{key: syncerKey, defaultSyncType: usersync.SyncTypeIFrame, forceSyncType: forceSyncType}
 		if priorityGroups == nil {
 			cfg.UserSync.PriorityGroups = [][]string{{}}
 			cfg.UserSync.PriorityGroups[0] = append(cfg.UserSync.PriorityGroups[0], bidderName)
@@ -1666,6 +1696,7 @@ func (g *fakePermsSetUID) AuctionActivitiesAllowed(ctx context.Context, bidderCo
 type fakeSyncer struct {
 	key             string
 	defaultSyncType usersync.SyncType
+	forceSyncType   string
 }
 
 func (s fakeSyncer) Key() string {
@@ -1684,6 +1715,10 @@ func (s fakeSyncer) GetSync(syncTypes []usersync.SyncType, privacyMacros macros.
 	return usersync.Sync{}, nil
 }
 
+func (s fakeSyncer) ForceResponseFormat() string {
+	return s.forceSyncType
+}
+
 func ToHTTPCookie(cookie *usersync.Cookie) (*http.Cookie, error) {
 	encoder := usersync.Base64Encoder{}
 	encodedCookie, err := encoder.Encode(cookie)

usersync/chooser_test.go

@@ -505,6 +505,7 @@ type fakeSyncer struct {
 	key              string
 	supportsIFrame   bool
 	supportsRedirect bool
+	forceSyncType    string
 }
 
 func (s fakeSyncer) Key() string {
@@ -531,6 +532,10 @@ func (fakeSyncer) GetSync([]SyncType, macros.UserSyncPrivacy) (Sync, error) {
 	return Sync{}, nil
 }
 
+func (s fakeSyncer) ForceResponseFormat() string {
+	return s.forceSyncType
+}
+
 type fakePrivacy struct {
 	gdprAllowsHostCookie  bool
 	gdprAllowsBidderSync  bool

usersync/syncer.go

@@ -35,6 +35,9 @@ type Syncer interface {
 	// GetSync returns a user sync for the user's device to perform, or an error if the none of the
 	// sync types are supported or if macro substitution fails.
 	GetSync(syncTypes []SyncType, userSyncMacros macros.UserSyncPrivacy) (Sync, error)
+
+	// ForceResponseFromat returns the callback format as specified in a bidders config
+	ForceResponseFormat() string
 }
 
 // Sync represents a user sync to be performed by the user's device.
@@ -50,6 +53,7 @@ type standardSyncer struct {
 	iframe          *template.Template
 	redirect        *template.Template
 	supportCORS     bool
+	forceSyncType   string
 }
 
 const (
@@ -72,6 +76,7 @@ func NewSyncer(hostConfig config.UserSync, syncerConfig config.Syncer, bidder st
 		key:             syncerConfig.Key,
 		defaultSyncType: resolveDefaultSyncType(syncerConfig),
 		supportCORS:     syncerConfig.SupportCORS != nil && *syncerConfig.SupportCORS,
+		forceSyncType:   syncerConfig.ForceSyncType,
 	}
 
 	if syncerConfig.IFrame != nil {
@@ -266,3 +271,14 @@ func (s standardSyncer) chooseTemplate(syncType SyncType) *template.Template {
 		return nil
 	}
 }
+
+func (s standardSyncer) ForceResponseFormat() string {
+	switch s.forceSyncType {
+	case setuidSyncTypeIFrame:
+		return s.forceSyncType
+	case setuidSyncTypeRedirect:
+		return s.forceSyncType
+	default:
+		return ""
+	}
+}

usersync/syncer_test.go

@@ -27,6 +27,7 @@ func TestNewSyncer(t *testing.T) {
 		givenIFrameConfig   *config.SyncerEndpoint
 		givenRedirectConfig *config.SyncerEndpoint
 		givenExternalURL    string
+		givenForceType      string
 		expectedError       string
 		expectedDefault     SyncType
 		expectedIFrame      string
@@ -97,6 +98,7 @@ func TestNewSyncer(t *testing.T) {
 			givenExternalURL:    "http://syncer.com",
 			givenIFrameConfig:   iframeConfig,
 			givenRedirectConfig: redirectConfig,
+			givenForceType:      "i",
 			expectedDefault:     SyncTypeIFrame,
 			expectedIFrame:      "https://bidder.com/iframe?redirect=http%3A%2F%2Fsyncer.com%2Fhost",
 			expectedRedirect:    "https://bidder.com/redirect?redirect=http%3A%2F%2Fsyncer.com%2Fhost",
@@ -105,11 +107,12 @@ func TestNewSyncer(t *testing.T) {
 
 	for _, test := range testCases {
 		syncerConfig := config.Syncer{
-			Key:         test.givenKey,
-			SupportCORS: &supportCORS,
-			IFrame:      test.givenIFrameConfig,
-			Redirect:    test.givenRedirectConfig,
-			ExternalURL: test.givenExternalURL,
+			Key:           test.givenKey,
+			SupportCORS:   &supportCORS,
+			IFrame:        test.givenIFrameConfig,
+			Redirect:      test.givenRedirectConfig,
+			ExternalURL:   test.givenExternalURL,
+			ForceSyncType: test.givenForceType,
 		}
 
 		result, err := NewSyncer(hostConfig, syncerConfig, test.givenBidderName)
@@ -120,6 +123,7 @@ func TestNewSyncer(t *testing.T) {
 				result := result.(standardSyncer)
 				assert.Equal(t, test.givenKey, result.key, test.description+":key")
 				assert.Equal(t, supportCORS, result.supportCORS, test.description+":cors")
+				assert.Equal(t, test.givenForceType, result.forceSyncType, test.description+":cors")
 				assert.Equal(t, test.expectedDefault, result.defaultSyncType, test.description+":default_sync")
 
 				if test.expectedIFrame == "" {
@@ -779,3 +783,32 @@ func TestSyncerChooseTemplate(t *testing.T) {
 		assert.Equal(t, test.expectedTemplate, result, test.description)
 	}
 }
+
+func TestSyncerForceResponseFormat(t *testing.T) {
+	testCases := []struct {
+		description       string
+		givenForceType    string
+		expectedForceType string
+	}{
+		{
+			description:       "IFrame",
+			givenForceType:    "b",
+			expectedForceType: "b",
+		},
+		{
+			description:       "Redirect",
+			givenForceType:    "i",
+			expectedForceType: "i",
+		},
+		{
+			description:       "Empty",
+			expectedForceType: "",
+		},
+	}
+
+	for _, test := range testCases {
+		syncer := standardSyncer{forceSyncType: test.givenForceType}
+		forceType := syncer.ForceResponseFormat()
+		assert.Equal(t, test.expectedForceType, forceType, test.description)
+	}
+}