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

     1  package privacy
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/prebid/prebid-server/config"
     7  	"github.com/prebid/prebid-server/openrtb_ext"
     8  	"github.com/prebid/prebid-server/util/ptrutil"
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  func TestNewActivityControl(t *testing.T) {
    13  	testCases := []struct {
    14  		name            string
    15  		privacyConf     config.AccountPrivacy
    16  		activityControl ActivityControl
    17  	}{
    18  		{
    19  			name:            "empty",
    20  			privacyConf:     config.AccountPrivacy{},
    21  			activityControl: ActivityControl{plans: nil},
    22  		},
    23  		{
    24  			name: "specified_and_correct",
    25  			privacyConf: config.AccountPrivacy{
    26  				AllowActivities: &config.AllowActivities{
    27  					SyncUser:                 getTestActivityConfig(true),
    28  					FetchBids:                getTestActivityConfig(true),
    29  					EnrichUserFPD:            getTestActivityConfig(true),
    30  					ReportAnalytics:          getTestActivityConfig(true),
    31  					TransmitUserFPD:          getTestActivityConfig(true),
    32  					TransmitPreciseGeo:       getTestActivityConfig(false),
    33  					TransmitUniqueRequestIds: getTestActivityConfig(true),
    34  					TransmitTids:             getTestActivityConfig(true),
    35  				},
    36  			},
    37  			activityControl: ActivityControl{plans: map[Activity]ActivityPlan{
    38  				ActivitySyncUser:                 getTestActivityPlan(ActivityAllow),
    39  				ActivityFetchBids:                getTestActivityPlan(ActivityAllow),
    40  				ActivityEnrichUserFPD:            getTestActivityPlan(ActivityAllow),
    41  				ActivityReportAnalytics:          getTestActivityPlan(ActivityAllow),
    42  				ActivityTransmitUserFPD:          getTestActivityPlan(ActivityAllow),
    43  				ActivityTransmitPreciseGeo:       getTestActivityPlan(ActivityDeny),
    44  				ActivityTransmitUniqueRequestIDs: getTestActivityPlan(ActivityAllow),
    45  				ActivityTransmitTIDs:             getTestActivityPlan(ActivityAllow),
    46  			}},
    47  		},
    48  	}
    49  
    50  	for _, test := range testCases {
    51  		t.Run(test.name, func(t *testing.T) {
    52  			actualAC := NewActivityControl(&test.privacyConf)
    53  			assert.Equal(t, test.activityControl, actualAC)
    54  		})
    55  	}
    56  }
    57  
    58  func TestCfgToDefaultResult(t *testing.T) {
    59  	testCases := []struct {
    60  		name            string
    61  		activityDefault *bool
    62  		expectedResult  bool
    63  	}{
    64  		{
    65  			name:            "nil",
    66  			activityDefault: nil,
    67  			expectedResult:  true,
    68  		},
    69  		{
    70  			name:            "true",
    71  			activityDefault: ptrutil.ToPtr(true),
    72  			expectedResult:  true,
    73  		},
    74  		{
    75  			name:            "false",
    76  			activityDefault: ptrutil.ToPtr(false),
    77  			expectedResult:  false,
    78  		},
    79  	}
    80  
    81  	for _, test := range testCases {
    82  		t.Run(test.name, func(t *testing.T) {
    83  			actualResult := cfgToDefaultResult(test.activityDefault)
    84  			assert.Equal(t, test.expectedResult, actualResult)
    85  		})
    86  	}
    87  }
    88  
    89  func TestActivityControlAllow(t *testing.T) {
    90  	testCases := []struct {
    91  		name            string
    92  		activityControl ActivityControl
    93  		activity        Activity
    94  		target          Component
    95  		activityResult  bool
    96  	}{
    97  		{
    98  			name:            "plans_is_nil",
    99  			activityControl: ActivityControl{plans: nil},
   100  			activity:        ActivityFetchBids,
   101  			target:          Component{Type: "bidder", Name: "bidderA"},
   102  			activityResult:  true,
   103  		},
   104  		{
   105  			name: "activity_not_defined",
   106  			activityControl: ActivityControl{plans: map[Activity]ActivityPlan{
   107  				ActivitySyncUser: getTestActivityPlan(ActivityAllow)}},
   108  			activity:       ActivityFetchBids,
   109  			target:         Component{Type: "bidder", Name: "bidderA"},
   110  			activityResult: true,
   111  		},
   112  		{
   113  			name: "activity_defined_but_not_found_default_returned",
   114  			activityControl: ActivityControl{plans: map[Activity]ActivityPlan{
   115  				ActivityFetchBids: getTestActivityPlan(ActivityAllow)}},
   116  			activity:       ActivityFetchBids,
   117  			target:         Component{Type: "bidder", Name: "bidderB"},
   118  			activityResult: true,
   119  		},
   120  		{
   121  			name: "activity_defined_and_allowed",
   122  			activityControl: ActivityControl{plans: map[Activity]ActivityPlan{
   123  				ActivityFetchBids: getTestActivityPlan(ActivityAllow)}},
   124  			activity:       ActivityFetchBids,
   125  			target:         Component{Type: "bidder", Name: "bidderA"},
   126  			activityResult: true,
   127  		},
   128  	}
   129  
   130  	for _, test := range testCases {
   131  		t.Run(test.name, func(t *testing.T) {
   132  			actualResult := test.activityControl.Allow(test.activity, test.target, ActivityRequest{})
   133  			assert.Equal(t, test.activityResult, actualResult)
   134  
   135  		})
   136  	}
   137  }
   138  
   139  func TestActivityRequest(t *testing.T) {
   140  	t.Run("empty", func(t *testing.T) {
   141  		r := ActivityRequest{}
   142  		assert.False(t, r.IsPolicies())
   143  		assert.False(t, r.IsBidRequest())
   144  	})
   145  
   146  	t.Run("policies", func(t *testing.T) {
   147  		r := NewRequestFromPolicies(Policies{})
   148  		assert.True(t, r.IsPolicies())
   149  		assert.False(t, r.IsBidRequest())
   150  	})
   151  
   152  	t.Run("request", func(t *testing.T) {
   153  		r := NewRequestFromBidRequest(openrtb_ext.RequestWrapper{})
   154  		assert.False(t, r.IsPolicies())
   155  		assert.True(t, r.IsBidRequest())
   156  	})
   157  }
   158  
   159  func getTestActivityConfig(allow bool) config.Activity {
   160  	return config.Activity{
   161  		Default: ptrutil.ToPtr(true),
   162  		Rules: []config.ActivityRule{
   163  			{
   164  				Allow: allow,
   165  				Condition: config.ActivityCondition{
   166  					ComponentName: []string{"bidderA"},
   167  					ComponentType: []string{"bidder"},
   168  				},
   169  			},
   170  		},
   171  	}
   172  }
   173  
   174  func getTestActivityPlan(result ActivityResult) ActivityPlan {
   175  	return ActivityPlan{
   176  		defaultResult: true,
   177  		rules: []Rule{
   178  			ConditionRule{
   179  				result:        result,
   180  				componentName: []string{"bidderA"},
   181  				componentType: []string{"bidder"},
   182  			},
   183  		},
   184  	}
   185  }