github.com/prebid/prebid-server@v0.275.0/privacy/enforcement_test.go (about)

     1  package privacy
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/prebid/openrtb/v19/openrtb2"
     7  	"github.com/stretchr/testify/assert"
     8  	"github.com/stretchr/testify/mock"
     9  )
    10  
    11  func TestAnyLegacy(t *testing.T) {
    12  	testCases := []struct {
    13  		enforcement Enforcement
    14  		expected    bool
    15  		description string
    16  	}{
    17  		{
    18  			description: "All False",
    19  			enforcement: Enforcement{
    20  				CCPA:    false,
    21  				COPPA:   false,
    22  				GDPRGeo: false,
    23  				GDPRID:  false,
    24  				LMT:     false,
    25  			},
    26  			expected: false,
    27  		},
    28  		{
    29  			description: "All True",
    30  			enforcement: Enforcement{
    31  				CCPA:    true,
    32  				COPPA:   true,
    33  				GDPRGeo: true,
    34  				GDPRID:  true,
    35  				LMT:     true,
    36  			},
    37  			expected: true,
    38  		},
    39  		{
    40  			description: "Mixed",
    41  			enforcement: Enforcement{
    42  				CCPA:    false,
    43  				COPPA:   true,
    44  				GDPRGeo: false,
    45  				GDPRID:  false,
    46  				LMT:     true,
    47  			},
    48  			expected: true,
    49  		},
    50  	}
    51  
    52  	for _, test := range testCases {
    53  		result := test.enforcement.AnyLegacy()
    54  		assert.Equal(t, test.expected, result, test.description)
    55  	}
    56  }
    57  
    58  func TestApplyGDPR(t *testing.T) {
    59  	testCases := []struct {
    60  		description        string
    61  		enforcement        Enforcement
    62  		expectedDeviceID   ScrubStrategyDeviceID
    63  		expectedDeviceIPv4 ScrubStrategyIPV4
    64  		expectedDeviceIPv6 ScrubStrategyIPV6
    65  		expectedDeviceGeo  ScrubStrategyGeo
    66  		expectedUser       ScrubStrategyUser
    67  		expectedUserGeo    ScrubStrategyGeo
    68  	}{
    69  		{
    70  			description: "All Enforced",
    71  			enforcement: Enforcement{
    72  				CCPA:    true,
    73  				COPPA:   true,
    74  				GDPRGeo: true,
    75  				GDPRID:  true,
    76  				LMT:     true,
    77  			},
    78  			expectedDeviceID:   ScrubStrategyDeviceIDAll,
    79  			expectedDeviceIPv4: ScrubStrategyIPV4Subnet,
    80  			expectedDeviceIPv6: ScrubStrategyIPV6Subnet,
    81  			expectedDeviceGeo:  ScrubStrategyGeoFull,
    82  			expectedUser:       ScrubStrategyUserIDAndDemographic,
    83  			expectedUserGeo:    ScrubStrategyGeoFull,
    84  		},
    85  		{
    86  			description: "CCPA Only",
    87  			enforcement: Enforcement{
    88  				CCPA:    true,
    89  				COPPA:   false,
    90  				GDPRGeo: false,
    91  				GDPRID:  false,
    92  				LMT:     false,
    93  			},
    94  			expectedDeviceID:   ScrubStrategyDeviceIDAll,
    95  			expectedDeviceIPv4: ScrubStrategyIPV4Subnet,
    96  			expectedDeviceIPv6: ScrubStrategyIPV6Subnet,
    97  			expectedDeviceGeo:  ScrubStrategyGeoReducedPrecision,
    98  			expectedUser:       ScrubStrategyUserIDAndDemographic,
    99  			expectedUserGeo:    ScrubStrategyGeoReducedPrecision,
   100  		},
   101  		{
   102  			description: "COPPA Only",
   103  			enforcement: Enforcement{
   104  				CCPA:    false,
   105  				COPPA:   true,
   106  				GDPRGeo: false,
   107  				GDPRID:  false,
   108  				LMT:     false,
   109  			},
   110  			expectedDeviceID:   ScrubStrategyDeviceIDAll,
   111  			expectedDeviceIPv4: ScrubStrategyIPV4Subnet,
   112  			expectedDeviceIPv6: ScrubStrategyIPV6Subnet,
   113  			expectedDeviceGeo:  ScrubStrategyGeoFull,
   114  			expectedUser:       ScrubStrategyUserIDAndDemographic,
   115  			expectedUserGeo:    ScrubStrategyGeoFull,
   116  		},
   117  		{
   118  			description: "GDPR Only - Full",
   119  			enforcement: Enforcement{
   120  				CCPA:    false,
   121  				COPPA:   false,
   122  				GDPRGeo: true,
   123  				GDPRID:  true,
   124  				LMT:     false,
   125  			},
   126  			expectedDeviceID:   ScrubStrategyDeviceIDAll,
   127  			expectedDeviceIPv4: ScrubStrategyIPV4Subnet,
   128  			expectedDeviceIPv6: ScrubStrategyIPV6Subnet,
   129  			expectedDeviceGeo:  ScrubStrategyGeoReducedPrecision,
   130  			expectedUser:       ScrubStrategyUserIDAndDemographic,
   131  			expectedUserGeo:    ScrubStrategyGeoReducedPrecision,
   132  		},
   133  		{
   134  			description: "GDPR Only - ID Only",
   135  			enforcement: Enforcement{
   136  				CCPA:    false,
   137  				COPPA:   false,
   138  				GDPRGeo: false,
   139  				GDPRID:  true,
   140  				LMT:     false,
   141  			},
   142  			expectedDeviceID:   ScrubStrategyDeviceIDAll,
   143  			expectedDeviceIPv4: ScrubStrategyIPV4None,
   144  			expectedDeviceIPv6: ScrubStrategyIPV6None,
   145  			expectedDeviceGeo:  ScrubStrategyGeoNone,
   146  			expectedUser:       ScrubStrategyUserIDAndDemographic,
   147  			expectedUserGeo:    ScrubStrategyGeoNone,
   148  		},
   149  		{
   150  			description: "GDPR Only - Geo Only",
   151  			enforcement: Enforcement{
   152  				CCPA:    false,
   153  				COPPA:   false,
   154  				GDPRGeo: true,
   155  				GDPRID:  false,
   156  				LMT:     false,
   157  			},
   158  			expectedDeviceID:   ScrubStrategyDeviceIDNone,
   159  			expectedDeviceIPv4: ScrubStrategyIPV4Subnet,
   160  			expectedDeviceIPv6: ScrubStrategyIPV6Subnet,
   161  			expectedDeviceGeo:  ScrubStrategyGeoReducedPrecision,
   162  			expectedUser:       ScrubStrategyUserNone,
   163  			expectedUserGeo:    ScrubStrategyGeoReducedPrecision,
   164  		},
   165  		{
   166  			description: "LMT Only",
   167  			enforcement: Enforcement{
   168  				CCPA:    false,
   169  				COPPA:   false,
   170  				GDPRGeo: false,
   171  				GDPRID:  false,
   172  				LMT:     true,
   173  			},
   174  			expectedDeviceID:   ScrubStrategyDeviceIDAll,
   175  			expectedDeviceIPv4: ScrubStrategyIPV4Subnet,
   176  			expectedDeviceIPv6: ScrubStrategyIPV6Subnet,
   177  			expectedDeviceGeo:  ScrubStrategyGeoReducedPrecision,
   178  			expectedUser:       ScrubStrategyUserIDAndDemographic,
   179  			expectedUserGeo:    ScrubStrategyGeoReducedPrecision,
   180  		},
   181  		{
   182  			description: "Interactions: COPPA + GDPR Full",
   183  			enforcement: Enforcement{
   184  				CCPA:    false,
   185  				COPPA:   true,
   186  				GDPRGeo: true,
   187  				GDPRID:  true,
   188  				LMT:     false,
   189  			},
   190  			expectedDeviceID:   ScrubStrategyDeviceIDAll,
   191  			expectedDeviceIPv4: ScrubStrategyIPV4Subnet,
   192  			expectedDeviceIPv6: ScrubStrategyIPV6Subnet,
   193  			expectedDeviceGeo:  ScrubStrategyGeoFull,
   194  			expectedUser:       ScrubStrategyUserIDAndDemographic,
   195  			expectedUserGeo:    ScrubStrategyGeoFull,
   196  		},
   197  	}
   198  
   199  	for _, test := range testCases {
   200  		req := &openrtb2.BidRequest{
   201  			Device: &openrtb2.Device{},
   202  			User:   &openrtb2.User{},
   203  		}
   204  		replacedDevice := &openrtb2.Device{}
   205  		replacedUser := &openrtb2.User{}
   206  
   207  		m := &mockScrubber{}
   208  		m.On("ScrubDevice", req.Device, test.expectedDeviceID, test.expectedDeviceIPv4, test.expectedDeviceIPv6, test.expectedDeviceGeo).Return(replacedDevice).Once()
   209  		m.On("ScrubUser", req.User, test.expectedUser, test.expectedUserGeo).Return(replacedUser).Once()
   210  
   211  		test.enforcement.apply(req, m)
   212  
   213  		m.AssertExpectations(t)
   214  		assert.Same(t, replacedDevice, req.Device, "Device")
   215  		assert.Same(t, replacedUser, req.User, "User")
   216  	}
   217  }
   218  
   219  func TestApplyToggle(t *testing.T) {
   220  	testCases := []struct {
   221  		description                  string
   222  		enforcement                  Enforcement
   223  		expectedScrubRequestExecuted bool
   224  		expectedScrubUserExecuted    bool
   225  		expectedScrubDeviceExecuted  bool
   226  	}{
   227  		{
   228  			description: "All enforced - only ScrubRequest execution expected",
   229  			enforcement: Enforcement{
   230  				CCPA:       true,
   231  				COPPA:      true,
   232  				GDPRGeo:    true,
   233  				GDPRID:     true,
   234  				LMT:        true,
   235  				UFPD:       true,
   236  				Eids:       true,
   237  				PreciseGeo: true,
   238  				TID:        true,
   239  			},
   240  			expectedScrubRequestExecuted: true,
   241  			expectedScrubUserExecuted:    false,
   242  			expectedScrubDeviceExecuted:  false,
   243  		},
   244  		{
   245  			description: "All Legacy and no activities - ScrubUser and ScrubDevice execution expected",
   246  			enforcement: Enforcement{
   247  				CCPA:       true,
   248  				COPPA:      true,
   249  				GDPRGeo:    true,
   250  				GDPRID:     true,
   251  				LMT:        true,
   252  				UFPD:       false,
   253  				Eids:       false,
   254  				PreciseGeo: false,
   255  				TID:        false,
   256  			},
   257  			expectedScrubRequestExecuted: false,
   258  			expectedScrubUserExecuted:    true,
   259  			expectedScrubDeviceExecuted:  true,
   260  		},
   261  		{
   262  			description: "Some Legacy and some activities - ScrubRequest, ScrubUser and ScrubDevice execution expected",
   263  			enforcement: Enforcement{
   264  				CCPA:       true,
   265  				COPPA:      true,
   266  				GDPRGeo:    true,
   267  				GDPRID:     true,
   268  				LMT:        true,
   269  				UFPD:       true,
   270  				Eids:       false,
   271  				PreciseGeo: false,
   272  				TID:        false,
   273  			},
   274  			expectedScrubRequestExecuted: true,
   275  			expectedScrubUserExecuted:    true,
   276  			expectedScrubDeviceExecuted:  true,
   277  		},
   278  		{
   279  			description: "Some Legacy and some activities - ScrubRequest execution expected",
   280  			enforcement: Enforcement{
   281  				CCPA:       true,
   282  				COPPA:      true,
   283  				GDPRGeo:    true,
   284  				GDPRID:     true,
   285  				LMT:        true,
   286  				UFPD:       true,
   287  				Eids:       true,
   288  				PreciseGeo: true,
   289  				TID:        false,
   290  			},
   291  			expectedScrubRequestExecuted: true,
   292  			expectedScrubUserExecuted:    false,
   293  			expectedScrubDeviceExecuted:  false,
   294  		},
   295  		{
   296  			description: "Some Legacy and some activities overlap - ScrubRequest and ScrubUser execution expected",
   297  			enforcement: Enforcement{
   298  				CCPA:       true,
   299  				COPPA:      true,
   300  				GDPRGeo:    true,
   301  				GDPRID:     true,
   302  				LMT:        true,
   303  				UFPD:       true,
   304  				Eids:       false,
   305  				PreciseGeo: true,
   306  				TID:        false,
   307  			},
   308  			expectedScrubRequestExecuted: true,
   309  			expectedScrubUserExecuted:    true,
   310  			expectedScrubDeviceExecuted:  false,
   311  		},
   312  	}
   313  
   314  	for _, test := range testCases {
   315  		t.Run(test.description, func(t *testing.T) {
   316  			req := &openrtb2.BidRequest{
   317  				Device: &openrtb2.Device{},
   318  				User:   &openrtb2.User{},
   319  			}
   320  			replacedDevice := &openrtb2.Device{}
   321  			replacedUser := &openrtb2.User{}
   322  
   323  			m := &mockScrubber{}
   324  
   325  			if test.expectedScrubRequestExecuted {
   326  				m.On("ScrubRequest", req, test.enforcement).Return(req).Once()
   327  			}
   328  			if test.expectedScrubUserExecuted {
   329  				m.On("ScrubUser", req.User, ScrubStrategyUserIDAndDemographic, ScrubStrategyGeoFull).Return(replacedUser).Once()
   330  			}
   331  			if test.expectedScrubDeviceExecuted {
   332  				m.On("ScrubDevice", req.Device, ScrubStrategyDeviceIDAll, ScrubStrategyIPV4Subnet, ScrubStrategyIPV6Subnet, ScrubStrategyGeoFull).Return(replacedDevice).Once()
   333  			}
   334  
   335  			test.enforcement.apply(req, m)
   336  
   337  			m.AssertExpectations(t)
   338  
   339  		})
   340  	}
   341  }
   342  
   343  func TestApplyNoneApplicable(t *testing.T) {
   344  	req := &openrtb2.BidRequest{}
   345  
   346  	m := &mockScrubber{}
   347  
   348  	enforcement := Enforcement{
   349  		CCPA:    false,
   350  		COPPA:   false,
   351  		GDPRGeo: false,
   352  		GDPRID:  false,
   353  		LMT:     false,
   354  
   355  		UFPD:       false,
   356  		PreciseGeo: false,
   357  		TID:        false,
   358  		Eids:       false,
   359  	}
   360  	enforcement.apply(req, m)
   361  
   362  	m.AssertNotCalled(t, "ScrubDevice")
   363  	m.AssertNotCalled(t, "ScrubUser")
   364  }
   365  
   366  func TestApplyNil(t *testing.T) {
   367  	m := &mockScrubber{}
   368  
   369  	enforcement := Enforcement{}
   370  	enforcement.apply(nil, m)
   371  
   372  	m.AssertNotCalled(t, "ScrubDevice")
   373  	m.AssertNotCalled(t, "ScrubUser")
   374  }
   375  
   376  type mockScrubber struct {
   377  	mock.Mock
   378  }
   379  
   380  func (m *mockScrubber) ScrubRequest(bidRequest *openrtb2.BidRequest, enforcement Enforcement) *openrtb2.BidRequest {
   381  	args := m.Called(bidRequest, enforcement)
   382  	return args.Get(0).(*openrtb2.BidRequest)
   383  }
   384  
   385  func (m *mockScrubber) ScrubDevice(device *openrtb2.Device, id ScrubStrategyDeviceID, ipv4 ScrubStrategyIPV4, ipv6 ScrubStrategyIPV6, geo ScrubStrategyGeo) *openrtb2.Device {
   386  	args := m.Called(device, id, ipv4, ipv6, geo)
   387  	return args.Get(0).(*openrtb2.Device)
   388  }
   389  
   390  func (m *mockScrubber) ScrubUser(user *openrtb2.User, strategy ScrubStrategyUser, geo ScrubStrategyGeo) *openrtb2.User {
   391  	args := m.Called(user, strategy, geo)
   392  	return args.Get(0).(*openrtb2.User)
   393  }