Remove unused code, update tests

config/bidderinfo.go

@@ -209,6 +209,11 @@ type InfoReaderFromDisk struct {
 	Path string
 }
 
+const (
+	ResponseFormatIFrame   = "b" // b = blank HTML response
+	ResponseFormatRedirect = "i" // i = image response
+)
+
 func (r InfoReaderFromDisk) Read() (map[string][]byte, error) {
 	bidderConfigs, err := os.ReadDir(r.Path)
 	if err != nil {
@@ -565,6 +570,10 @@ func validateSyncer(bidderInfo BidderInfo) error {
 		return nil
 	}
 
+	if bidderInfo.Syncer.FormatOverride != ResponseFormatIFrame && bidderInfo.Syncer.FormatOverride != ResponseFormatRedirect && bidderInfo.Syncer.FormatOverride != "" {
+		return fmt.Errorf("syncer could not be created, invalid FormatOverride value: %s", bidderInfo.Syncer.FormatOverride)
+	}
+
 	for _, supports := range bidderInfo.Syncer.Supports {
 		if !strings.EqualFold(supports, "iframe") && !strings.EqualFold(supports, "redirect") {
 			return fmt.Errorf("syncer could not be created, invalid supported endpoint: %s", supports)

config/bidderinfo_test.go

@@ -593,6 +593,7 @@ func TestBidderInfoValidationPositive(t *testing.T) {
 					URL:       "http://bidderB.com/usersync",
 					UserMacro: "UID",
 				},
+				FormatOverride: ResponseFormatRedirect,
 			},
 		},
 		"bidderC": BidderInfo{
@@ -627,6 +628,9 @@ func TestBidderInfoValidationPositive(t *testing.T) {
 					},
 				},
 			},
+			Syncer: &Syncer{
+				FormatOverride: ResponseFormatIFrame,
+			},
 		},
 	}
 	errs := bidderInfos.validate(make([]error, 0))
@@ -1318,6 +1322,37 @@ func TestBidderInfoValidationNegative(t *testing.T) {
 				errors.New("parent bidder: bidderC not found for an alias: bidderB"),
 			},
 		},
+		{
+			"Invalid format override value",
+			BidderInfos{
+				"bidderB": BidderInfo{
+					Endpoint: "http://bidderA.com/openrtb2",
+					Maintainer: &MaintainerInfo{
+						Email: "[email protected]",
+					},
+					Capabilities: &CapabilitiesInfo{
+						App: &PlatformInfo{
+							MediaTypes: []openrtb_ext.BidType{
+								openrtb_ext.BidTypeBanner,
+								openrtb_ext.BidTypeNative,
+							},
+						},
+						Site: &PlatformInfo{
+							MediaTypes: []openrtb_ext.BidType{
+								openrtb_ext.BidTypeBanner,
+								openrtb_ext.BidTypeNative,
+							},
+						},
+					},
+					Syncer: &Syncer{
+						FormatOverride: "x",
+					},
+				},
+			},
+			[]error{
+				errors.New("syncer could not be created, invalid FormatOverride value: x"),
+			},
+		},
 	}
 
 	for _, test := range testCases {

usersync/syncer.go

@@ -53,11 +53,6 @@ type standardSyncer struct {
 	formatOverride  string
 }
 
-const (
-	setuidSyncTypeIFrame   = "b" // b = blank HTML response
-	setuidSyncTypeRedirect = "i" // i = image response
-)
-
 // NewSyncer creates a new Syncer from the provided configuration, or return an error if macro substition
 // fails or an endpoint url is invalid.
 func NewSyncer(hostConfig config.UserSync, syncerConfig config.Syncer, bidder string) (Syncer, error) {
@@ -78,7 +73,7 @@ func NewSyncer(hostConfig config.UserSync, syncerConfig config.Syncer, bidder st
 
 	if syncerConfig.IFrame != nil {
 		var err error
-		syncer.iframe, err = buildTemplate(bidder, setuidSyncTypeIFrame, hostConfig, syncerConfig.ExternalURL, *syncerConfig.IFrame, syncerConfig.FormatOverride)
+		syncer.iframe, err = buildTemplate(bidder, config.ResponseFormatIFrame, hostConfig, syncerConfig.ExternalURL, *syncerConfig.IFrame, syncerConfig.FormatOverride)
 		if err != nil {
 			return nil, fmt.Errorf("iframe %v", err)
 		}
@@ -89,7 +84,7 @@ func NewSyncer(hostConfig config.UserSync, syncerConfig config.Syncer, bidder st
 
 	if syncerConfig.Redirect != nil {
 		var err error
-		syncer.redirect, err = buildTemplate(bidder, setuidSyncTypeRedirect, hostConfig, syncerConfig.ExternalURL, *syncerConfig.Redirect, syncerConfig.FormatOverride)
+		syncer.redirect, err = buildTemplate(bidder, config.ResponseFormatRedirect, hostConfig, syncerConfig.ExternalURL, *syncerConfig.Redirect, syncerConfig.FormatOverride)
 		if err != nil {
 			return nil, fmt.Errorf("redirect %v", err)
 		}
@@ -197,9 +192,9 @@ func (s standardSyncer) Key() string {
 
 func (s standardSyncer) DefaultResponseFormat() SyncType {
 	switch s.formatOverride {
-	case setuidSyncTypeIFrame:
+	case config.ResponseFormatIFrame:
 		return SyncTypeIFrame
-	case setuidSyncTypeRedirect:
+	case config.ResponseFormatRedirect:
 		return SyncTypeRedirect
 	default:
 		return s.defaultSyncType
@@ -279,14 +274,3 @@ func (s standardSyncer) chooseTemplate(syncType SyncType) *template.Template {
 		return nil
 	}
 }
-
-func (s standardSyncer) ForceResponseFormat() string {
-	switch s.formatOverride {
-	case setuidSyncTypeIFrame:
-		return s.formatOverride
-	case setuidSyncTypeRedirect:
-		return s.formatOverride
-	default:
-		return ""
-	}
-}

usersync/syncer_test.go

@@ -484,6 +484,35 @@ func TestSyncerDefaultSyncType(t *testing.T) {
 	assert.Equal(t, SyncTypeRedirect, syncer.DefaultResponseFormat())
 }
 
+func TestSyncerDefaultResponseFormat(t *testing.T) {
+	testCases := []struct {
+		description      string
+		givenSyncer      standardSyncer
+		expectedSyncType SyncType
+	}{
+		{
+			description:      "IFrame",
+			givenSyncer:      standardSyncer{formatOverride: config.ResponseFormatIFrame},
+			expectedSyncType: SyncTypeIFrame,
+		},
+		{
+			description:      "Default with Redirect Override",
+			givenSyncer:      standardSyncer{defaultSyncType: SyncTypeIFrame, formatOverride: config.ResponseFormatRedirect},
+			expectedSyncType: SyncTypeRedirect,
+		},
+		{
+			description:      "Default with no override",
+			givenSyncer:      standardSyncer{defaultSyncType: SyncTypeRedirect},
+			expectedSyncType: SyncTypeRedirect,
+		},
+	}
+
+	for _, test := range testCases {
+		syncType := test.givenSyncer.DefaultResponseFormat()
+		assert.Equal(t, test.expectedSyncType, syncType, test.description)
+	}
+}
+
 func TestSyncerSupportsType(t *testing.T) {
 	endpointTemplate := template.Must(template.New("test").Parse("iframe"))
 
@@ -780,32 +809,3 @@ 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{formatOverride: test.givenForceType}
-		forceType := syncer.ForceResponseFormat()
-		assert.Equal(t, test.expectedForceType, forceType, test.description)
-	}
-}